EM-Training for Weighted Aligned Hypergraph Bimorphisms

Total Page:16

File Type:pdf, Size:1020Kb

EM-Training for Weighted Aligned Hypergraph Bimorphisms EM-Training for Weighted Aligned Hypergraph Bimorphisms Frank Drewes Kilian Gebhardt and Heiko Vogler Department of Computing Science Department of Computer Science Umea˚ University Technische Universitat¨ Dresden S-901 87 Umea,˚ Sweden D-01062 Dresden, Germany [email protected] [email protected] [email protected] Abstract malized by the new concept of hybrid grammar. Much as in the mentioned synchronous grammars, We develop the concept of weighted a hybrid grammar synchronizes the derivations aligned hypergraph bimorphism where the of nonterminals of a string grammar, e.g., a lin- weights may, in particular, represent proba- ear context-free rewriting system (LCFRS) (Vijay- bilities. Such a bimorphism consists of an Shanker et al., 1987), and of nonterminals of a R 0-weighted regular tree grammar, two ≥ tree grammar, e.g., regular tree grammar (Brainerd, hypergraph algebras that interpret the gen- 1969) or simple definite-clause programs (sDCP) erated trees, and a family of alignments (Deransart and Małuszynski, 1985). Additionally it between the two interpretations. Seman- synchronizes terminal symbols, thereby establish- tically, this yields a set of bihypergraphs ing an explicit alignment between the positions of each consisting of two hypergraphs and the string and the nodes of the tree. We note that an explicit alignment between them; e.g., LCFRS/sDCP hybrid grammars can also generate discontinuous phrase structures and non- non-projective dependency structures. projective dependency structures are bihy- In this paper we focus on the task of training an pergraphs. We present an EM-training al- LCFRS/sDCP hybrid grammar, that is, assigning gorithm which takes a corpus of bihyper- probabilities to its rules given a corpus of discon- graphs and an aligned hypergraph bimor- tinuous phrase structures or non-projective depen- phism as input and generates a sequence dency structures. Since the alignments are first of weight assignments which converges to class citizens, we develop our approach in the a local maximum or saddle point of the general framework of hypergraphs and hyperedge likelihood function of the corpus. replacement (HR) (Habel, 1992). We define the concepts of bihypergraph (for short: bigraph) and 1 Introduction aligned HR bimorphism. A bigraph consists of In natural language processing alignments play an hypergraphs H1, λ, and H2, where λ represents important role. For instance, in machine translation the alignment between H1 and H2. A bimorphism they show up as hidden information when training = (g, , Λ, ) consists of a regular tree gram- B A1 A2 probabilities of dictionaries (Brown et al., 1993) or mar g generating trees over some ranked alphabet when considering pairs of input/output sentences Σ, two Σ-algebras and which interpret each A1 A2 derived by a synchronous grammar (Lewis and symbol in Σ as an HR operation (thus evaluating Stearns, 1968; Chiang, 2007; Shieber and Schabes, every tree to two hypergraphs), and a Σ-indexed 1990; Nederhof and Vogler, 2012). As another family Λ of alignments between the two interpreta- example, in language models for discontinuous tions of each σ Σ. The semantics of is a set of ∈ B phrase structures and non-projective dependency bigraphs. structures they can be used to capture the connec- For instance, each discontinuous phrase struc- tion between the words in a natural language sen- ture or non-projective dependency structure can be tence and the corresponding nodes of the parse tree represented as a bigraph (H1, λ, H2) where H1 and or dependency structure of that sentence. H2 correspond to the string component and the tree In (Nederhof and Vogler, 2014) the generation component, respectively. Fig. 1 shows an example of discontinuous phrase structures has been for- of a bigraph representing a non-projective depen- 60 Proceedings of the ACL Workshop on Statistical NLP and Weighted Automata, pages 60–69, Berlin, Germany, August 12, 2016. c 2016 Association for Computational Linguistics is . hearing scheduled A on today (a) issue the A hearing is scheduled on the issue today . (0) inp (0) out (y1 ) (y1 ) is . hearing scheduled H2 A on today (b) issue the λ A hearing is scheduled on the issue today . H1 (0) inp (0) out (y1 ) (y1 ) Figure 1: (a) A sentence with non-projective dependencies is represented in (b) by a bigraph (H1, λ, H2). Both hypergraphs H1 and H2 contain a distinct hyperedge (box) for each word of the sentence. H1 specifies the linear order on the words. H2 describes parent-child relationships between the words, where children form a list to whose start and end the parent has a tentacle. The alignment λ establishes a one-to-one correspondence between the (input vertices of the) hyperedges in H1 and H2. dency structure. We present each LCFRS/sDCP ities. We show that the complexity of construct- hybrid grammar as a particular aligned HR bimor- ing the reduct is polynomial in the size of g and phism; this establishes an initial algebra semantics (H , λ, H ) if is an LCFRS/sDCP hybrid gram- 1 2 B (Goguen et al., 1977) for hybrid grammars. mar. However, as the algorithm itself is not limited The flexibility of aligned HR bimorphisms goes to this situation, we expect it to be useful in other well beyond hybrid grammars as they generalize cases as well. the synchronous HR grammars of (Jones et al., 2012), making it possible to synchronously gen- 2 Preliminaries erate two graphs connected by explicit alignment Basic mathematical notation We denote the set structures. Thus, they can for instance model align- of natural numbers (including 0) by N and the set ments involving directed acyclic graphs like Ab- N 0 by N . For n N, we denote 1, . , n \{ } ∈ { } stract Meaning Representations (Banarescu et al., by [n]. An alphabet A is a finite set of symbols. 2013) or Millstream systems (Bensch et al., 2014). We denote the set of all strings over A by A∗, the Our training algorithm takes as input an aligned empty string by ε, and A ε by A+. We denote ∗ \{ } HR bimorphism = (g, 1, Λ, 2) and a corpus the length of s A by s and, for each i [ s ], B A A ∈ ∗ | | ∈ | | c of bigraphs. It is based on the dynamic program- the ith item in s by s(i), i.e., s is identified with the ming variant (Baker, 1979; Lari and Young, 1990; function s:[ s ] A such that s = s(1) s( s ). | | → ··· | | Prescher, 2001) of the EM-algorithm (Dempster et We denote the range s(1), . , s( s ) of s by [s]. { | | } al., 1977) and thus approximates a local maximum The powerset of a set A is denoted by (A). The P or saddle point of the likelihood function of c. canonical extension of a function f : A B to → In order to calculate the significance of each f : (A) (B) and to f : A B are de- P → P ∗ → ∗ rule of g for the generation of a single bigraph fined as usual and denoted by f as well. We denote (H , λ, H ) occurring in c, we proceed as usual, the restriction of f : A B to A A by f . 1 2 → 0 ⊆ |A0 constructing the reduct £ (H , λ, H ) which For an equivalence relation on B we denote B 1 2 ∼ generates the singleton (H1, λ, H2) via the same the equivalence class of b B by [b] and the ∈ ∼ derivation trees as and preserves the probabil- quotient of B modulo by B/ . For f : A B ∼ ∼ → 61 B we define the function f/ : A B/ by with initial nonterminal S and the following rules: ∼ → ∼ f/ (a) = [f(a)] . In particular, for a string s ∼ ∼ ∈ S σ1(A, B) A σ2 B∗ we let s/ = [s(1)] [s( s )] . → → ∼ ∼ ··· | | ∼ B σ (C, D) C σ D σ → 3 → 4 → 5 Terms, regular tree grammars, and algebras We observe that S σ (σ , σ (σ , σ )). Let η, ⇒g∗ 1 2 3 4 5 A ranked alphabet is a pair (Σ, rk) where Σ is ζ, and ζ0 be the following trees (in order): an alphabet and rk: Σ N is a mapping associat- → B σ (C, D) S σ (A, B) S σ (A, B) ing a rank with each symbol of Σ. Often we just → 3 → 1 → 1 1 write Σ instead of (Σ, rk). We abbreviate rk (k) C σ4 D σ5 A σ2 B A σ2 η − → → → → by Σk. In the following let Σ be a ranked alphabet. Then ζ DS(T ,B) because ζ DS(T ) and Let A be an arbitrary set. We let Σ(A) denote ∈ g Σ 0 ∈ g Σ the left-hand side of the root of η is B. the set of strings σ(a1, . , ak) k N, σ { | ∈ ∈ Σk, a1, . , ak A (where the parentheses and A Σ-algebra is a pair = (A, (σ σ Σ)) ∈ } A A | ∈ commas are special symbols not in Σ). The set of where A is a set and σ is a k-ary operation on A A well-formed terms over Σ indexed by A, denoted for every k N and σ Σk. As usual, we will ∈ ∈ by T (A), is defined to be the smallest set T such sometimes use to refer to its carrier set A or, Σ A that A T and Σ(T ) T . We abbreviate TΣ( ) conversely, denote by A (and thus σ by σA) ⊆ ⊆ ∅ A A by T and write σ instead of σ() for σ Σ . if there is no risk of confusion. The Σ-term alge- Σ ∈ 0 1 A regular tree grammar (RTG) (Gecseg´ and bra is the Σ-algebra TΣ with σTΣ (t1, . , tk) = σ(t1, .
Recommended publications
  • Domain Theory and the Logic of Observable Properties
    Domain Theory and the Logic of Observable Properties Samson Abramsky Submitted for the degree of Doctor of Philosophy Queen Mary College University of London October 31st 1987 Abstract The mathematical framework of Stone duality is used to synthesize a number of hitherto separate developments in Theoretical Computer Science: • Domain Theory, the mathematical theory of computation introduced by Scott as a foundation for denotational semantics. • The theory of concurrency and systems behaviour developed by Milner, Hennessy et al. based on operational semantics. • Logics of programs. Stone duality provides a junction between semantics (spaces of points = denotations of computational processes) and logics (lattices of properties of processes). Moreover, the underlying logic is geometric, which can be com- putationally interpreted as the logic of observable properties—i.e. properties which can be determined to hold of a process on the basis of a finite amount of information about its execution. These ideas lead to the following programme: 1. A metalanguage is introduced, comprising • types = universes of discourse for various computational situa- tions. • terms = programs = syntactic intensions for models or points. 2. A standard denotational interpretation of the metalanguage is given, assigning domains to types and domain elements to terms. 3. The metalanguage is also given a logical interpretation, in which types are interpreted as propositional theories and terms are interpreted via a program logic, which axiomatizes the properties they satisfy. 2 4. The two interpretations are related by showing that they are Stone duals of each other. Hence, semantics and logic are guaranteed to be in harmony with each other, and in fact each determines the other up to isomorphism.
    [Show full text]
  • Algebraic Implementation of Abstract Data Types*
    Theoretical Computer Science 20 (1982) 209-263 209 North-Holland Publishing Company ALGEBRAIC IMPLEMENTATION OF ABSTRACT DATA TYPES* H. EHRIG, H.-J. KREOWSKI, B. MAHR and P. PADAWITZ Fachbereich Informatik, TV Berlin, 1000 Berlin 10, Fed. Rep. Germany Communicated by M. Nivat Received October 1981 Abstract. Starting with a review of the theory of algebraic specifications in the sense of the ADJ-group a new theory for algebraic implementations of abstract data types is presented. While main concepts of this new theory were given already at several conferences this paper provides the full theory of algebraic implementations developed in Berlin except of complexity considerations which are given in a separate paper. The new concept of algebraic implementations includes implementations for algorithms in specific programming languages and on the other hand it meets also the requirements for stepwise refinement of structured programs and software systems as introduced by Dijkstra and Wirth. On the syntactical level an algebraic implementation corresponds to a system of recursive programs while the semantical level is defined by algebraic constructions, called SYNTHESIS, RESTRICTION and IDENTIFICATION. Moreover the concept allows composition of implementations and a rigorous study of correctness. The main results of the paper are different kinds of correctness criteria which are applied to a number of illustrating examples including the implementation of sets by hash-tables. Algebraic implementations of larger systems like a histogram or a parts system are given in separate case studies which, however, are not included in this paper. 1. Introduction The concept of abstract data types was developed since about ten years starting with the debacles of large software systems in the late 60's.
    [Show full text]
  • Categories of Coalgebras with Monadic Homomorphisms Wolfram Kahl
    Categories of Coalgebras with Monadic Homomorphisms Wolfram Kahl To cite this version: Wolfram Kahl. Categories of Coalgebras with Monadic Homomorphisms. 12th International Workshop on Coalgebraic Methods in Computer Science (CMCS), Apr 2014, Grenoble, France. pp.151-167, 10.1007/978-3-662-44124-4_9. hal-01408758 HAL Id: hal-01408758 https://hal.inria.fr/hal-01408758 Submitted on 5 Dec 2016 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Distributed under a Creative Commons Attribution| 4.0 International License Categories of Coalgebras with Monadic Homomorphisms Wolfram Kahl McMaster University, Hamilton, Ontario, Canada, [email protected] Abstract. Abstract graph transformation approaches traditionally con- sider graph structures as algebras over signatures where all function sym- bols are unary. Attributed graphs, with attributes taken from (term) algebras over ar- bitrary signatures do not fit directly into this kind of transformation ap- proach, since algebras containing function symbols taking two or more arguments do not allow component-wise construction of pushouts. We show how shifting from the algebraic view to a coalgebraic view of graph structures opens up additional flexibility, and enables treat- ing term algebras over arbitrary signatures in essentially the same way as unstructured label sets.
    [Show full text]
  • Abstraction and Abstraction Refinement in the Verification Of
    Abstraction and Abstraction Refinement in the Verification of Graph Transformation Systems Vom Fachbereich Ingenieurwissenschaften Abteilung Informatik und angewandte Kognitionswissenschaft der Unversit¨at Duisburg-Essen zur Erlangung des akademischen Grades eines Doktor der Naturwissenschaften (Dr.-rer. nat.) genehmigte Dissertation von Vitaly Kozyura aus Magadan, Russland Referent: Prof. Dr. Barbara K¨onig Korreferent: Prof. Dr. Arend Rensink Tag der m¨undlichen Pr¨ufung: 05.08.2009 Abstract Graph transformation systems (GTSs) form a natural and convenient specification language which is used for modelling concurrent and distributed systems with dynamic topologies. These can be, for example, network and Internet protocols, mobile processes with dynamic behavior and dynamic pointer structures in programming languages. All this, together with the possibility to visualize and explain system behavior using graphical methods, makes GTSs a well-suited formalism for the specification of complex dynamic distributed systems. Under these circumstances the problem of checking whether a certain property of GTSs holds – the verification problem – is considered to be a very important question. Unfortunately the verification of GTSs is in general undecidable because of the Turing- completeness of GTSs. In the last few years a technique for analysing GTSs based on approximation by Petri graphs has been developed. Petri graphs are Petri nets having additional graph structure. In this work we focus on the verification techniques based on counterexample-guided abstraction refinement (CEGAR approach). It starts with a coarse initial over-approxi- mation of a system and an obtained counterexample. If the counterexample is spurious then one starts a refinement procedure of the approximation, based on the structure of the counterexample.
    [Show full text]
  • Syntax and Semantics in Algebra Jean-François Nicaud, Denis Bouhineau, Jean-Michel Gélis
    Syntax and semantics in algebra Jean-François Nicaud, Denis Bouhineau, Jean-Michel Gélis To cite this version: Jean-François Nicaud, Denis Bouhineau, Jean-Michel Gélis. Syntax and semantics in algebra. Pro- ceedings of the 12th ICMI Study Conference. The University of Melbourne, 2001, Australia. 12 p. hal-00962023 HAL Id: hal-00962023 https://hal.archives-ouvertes.fr/hal-00962023 Submitted on 25 Mar 2014 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. 1 Syntax and Semantics in Algebra Jean-François Nicaud, Denis Bouhineau Jean-Michel )*lis I IN, University of Nantes, France IUFM of Versailles, France $bouhineau, nicaud%&irin.univ-nantes.fr gelis&inrp.fr This paper is the first chapter of a cognitive, didactic and computatio- nal theory of algebra that presents, in a formal .ay, .ell /no.n elements of mathematics 0numbers, functions and polynomials1 as semantic ob2ects, and expressions as syntactic constructions. The lin/ bet.een syntax and semantics is realised by morphisms. The paper highlights preferred semantics for algebra and defines formally algebraic problems. 3ey.ords4 syntax, semantics, formalisation, algebraic problem. Introduction This paper describes a theory of algebra .ith cognitive, didactic and computational features.
    [Show full text]
  • Lecture Notes for MATH 770 : Foundations of Mathematics — University of Wisconsin – Madison, Fall 2005
    Lecture notes for MATH 770 : Foundations of Mathematics — University of Wisconsin – Madison, Fall 2005 Ita¨ıBEN YAACOV Ita¨ı BEN YAACOV, Institut Camille Jordan, Universite´ Claude Bernard Lyon 1, 43 boulevard du 11 novembre 1918, 69622 Villeurbanne Cedex URL: http://math.univ-lyon1.fr/~begnac/ c Ita¨ıBEN YAACOV. All rights reserved. CONTENTS Contents Chapter 1. Propositional Logic 1 1.1. Syntax 1 1.2. Semantics 3 1.3. Syntactic deduction 6 Exercises 12 Chapter 2. First order Predicate Logic 17 2.1. Syntax 17 2.2. Semantics 19 2.3. Substitutions 22 2.4. Syntactic deduction 26 Exercises 35 Chapter 3. Model Theory 39 3.1. Elementary extensions and embeddings 40 3.2. Quantifier elimination 46 Exercises 51 Chapter 4. Incompleteness 53 4.1. Recursive functions 54 4.2. Coding syntax in Arithmetic 59 4.3. Representation of recursive functions 64 4.4. Incompleteness 69 4.5. A “physical” computation model: register machines 71 Exercises 75 Chapter 5. Set theory 77 5.1. Axioms for set theory 77 5.2. Well ordered sets 80 5.3. Cardinals 86 Exercises 94 –sourcefile– iii Rev: –revision–, July 22, 2008 CONTENTS 1.1. SYNTAX CHAPTER 1 Propositional Logic Basic ingredients: • Propositional variables, which will be denoted by capital letters P,Q,R,..., or sometimes P0, P1, P2,.... These stand for basic statements, such as “the sun is hot”, “the moon is made of cheese”, or “everybody likes math”. The set of propositional variables will be called vocabulary. It may be infinite. • Logical connectives: ¬ (unary connective), →, ∧, ∨ (binary connectives), and possibly others. Each logical connective is defined by its truth table: A B A → B A ∧ B A ∨ B A ¬A T T T T T T F T F F F T F T F T T F T F F T F F Thus: • The connective ¬ means “not”: ¬A means “not A”.
    [Show full text]
  • Abstract Data Types
    1 Abstract data types The history of programming languages may be characterized as the genesis of increasingly powerful abstractions to aid the development of reliable programs. Abstract data types 8 1-1 abstraction and types • algebraic specification • modules versus classes • types as constraints • Additional keywords and phrases: control abstractions, data abstractions, compiler support, description systems, behavioral specification, imple- mentation specification Slide 1-1: Abstract data types In this chapter we will look at the notion of abstract data types, which may be regarded as an essential constituent of object-oriented modeling. In particular, we will study the notion of data abstraction from a foundational perspective, that is based on a mathematical description of types. We start this chapter by discussing the notion of types as constraints. Then, we look at the (first order) algebraic specification of abstract data types, and we explore the trade- offs between the traditional implementation of abstract data types by employing 1 2 Abstract data types modules and the object-oriented approach employing classes. We conclude this chapter by exploring the distinction between classes and types, as a preparation for the treatment of (higher order) polymorphic type theories for object types and inheritance in the next chapter. 1.1 Abstraction and types The concern for abstraction may be regarded as the driving force behind the development of programming languages (of which there are astoundingly many). In the following we will discuss the role of abstraction in programming, and especially the importance of types. We then briefly look at what mathematical means we have available to describe types from a foundational perspective and what we may (and may not) expect from types in object-oriented programming.
    [Show full text]
  • Algebraic Semantics Abstract Type Whose Values Are Lists of Algebraic Semantics Involves the Algebraic Integers: Specification of Data and Language Constructs
    Algebraic Semantics Abstract type whose values are lists of Algebraic semantics involves the algebraic integers: specification of data and language constructs. Sorts = { Integer, Boolean, List }. Function symbols with their signatures: Foundations based on abstract algebras. zero : Integer Basic idea one : Integer • Name the sorts of objects and the operations plus ( _ , _ ) : Integer, Integer ! Integer on the objects. minus ( _ , _ ) : Integer, Integer ! Integer • Use algebraic axioms to describe their characteristic properties. true : Boolean false : Boolean An algebraic specification contains two parts: emptyList : List signature and equations. cons ( _ , _ ) : Integer, List ! List A signature # of an algebraic specification head ( _ ) : List ! Integer is a pair <Sorts, Operations> where tail ( _ ) : List ! List • Sorts is a set containing names of sorts. empty? ( _ ) : List ! Boolean • Operations is a family of function symbols length ( _ ) : List ! Integer indexed by the functionalities of the operations represented by the function symbols. Chapter 12 1 Chapter 12 2 Family of operations decomposes: Module Representation OprBoolean = { true, false } OprInteger,Integer!Integer = { plus, minus } • Decompose definitions into relatively small OprList!Integer = { head, length } components. Equations constrain the operations to indicate • Import the signature and equations of one the appropriate behavior for the operations. module into another. head (cons (m, s)) = m, empty? (emptyList) = true • Define sorts and functions to be either exported or hidden. empty? (cons (m, s)) = false. Each stands for a closed assertion: • Modules can be parameterized to define generic abstract data types. "m:Integer, "s:List [head (cons (m, s)) = m]. empty? (emptyList) = true "m:Integer, "s:List [empty? (cons (m, s))= false].
    [Show full text]
  • The Agda Universal Algebra Library Part 2: Structure Homomorphisms, Terms, Classes of Algebras, Subalgebras, and Homomorphic Images
    The Agda Universal Algebra Library Part 2: Structure Homomorphisms, terms, classes of algebras, subalgebras, and homomorphic images William DeMeo a S Department of Algebra, Charles University in Prague Abstract The Agda Universal Algebra Library (UALib) is a library of types and programs (theorems and proofs) we developed to formalize the foundations of universal algebra in dependent type theory using the Agda programming language and proof assistant. The UALib includes a substantial collection of definitions, theorems, and proofs from universal algebra, equational logic, and model theory, and as such provides many examples that exhibit the power of inductive and dependent types for representing and reasoning about mathematical structures and equational theories. In this paper, we describe the the types and proofs of the UALib that concern homomorphisms, terms, and subalgebras. 2012 ACM Subject Classification Theory of computation → Logic and verification; Computing meth- odologies → Representation of mathematical objects; Theory of computation → Type theory Keywords and phrases Agda, constructive mathematics, dependent types, equational logic, extension- ality, formalization of mathematics, model theory, type theory, universal algebra Related Version hosted on arXiv Part 1, Part 3: http://arxiv.org/a/demeo_w_1 Supplementary Material Documentation: ualib.org Software: https://gitlab.com/ualib/ualib.gitlab.io.git Contents 1 Introduction 2 1.1 Motivation ....................................... 2 1.2 Attributions and Contributions ...........................
    [Show full text]
  • Lectures on Universal Algebra
    Lectures on Universal Algebra Matt Valeriote McMaster University November 8, 1999 1 Algebras In this ¯rst section we will consider some common features of familiar alge- braic structures such as groups, rings, lattices, and boolean algebras to arrive at a de¯nition of a general algebraic structure. Recall that a group G consists of a nonempty set G, along with a binary ¡1 operation ¢ : G ! G, a unary operation : G ! G, and a constant 1G such that ² x ¢ (y ¢ z) = (x ¢ y) ¢ z for all x, y, z 2 G, ¡1 ¡1 ² x ¢ x = 1G and x ¢ x = 1G for all x 2 G, ² 1G ¢ x = x and x ¢ 1G = x for all x 2 G. A group is abelian if it additionally satis¯es: x ¢ y = y ¢ x for all x, y 2 G. A ring R is a nonempty set R along with binary operations +, ¢, a unary operation ¡, and constants 0R and 1R which satisfy ² R, along with +, ¡, and 0R is an abelian group. ² x ¢ (y ¢ z) = (x ¢ y) ¢ z for all x, y, z 2 G. ² x ¢ (y + z) = (x ¢ y) + (x ¢ z) and (y + z) ¢ x = (y ¢ x) + (z ¢ x) for all x, y, z 2 G. 1 ² 1G ¢ x = x and x ¢ 1G = x for all x 2 G. Lattices are algebras of a di®erent nature, they are essentially an algebraic encoding of partially ordered sets which have the property that any pair of elements of the ordered set has a least upper bound and a greatest lower bound. A lattice L consists of a nonempty set L, equipped with two binary operations ^ and _ which satisfy: ² x ^ x = x and x _ x = x for all x 2 L, ² x ^ y = y ^ x and x _ y = y _ x for all x, y 2 L, ² x ^ (y _ x) = x and x _ (y ^ x) = x for all x, y 2 L.
    [Show full text]
  • Domain Theory Corrected and Expanded Version Samson Abramsky1 and Achim Jung2
    Domain Theory Corrected and expanded version Samson Abramsky1 and Achim Jung2 This text is based on the chapter Domain Theory in the Handbook of Logic in Com- puter Science, volume 3, edited by S. Abramsky, Dov M. Gabbay, and T. S. E. Maibaum, published by Clarendon Press, Oxford in 1994. While the numbering of all theorems and definitions has been kept the same, we have included comments and corrections which we have received over the years. For ease of reading, small typo- graphical errors have simply been corrected. Where we felt the original text gave a misleading impression, we have included additional explanations, clearly marked as such. If you wish to refer to this text, then please cite the published original version where possible, or otherwise this on-line version which we try to keep available from the page http://www.cs.bham.ac.uk/˜axj/papers.html We will be grateful to receive further comments or suggestions. Please send them to [email protected] So far, we have received comments and/or corrections from Liang-Ting Chen, Francesco Consentino, Joseph D. Darcy, Mohamed El-Zawawy, Miroslav Haviar, Weng Kin Ho, Klaus Keimel, Olaf Klinke, Xuhui Li, Homeira Pajoohesh, Dieter Spreen, and Dominic van der Zypen. 1Computing Laboratory, University of Oxford, Wolfson Building, Parks Road, Oxford, OX1 3QD, Eng- land. 2School of Computer Science, University of Birmingham, Edgbaston, Birmingham, B15 2TT, England. Contents 1 Introduction and Overview 5 1.1 Origins ................................. 5 1.2 Ourapproach .............................. 7 1.3 Overview ................................ 7 2 Domains individually 10 2.1 Convergence .............................
    [Show full text]
  • Arxiv:1611.02908V1 [Cs.LO] 9 Nov 2016 1
    Coming to Terms with Quantified Reasoning Laura Kovács Simon Robillard Andrei Voronkov TU Wien, Austria Chalmers Univ. of Technology, Sweden University of Manchester, UK [email protected] [email protected] Chalmers Univ. of Technology, Sweden [email protected] Abstract program analysis. Terms may be used to formalize the semantics The theory of finite term algebras provides a natural framework to of programming languages (Goguen et al. 1977; Clark 1978; Cour- describe the semantics of functional languages. The ability to effi- celle 1983); they can also themselves be the object of computation. ciently reason about term algebras is essential to automate program The latter is especially obvious in the case of functional program- analysis and verification for functional or imperative programs over ming languages, where algebraic data structures are manipulated. algebraic data types such as lists and trees. However, as the theory Consider for example the following declaration, in the functional of finite term algebras is not finitely axiomatizable, reasoning about language ML: quantified properties over term algebras is challenging. datatype nat = zero | succ of nat; In this paper we address full first-order reasoning about prop- erties of programs manipulating term algebras, and describe two Although the functional programmer calls this a data type declara- approaches for doing so by using first-order theorem proving. Our tion, the logician really sees the declaration of an (initial) algebra first method is a conservative extension of the theory of term alge- whose signature is composed of two symbols: the constant zero bras using a finite number of statements, while our second method and the unary function succ.
    [Show full text]