DOCSLIB.ORG

Implementing Extended Structural Synthesis of Programs

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

From: AAAI Technical Report SS-02-05. Compilation copyright © 2002, AAAI (www.aaai.org). All rights reserved. Implementing Extended Structural Synthesis of Programs Sven Lämmermann Enn Tyugu Department of Microelectronics and Information Estonian Business School Technology, KTH [email protected] [email protected] Abstract Our synthesis method is aimed at composing software from functions, including higher-order functions (which We discuss logic and specification language of a program are taking automatically synthesized functions as synthesizer for Java intended for dynamic synthesis of arguments, and can so representcontrolstructures, e.g. services. We introduce metainterfaces as logical loops and conditional statements). Higher-orderness specifications of classes. They can be used in two ways: as guarantees the generality of the method in principle – one specifications of computational usage of classes or as can preprogram a small set of higher order functions that specifications of new classes composed from metaclasses – the classes already supplied with metainterfaces. The are sufficient for representing any computable function. In specification language used has a straightforward translation practice, we use a specific set of preprogrammed functions into a restricted first-order constructive logic. New for every problem domain. These functions are programs are composed by a deductive synthesis method implemented as methods of classes written in Java. We close to the structural synthesis of programs. An example of distinguish three kinds of building blocks used in the composition of a transaction service is presented. software synthesis process: The smallest building blocks (we call them also Introduction modules) are methods; they are selected and connected automatically by the synthesizer. We discuss logic and specification language proposed in The next size blocks are Java classes representing an ongoing project aimed at the development of a program particular concepts. synthesizer for Java intended for dynamic synthesis of The largest are metaclasses that represent independent network services. A prototype of the synthesizer has software components and are specified declaratively. already shown good performance. In this project, we The software features we are going to express in logic prioritize the efficiency of proof search before the are the following: generality of the logical language. The method under Dataflow between pre-programmed modules consideration is deductive program synthesis. In essence, it Order of application of modules (control variables) is an extension of the structural program synthesis (SSP) Hierarchical data structures described already in (Mints and Tyugu 1982), and we call Usage of pre-programmed control structures it ESSP – extended structural synthesis of programs. (subtasks) Our discussion is related to two quite different Alternative outcome of modules, in particular knowledge domains: software composition and logic. In exception handling the introductiuon we briefly look at the features of Implicit linking of modules software that must be representable by the logic of the 1. Dataflow. Dataflow dependencies between pre- synthesizer. We explain here as well which features of programmed functions can be expressed simply by logic will be used to support the required software features, implications, where for each function there is an and show how the complexity of proof search depends on implication. On its left hand side is a conjunction of the features covered bythelogic. As expected, supporting propositions stating for each input variable (for each all desirable features of the software composition leads in argument) that the input is available and on the right had principle to exponential time complexity of the proof side is a conjunction of propositions stating for each output search. However, our proof search strategy enables us to variable that the output is computed. This conforms with construct a coarse-grained proof quite efficiently using the intuitionistic realizability of implications as functions admissible inference rules that correspond to actual and propositional variables as data. Consider the following applications of functions and control structures in example. Let f and g be modules with input variables a, b computations. We are still quite satisfied with the respectively, and output variables b, c respectively. Then efficiency of the application of the synthesizer to practical the logical descriptionofthedataflow will be A ⊃ B and problems. BC⊃ where A, B, C are propositions stating availability (computability) of variables a, b, c.Computability of c introduction of disjunctions on the right hand side of from a follows from derivability of C from A. implications. 2. Order of module application.Wearesometimes 6. Implicit selections and linking of software components. confronted with the situation where the order of module Our intention is to use the synthesizer for putting together application matters, but this is not determined by dataflow. large programs from components. We mean by a To overcome this problem, a logic must, in addition, component not just a function, but also a software include means to force a certain order of module configuration providing some useful functionality. We application. For instance, let the modules f and g from the expect to have libraries of components supporting various example above be two methods of a class D implemented problem domains, like packages in Java. So the problem of in an object oriented programming language. Before these automatic selection components appears. This requires a twomethods can be applied, a constructor d of the class D language where we can state that a component with must create an object of class D.Byadding a proposition, particular properties exists or, vice versa, it may be let’s say D (as an additional conjunct) to the right hand required. Hence, we need existential and universal side of the implication specifying the constructor d,and quantifiers. However, we can restrict the usage of adding the same proposition to the left hand sides of the quantifiers so that we will not need the whole power of implications specifying f and g,thecorrect order of first order logic. application is forced on the modules. Fortunately, this does Extended structural synthesis covers the features not require any extension of the logic compared to the discussed above as follows: logic of dataflow. Non-nested implications of conjunctions of 3. Hierarchical data structures. Hierarchical data propositions cover 1, 2, and 3, structures can be specified by means of structural relations Nested implications cover also 4, that bind a structure, e.g. x with its components, say Disjunctions cover 5, but can be reduced to nested x1,,… xk .The computational possibilities of this relation implications, ∧∧ ⊃ Restricted first-order logic covers 6. can be expressed by the implications XXX1 … k and The proof search for non-nested implications has linear XX⊃ ,for ik=1,… , where X and X denote again the i i time complexity. Adding nested implications gives us the computability of x and xi respectively. This does not general case of intuitionistic propositional logic, hence require extension of the logic used for expressing the exponential time complexity in general; however, we can dataflow. (Object-oriented environments mayrequiresome use a modal logic for nested implications and get simpler additional computations for obtaining a structured value, proof search, see (Mints 1991). In the case of first-order e.g. application of a constructor of a proper class.) logic we use quantifiers in a very restricted way, and hope 4. Usage of predefined control structures. As we have to keep the search manageable. noted already, some building blocks that have to be We have chosen Java as the language we extend, specified are higher order functions that take other because it is a widely used object-oriented language functions as input. A functional input f of a function g can suitable for implementing services in a network. be specified by an implication on the left hand side of the Components of services are represented as classes and implication specifying the function g.Forinstance, the interfaces. Special attention ispaid to handling exceptions formula ()IANS⊃∧⊃ specifies a function g with in Java in a logically sound way. Also handling arguments f and n that computes s,wherethefunction f can constructors requires special attention. This has required be any function computing a from i that is composed from some extension of the logic used in (Lämmermann 2000). given blocks. (The capital letters again denote the Considerable part of the presentation takes an example of computability of the variables denoted by the respective synthesis of a banking service implemented in our project. small letters.) Accepting nested implications as formulae is This example is introduced gradually by presenting Java an essential extension of the logical language. Indeed, any classes on various parts of the paper. propositional formula of the intuitionistic logic can be encoded by formulae of this language so that its derivability can be checkedinatheorywithin this Specifications as Metainterfaces implicative language, see for instance (Mints and Tyugu On the specification language side we introduce 1982). metainterfaces as logical specifications of classes. They 5. Alternative outcome of modules.Evenconsidering only can be used in two ways: as specifications
Recommended publications
  • Objects and Classes in Python Documentation Release 0.1

    Objects and Classes in Python Documentation Release 0.1

    Objects and classes in Python Documentation Release 0.1 Jonathan Fine Sep 27, 2017 Contents 1 Decorators 2 1.1 The decorator syntax.........................................2 1.2 Bound methods............................................3 1.3 staticmethod() .........................................3 1.4 classmethod() ..........................................3 1.5 The call() decorator.......................................4 1.6 Nesting decorators..........................................4 1.7 Class decorators before Python 2.6.................................5 2 Constructing classes 6 2.1 The empty class...........................................6 3 dict_from_class() 8 3.1 The __dict__ of the empty class...................................8 3.2 Is the doc-string part of the body?..................................9 3.3 Definition of dict_from_class() ...............................9 4 property_from_class() 10 4.1 About properties........................................... 10 4.2 Definition of property_from_class() ............................ 11 4.3 Using property_from_class() ................................ 11 4.4 Unwanted keys............................................ 11 5 Deconstructing classes 13 6 type(name, bases, dict) 14 6.1 Constructing the empty class..................................... 14 6.2 Constructing any class........................................ 15 6.3 Specifying __doc__, __name__ and __module__.......................... 15 7 Subclassing int 16 7.1 Mutable and immutable types.................................... 16 7.2
  • Propositional Logic - Basics

    Propositional Logic - Basics

    Outline Propositional Logic - Basics K. Subramani1 1Lane Department of Computer Science and Electrical Engineering West Virginia University 14 January and 16 January, 2013 Subramani Propositonal Logic Outline Outline 1 Statements, Symbolic Representations and Semantics Boolean Connectives and Semantics Subramani Propositonal Logic (i) The Law! (ii) Mathematics. (iii) Computer Science. Definition Statement (or Atomic Proposition) - A sentence that is either true or false. Example (i) The board is black. (ii) Are you John? (iii) The moon is made of green cheese. (iv) This statement is false. (Paradox). Statements, Symbolic Representations and Semantics Boolean Connectives and Semantics Motivation Why Logic? Subramani Propositonal Logic (ii) Mathematics. (iii) Computer Science. Definition Statement (or Atomic Proposition) - A sentence that is either true or false. Example (i) The board is black. (ii) Are you John? (iii) The moon is made of green cheese. (iv) This statement is false. (Paradox). Statements, Symbolic Representations and Semantics Boolean Connectives and Semantics Motivation Why Logic? (i) The Law! Subramani Propositonal Logic (iii) Computer Science. Definition Statement (or Atomic Proposition) - A sentence that is either true or false. Example (i) The board is black. (ii) Are you John? (iii) The moon is made of green cheese. (iv) This statement is false. (Paradox). Statements, Symbolic Representations and Semantics Boolean Connectives and Semantics Motivation Why Logic? (i) The Law! (ii) Mathematics. Subramani Propositonal Logic (iii) Computer Science. Definition Statement (or Atomic Proposition) - A sentence that is either true or false. Example (i) The board is black. (ii) Are you John? (iii) The moon is made of green cheese. (iv) This statement is false.
  • Csci 658-01: Software Language Engineering Python 3 Reflexive

    Csci 658-01: Software Language Engineering Python 3 Reflexive

    CSci 658-01: Software Language Engineering Python 3 Reflexive Metaprogramming Chapter 3 H. Conrad Cunningham 4 May 2018 Contents 3 Decorators and Metaclasses 2 3.1 Basic Function-Level Debugging . .2 3.1.1 Motivating example . .2 3.1.2 Abstraction Principle, staying DRY . .3 3.1.3 Function decorators . .3 3.1.4 Constructing a debug decorator . .4 3.1.5 Using the debug decorator . .6 3.1.6 Case study review . .7 3.1.7 Variations . .7 3.1.7.1 Logging . .7 3.1.7.2 Optional disable . .8 3.2 Extended Function-Level Debugging . .8 3.2.1 Motivating example . .8 3.2.2 Decorators with arguments . .9 3.2.3 Prefix decorator . .9 3.2.4 Reformulated prefix decorator . 10 3.3 Class-Level Debugging . 12 3.3.1 Motivating example . 12 3.3.2 Class-level debugger . 12 3.3.3 Variation: Attribute access debugging . 14 3.4 Class Hierarchy Debugging . 16 3.4.1 Motivating example . 16 3.4.2 Review of objects and types . 17 3.4.3 Class definition process . 18 3.4.4 Changing the metaclass . 20 3.4.5 Debugging using a metaclass . 21 3.4.6 Why metaclasses? . 22 3.5 Chapter Summary . 23 1 3.6 Exercises . 23 3.7 Acknowledgements . 23 3.8 References . 24 3.9 Terms and Concepts . 24 Copyright (C) 2018, H. Conrad Cunningham Professor of Computer and Information Science University of Mississippi 211 Weir Hall P.O. Box 1848 University, MS 38677 (662) 915-5358 Note: This chapter adapts David Beazley’s debugly example presentation from his Python 3 Metaprogramming tutorial at PyCon’2013 [Beazley 2013a].
  • The Use of UML for Software Requirements Expression and Management

    The Use of UML for Software Requirements Expression and Management

    The Use of UML for Software Requirements Expression and Management Alex Murray Ken Clark Jet Propulsion Laboratory Jet Propulsion Laboratory California Institute of Technology California Institute of Technology Pasadena, CA 91109 Pasadena, CA 91109 818-354-0111 818-393-6258 [email protected] [email protected] Abstract— It is common practice to write English-language 1. INTRODUCTION ”shall” statements to embody detailed software requirements in aerospace software applications. This paper explores the This work is being performed as part of the engineering of use of the UML language as a replacement for the English the flight software for the Laser Ranging Interferometer (LRI) language for this purpose. Among the advantages offered by the of the Gravity Recovery and Climate Experiment (GRACE) Unified Modeling Language (UML) is a high degree of clarity Follow-On (F-O) mission. However, rather than use the real and precision in the expression of domain concepts as well as project’s model to illustrate our approach in this paper, we architecture and design. Can this quality of UML be exploited have developed a separate, ”toy” model for use here, because for the definition of software requirements? this makes it easier to avoid getting bogged down in project details, and instead to focus on the technical approach to While expressing logical behavior, interface characteristics, requirements expression and management that is the subject timeliness constraints, and other constraints on software using UML is commonly done and relatively straight-forward, achiev- of this paper. ing the additional aspects of the expression and management of software requirements that stakeholders expect, especially There is one exception to this choice: we will describe our traceability, is far less so.
  • Metaclasses: Generative C++

    Metaclasses: Generative C++

    Metaclasses: Generative C++ Document Number: P0707 R3 Date: 2018-02-11 Reply-to: Herb Sutter ([email protected]) Audience: SG7, EWG Contents 1 Overview .............................................................................................................................................................2 2 Language: Metaclasses .......................................................................................................................................7 3 Library: Example metaclasses .......................................................................................................................... 18 4 Applying metaclasses: Qt moc and C++/WinRT .............................................................................................. 35 5 Alternatives for sourcedefinition transform syntax .................................................................................... 41 6 Alternatives for applying the transform .......................................................................................................... 43 7 FAQs ................................................................................................................................................................. 46 8 Revision history ............................................................................................................................................... 51 Major changes in R3: Switched to function-style declaration syntax per SG7 direction in Albuquerque (old: $class M new: constexpr void M(meta::type target,
  • Meta-Class Features for Large-Scale Object Categorization on a Budget

    Meta-Class Features for Large-Scale Object Categorization on a Budget

    Meta-Class Features for Large-Scale Object Categorization on a Budget Alessandro Bergamo Lorenzo Torresani Dartmouth College Hanover, NH, U.S.A. faleb, [email protected] Abstract cation accuracy over a predefined set of classes, and without consideration of the computational costs of the recognition. In this paper we introduce a novel image descriptor en- We believe that these two assumptions do not meet the abling accurate object categorization even with linear mod- requirements of modern applications of large-scale object els. Akin to the popular attribute descriptors, our feature categorization. For example, test-recognition efficiency is a vector comprises the outputs of a set of classifiers evaluated fundamental requirement to be able to scale object classi- on the image. However, unlike traditional attributes which fication to Web photo repositories, such as Flickr, which represent hand-selected object classes and predefined vi- are growing at rates of several millions new photos per sual properties, our features are learned automatically and day. Furthermore, while a fixed set of object classifiers can correspond to “abstract” categories, which we name meta- be used to annotate pictures with a set of predefined tags, classes. Each meta-class is a super-category obtained by the interactive nature of searching and browsing large im- grouping a set of object classes such that, collectively, they age collections calls for the ability to allow users to define are easy to distinguish from other sets of categories. By us- their own personal query categories to be recognized and ing “learnability” of the meta-classes as criterion for fea- retrieved from the database, ideally in real-time.
  • Metaclass Functions: Generative C++

    Metaclass Functions: Generative C++

    Metaclass functions: Generative C++ Document Number: P0707 R4 Date: 2019-06-16 Reply-to: Herb Sutter ([email protected]) Audience: SG7, EWG Contents 1 Overview .............................................................................................................................................................2 2 Language: “Metaclass” functions .......................................................................................................................6 3 Library: Example metaclasses .......................................................................................................................... 18 4 Applying metaclasses: Qt moc and C++/WinRT .............................................................................................. 35 5 FAQs ................................................................................................................................................................. 41 R4: • Updated notes in §1.3 to track the current prototype, which now also has consteval support. • Added using metaclass function in the class body. Abstract The only way to make a language more powerful, but also make its programs simpler, is by abstraction: adding well-chosen abstractions that let programmers replace manual code patterns with saying directly what they mean. There are two major categories: Elevate coding patterns/idioms into new abstractions built into the language. For example, in current C++, range-for lets programmers directly declare “for each” loops with compiler support and enforcement.
  • Middlesex University Research Repository

    Middlesex University Research Repository

    Middlesex University Research Repository An open access repository of Middlesex University research http://eprints.mdx.ac.uk Clark, Tony (1997) Metaclasses and reflection in smalltalk. Technical Report. University of Bradford. Available from Middlesex University’s Research Repository at http://eprints.mdx.ac.uk/6181/ Copyright: Middlesex University Research Repository makes the University’s research available electronically. Copyright and moral rights to this thesis/research project are retained by the author and/or other copyright owners. The work is supplied on the understanding that any use for commercial gain is strictly forbidden. A copy may be downloaded for personal, non-commercial, research or study without prior permission and without charge. Any use of the thesis/research project for private study or research must be properly acknowledged with reference to the work’s full bibliographic details. This thesis/research project may not be reproduced in any format or medium, or extensive quotations taken from it, or its content changed in any way, without first obtaining permission in writing from the copyright holder(s). If you believe that any material held in the repository infringes copyright law, please contact the Repository Team at Middlesex University via the following email address: [email protected] The item will be removed from the repository while any claim is being investigated. Metaclasses and Reection in Smalltalk A N Clark Department of Computing University of Bradford Bradford West Yorkshire BD DP UK email ANClarkcompbradacuk
  • 12 Propositional Logic

    12 Propositional Logic

    CHAPTER 12 ✦ ✦ ✦ ✦ Propositional Logic In this chapter, we introduce propositional logic, an algebra whose original purpose, dating back to Aristotle, was to model reasoning. In more recent times, this algebra, like many algebras, has proved useful as a design tool. For example, Chapter 13 shows how propositional logic can be used in computer circuit design. A third use of logic is as a data model for programming languages and systems, such as the language Prolog. Many systems for reasoning by computer, including theorem provers, program verifiers, and applications in the field of artificial intelligence, have been implemented in logic-based programming languages. These languages generally use “predicate logic,” a more powerful form of logic that extends the capabilities of propositional logic. We shall meet predicate logic in Chapter 14. ✦ ✦ ✦ ✦ 12.1 What This Chapter Is About Section 12.2 gives an intuitive explanation of what propositional logic is, and why it is useful. The next section, 12,3, introduces an algebra for logical expressions with Boolean-valued operands and with logical operators such as AND, OR, and NOT that Boolean algebra operate on Boolean (true/false) values. This algebra is often called Boolean algebra after George Boole, the logician who first framed logic as an algebra. We then learn the following ideas. ✦ Truth tables are a useful way to represent the meaning of an expression in logic (Section 12.4). ✦ We can convert a truth table to a logical expression for the same logical function (Section 12.5). ✦ The Karnaugh map is a useful tabular technique for simplifying logical expres- sions (Section 12.6).
  • The Basics of Exception Handling

    The Basics of Exception Handling

    The Basics of Exception Handling MIPS uses two coprocessors: C0 and C1 for additional help. C0 primarily helps with exception handling, and C1 helps with floating point arithmetic. Each coprocessor has a few registers. Interrupts Initiated outside the instruction stream Arrive asynchronously (at no specific time), Example: o I/O device status change o I/O device error condition Traps Occur due to something in instruction stream. Examples: o Unaligned address error o Arithmetic overflow o System call MIPS coprocessor C0 has a cause register (Register 13) that contains a 4-bit code to identify the cause of an exception Cause register pending exception code interrupt Bits 15-10 Bits 5-2 [Exception Code = 0 means I/O interrupt = 12 means arithmetic overflow etc] MIPS instructions that cause overflow (or some other violation) lead to an exception, which sets the exception code. It then switches to the kernel mode (designated by a bit in the status register of C0, register 12) and transfers control to a predefined address to invoke a routine (exception handler) for handling the exception. Interrupt Enable Status register Interrupt Mask 15-8 1 0 Kernel/User (EPC = Exception Program Counter, Reg 14 of C0) Memory L: add $t0, $t1, $t2 overflow! Return address (L+4) Exception handler routine is saved in EPC Next instruction Overflow ra ! EPC; jr ra Invalid instruction ra ! EPC; jr ra System Call ra ! EPC; jr ra The Exception Handler determines the cause of the exception by looking at the exception code bits. Then it jumps to the appropriate exception handling routine.
  • Adding the Everywhere Operator to Propositional Logic

    Adding the Everywhere Operator to Propositional Logic

    Adding the Everywhere Operator to Propositional Logic David Gries∗ and Fred B. Schneider† Computer Science Department, Cornell University Ithaca, New York 14853 USA September 25, 2002 Abstract Sound and complete modal propositional logic C is presented, in which 2P has the interpretation “ P is true in all states”. The interpretation is already known as the Carnapian extension of S5. A new axiomatization for C provides two insights. First, introducing an inference rule textual substitution allows seamless integration of the propositional and modal parts of the logic, giving a more practical system for writing formal proofs. Second, the two following approaches to axiomatizing a logic are shown to be not equivalent: (i) give axiom schemes that denote an infinite number of axioms and (ii) write a finite number of axioms in terms of propositional variables and introduce a substitution inference rule. 1Introduction Logic gives a syntactic way to derive or certify truths that can be expressed in the language of the logic. The expressiveness of the language impacts the logic’s utility —the more expressive the language, the more useful the logic (at least if the intended use is to prove theorems, as opposed to, say, studying logics). We wish to calculate with logic, much as one calculates in algebra to derive equations, and we find it useful for 2P to be a formula of the logic and have the meaning “ P is true in all states”. When a propositional logic extended with 2 is further extended to predicate logic and then to other theories, the logic can be used for proving theorems that could otherwise be ∗Supported by NSF grant CDA-9214957 and ARPA/ONR grant N00014-91-J-4123.
  • On the Logic of Left-Continuous T-Norms and Right-Continuous T-Conorms

    On the Logic of Left-Continuous T-Norms and Right-Continuous T-Conorms

    On the Logic of Left-Continuous t-Norms and Right-Continuous t-Conorms B Llu´ıs Godo1( ),Mart´ın S´ocola-Ramos2, and Francesc Esteva1 1 Artificial Intelligence Research Institute (IIIA-CSIC), Campus de la UAB, Bellaterra, 08193 Barcelona, Spain {godo,esteva}@iiia.csic.es 2 Juniv¨agen 13, 27172 K¨opingebro, Sweden [email protected] Abstract. Double residuated lattices are expansions of residuated lat- tices with an extra monoidal operator, playing the role of a strong dis- junction operation, together with its dual residuum. They were intro- duced by Orlowska and Radzikowska. In this paper we consider the subclass of double residuated structures that are expansions of MTL- algebras, that is, prelinear, bounded, commutative and integral residu- ated lattices. MTL-algebras constitute the algebraic semantics for the MTL logic, the system of mathematical fuzzy logic that is complete w.r.t. the class of residuated lattices on the real unit interval [0, 1] induced by left-continuous t-norms. Our aim is to axiomatise the logic whose intended semantics are commutative and integral double residu- ated structures on [0, 1], that are induced by an arbitrary left-continuous t-norm, an arbitrary right-continuous t-conorm, and their corresponding residual operations. Keywords: Mathematical fuzzy logic · Double residuated lattices · MTL · DMCTL · Semilinear logics · Standard completeness 1 Introduction Residuated lattices [7] are a usual choice for general algebras of truth-values in systems of mathematical fuzzy logic [1–3,9], as well as for valuation structures in lattice-valued fuzzy sets (L-fuzzy sets) [8] and in multiple-valued generalisations of information relations [11,13,14].