DOCSLIB.ORG

Algebraic Semantics Abstract Type Whose Values Are Lists of Algebraic Semantics Involves the Algebraic Integers: Specification of Data and Language Constructs

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read 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]. Chapter 12 3 Chapter 12 4 A Module for Truth Values variables module Booleans b, b1, b2 : Boolean exports equations sorts Boolean [B1] and (true, b) = b operations [B2] and (false, true) = false true : Boolean [B3] and (false, false) = false false : Boolean [B4] not (true)= false errorBoolean : Boolean [B5] not (false) = true not ( _ ) : Boolean Boolean ! [B6] or (b1, b2) = not (and (not (b1), not (b2))) and ( _ , _ ) : [B7] implies (b1, b2) = or (not (b1), b2) Boolean, Boolean Boolean ! [B8] xor (b1, b2) = or ( _ , _ ) : and (or(b1,b2),not(and(b1,b2))) Boolean, Boolean Boolean ! [B9] eq? (b1, b2) = not (xor (b1, b2)) implies ( _ , _ ) : end Booleans Boolean,Boolean ! Boolean eq? ( _ , _ ) : Note module syntax Boolean, Boolean ! Boolean end exports A conditional equation has the form operations lhs=rhs when lhs =rhs , lhs =rhs , ..., lhs =rhs . xor ( _ , _ ) : Boolean, Boolean ! Boolean 1 1 2 2 n n Chapter 12 5 Chapter 12 6 A Module for Natural Numbers variables m, n : Natural module Naturals equations imports Booleans [N1] 1 = succ (0) exports [N2] 10 = succ (succ (succ (succ (succ ( sorts Natural succ (succ (succ (succ (succ (0)))))))))) operations [N3] add (m, 0) = m 0 : Natural [N4] add (m, succ (n)) = succ (add (m, n)) 1 : Natural 10 : Natural [N5] sub (0, succ(n)) = errorNatural errorNatural : Natural [N6] sub (m, 0) = m succ ( _ ) : Natural ! Natural [N7] sub(succ(m),succ(n)) =sub(m,n) add ( _ , _ ) : Natural, Natural ! Natural [N8] mul (m, 0) = 0 when m!errorNatural sub ( _ , _ ) : Natural, Natural ! Natural [N9] mul (m, 1) = m mul ( _ , _ ) : Natural, Natural ! Natural [N10] mul (m, succ(n)) = add (m, mul (m, n)) div ( _ , _ ) : Natural, Natural ! Natural [N11] div (m, 0) = errorNatural eq? ( _ , _ ) : Natural, Natural Boolean ! [N12] div (0, succ (n)) = 0 when n!errorNatural less? ( _ , _ ) : [N13] div (m, succ (n)) = Natural, Natural ! Boolean if ( less? (m, succ (n)), greater?( _ , _ ) : 0, Natural, Natural ! Boolean succ(div(sub(m,succ(n)),succ(n)))) end exports Chapter 12 7 Chapter 12 8 [N14] eq? (0, 0) = true [N15] eq? (0, succ (n)) = false Conditions are Necessary when n!errorNatural [N16] eq? (succ (m), 0) = false Use [N8] and ignore the condition: when m!errorNatural [N17] eq? (succ (m), succ (n)) = eq? (m, n) 0 = mul(succ(errorNatural),0) [N18] less? (0, succ (m)) = true = mul(errorNatural,0) when m!errorNatural = errorNatural. [N19] less? (m, 0) = false when m!errorNatural and [N20] less? (succ (m), succ (n)) = less? (m, n) succ(0) = succ(errorNatural) = errorNatural, [N21] greater? (m, n) = less? (n, m) succ(succ(0)) = end Naturals succ(errorNatural) = errorNatural, and so on. All operations propagate errors succ (errorNatural) = errorNatural, Conditions are needed when variable(s) on the left disappear on the right. sub (div(0,0), succ(0)) = errorNatural, not (errorBoolean) = errorBoolean, and eq? (0, succ (errorNatural)) = errorBoolean. Chapter 12 9 Chapter 12 10 Constructors A Module for Characters • No equations for 0 and succ module Characters • Terms 0, succ(0), succ(succ(0)), ... not equal importsBooleans, Naturals exports • These plus errorNatural can be viewed as characterizing the natural numbers, the sorts Char individuals defined by the module. operations eq? ( _ , _ ) : Char, Char ! Boolean • Initial algebraic semantics letter? ( _ ) : Char ! Boolean digit? ( _ ) : Char ! Boolean • No confusion property ord ( _ ) : Char ! Natural • No junk property char-0 : Char char-1 : Char : : char-9 : Char char-a : Char : : char-z : Char errorChar : Char end exports Chapter 12 11 Chapter 12 12 variables Parameterized Module and Instantiations c, c1, c2 : Char module Lists equations imports Booleans, Naturals [C1] ord (char-0) = 0 [C2] ord (char-1) = succ (ord (char-0)) parameters Items [C3] ord (char-2) = succ (ord (char-1)) sorts Item : : : operations [C11] ord (char-a) = succ (ord (char-9)) errorItem : Item [C12] ord (char-b) = succ (ord (char-a)) eq? : Item, Item ! Boolean : : : variables [C36] ord (char-z) = succ (ord (char-y)) a, b, c : Item equations [C37] eq? (c1, c2) = eq? (ord (c1), ord (c2)) eq? (a,a) = true when a!errorItem [C38] letter? (c) = eq? (a,b) = eq? (b,a) and (not (greater? (ord (char-a), ord (c))), implies(and(eq?(a,b),eq?(b,c)), not (greater? (ord (c), ord (char-z)))) eq?(a,c))=true [C39] digit? (c) = when a!errorItem, and (not (greater? (ord (char-0), ord (c))), b!errorItem, not (greater? (ord (c) ord (char-9)))) c!errorItem end Characters end Items Chapter 12 13 Chapter 12 14 exports equations sorts List [S1] concat (null, s) = s operations [S2] concat(cons(i,s1),s2) = null : List cons(i,concat(s1, s2)) errorList : List [S3] equal? (null, null) = true cons ( _ , _ ) : Item, List ! List concat ( _ , _ ) : List, List ! List [S4] equal? (null, cons (i, s)) = false length ( _ ) : List ! Natural when s!errorList, i!errorItem equal? ( _ , _ ): List, List Boolean ! [S5] equal? (cons (i, s), null) = false mkList ( _ ) : Item List ! when s!errorList, i!errorItem end exports [S6] equal? (cons (i1, s1), cons (i2, s2)) = variables and(eq?(i1, i2), equal?(s1, s2)) i, i1, i2 : Item [S7] length (null) = 0 s, s , s : List 1 2 [S8] length (cons (i, s)) = succ (length (s)) when i!errorItem [S9] mkList (i) = cons (i, null) end Lists Chapter 12 15 Chapter 12 16 Instantiations module Strings imports Booleans, Naturals, Characters, module Files instantiation of Lists importsBooleans, Naturals, bind Items using Char for Item instantiation of Lists using errorChar for errorItem bind Items using eq? for eq? using Natural for Item rename using String for List using errorNatural for errorItem using nullString for null using eq? for eq? using mkString for mkList rename using File for List using strEqual for equal? using emptyFile for null using errorString for errorList using mkFile for mkList using errorFile for errorList exports exports sorts String sorts File operations operations string-to-natural ( _ ) : empty? ( _ ) : File ! Boolean end exports String ! Boolean, Natural variables f : File end exports equations [F1] empty? (f) = equal? (f, emptyFile) end Files Chapter 12 17 Chapter 12 18 variables A Module for Finite Mappings c : Char b : Boolean module Mappings n : Natural s : String imports Booleans equations parameters Entries sorts Domain, Range [Str1] string-to-natural (nullString) = <true,0> operations [Str2] string-to-natural (cons (c, s)) = equals ( _ , _ ) : if ( and (digit? (c), b), Domain,Domain ! Boolean <true, add(mul(sub(ord(c),ord(char-0)), errorDomain : Domain exp(10, length(s))), n)>, errorRange : Range <false, 0>) variables when <b,n> = string-to-natural (s) a,b,c : Domain end Strings equations equals (a,a) = true when a!errorDomain Expression in [Str2]: equals (a,b) = equals (b,a) ((ord(c) – ord(char-0)) • 10length(s)) + n implies (and (equals (a,b), equals (b,c)), equals (a,c)) = true when a, b, and c ! errorDomain end Entries Chapter 12 19 Chapter 12 20 exports sorts Mapping A Store Structure operations emptyMap : Mapping module Stores errorMapping : Mapping imports Strings, Naturals, update( _ , _ , _ ) : Mapping,Domain,Range ! Mapping instantiation of Mappings apply ( _ , _ ) : bind Entries Mapping, Domain ! Range using String for Domain end exports using Natural for Range variables using strEqual for equals m : Mapping using errorString for errorDomain d, d1, d2 : Domain using errorNatural for errorRange r : Range rename using Store for Mapping equations using emptySto for emptyMap [M1] apply (emptyMap, d) = errorRange using updateSto for update [M2] apply (update(m, d1, r), d2) = r using applySto for apply when equals(d1,d2) = true, m!errorMapping end Stores [M3] apply (update(m, d1, r), d2) = apply(m, d2) when equals(d1,d2)=false, r!errorRange end Mappings Chapter 12 21 Chapter 12 22 Mathematical Foundations module Nats imports Bools Simplify modules. exports sorts Natural module Bools operations exports 0 : Natural sorts Boolean succ ( _ ) : Natural ! Natural operations add ( _ , _ ) : Natural, Natural ! Natural true : Boolean end exports false : Boolean variables not ( _ ) : Boolean ! Boolean m, n : Natural end exports equations equations [N1] add (m, 0) = m [B1] not (true) = false [N2] add (m, succ (n)) = succ (add (m, n)) [B2] not (false) = true end Nats end Bools Chapter 12 23 Chapter 12 24 Example: Ground terms of sort Boolean in Ground Terms Bools true, not(true), Function symbols used to construct terms not(not(true)), not(not(not(true))), ..
Load more

Recommended publications
  • 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.
    [Show full text]
  • 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]
  • 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]