DOCSLIB.ORG

On the Representation of Datatypes in Isabelle/HOL

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
On the Representation of Datatypes in Isabelle/HOL On the Representation of Datatyp es in Isab elleHOL N Volker FernUniversitat Hagen Germany Abstract Representation of datatyp es is a necessary prerequisite if one wants to proverat her than p ostulate the characteristic theorems of datatyp es This pap er intro duces two notions of representation functions for typ es and shows how representations of comp osed typ es can b e calculated from representations of their constituents Together with a representation of basic typ es due to Paulson this provides a basis for the mechanization of datatyp es in Isab elleHOL Intro duction Datatyp es are imp ortant ingredients of many theories mo delling computations We will b e concerned here with datatyp es which are generated from a numb er of elements and functions the constructors This means that every element of the typ e can b e written as a constructor term ie as an application of constructors to constructors Furthermore our datatyp es will b e freely generated by the constructors ie the constructors are distinct and injective This implies that every element of the datatyp e is denoted by a unique constructor term As a consequence suchtyp es enjoy a structural induction theorem and allow the denition of functions by primitive recursion In the categorical setting these typ es arise as initial elements in certain categories of algebras Therefore one also sp eaks of initial algebras Other names used are recursive or inductivetyp es without laws We will simply call them datatyp es y destructor functions whose domain is The dual kind of typ es are characterized b the carrier of the typ e An example for such a codatatyp e are innite lists Although parts of our discussion should carry over to codatatyp es we will not consider them here Currently the Isab elleHOL system provides a datatyp e denition package which hasanumb er of shortcomings The prop erties of the new typ es are p ostulated axiomatically The declaration of a typ e T maynotcontain applications of typ e op erators to T This forbids denitions like a b Tree LEAF a j NODE b a b Tree List There is no supp ort for mutually recursive datatyp es We will outline in this pap er an approach which aims to prove the characteristic theo rems of the new datatyp e This is achieved by representing typ es by sets of a certain typ e whichwas intro duced byPaulson for exactly this purp ose Our main contri bution is the derivation of representations of typ e expressions from representations of its constituents This construction based on a generalization of the map function from lists to an arbitrary datatyp e The typ e a b Tree mo dels trees with arbitrary nite branching and elements of a resp b in the leafs resp no des This example is inspired from a slightly simpler datatyp e in That article discusses some basic questions concerning automatic supp ort for datatyp es in another higher order pro of assistant namely the HOL system We are currently working on an implementation along the lines suggested in this pap er We stress that this pap er rep orts on work in progress and do es not claim to b e the nal word on representations of datatyp es in higher order logic Map for arbitrary datatyp es Atseveral places of our exp osition we will make use of the fact that for every datatyp e map whichistheT analogue of the wellknown function T one can dene a function T map on lists Since the denition of the general mapping function is technically some what involved we will illustrate it rst by a couple of examples Recall that lists can b e dened by the datatyp e declaration a List j Cons a a List For the typ e T List the function T map agrees with map ie wehave List map a b a List b List and map f List List map f Cons x xs Cons fx List map fxs Intuitively List map preserves the structure given by the list constructors and Cons but changes the values of those constructor arguments whose typ e in is a For the datatyp e Tree dened ab ove the typ e of the mapping function is Tree map a b a b a a Tree b b Tree map is dened by primitive recursion The recursive o ccur Again the function Tree rence of Tree within List is reected by an application of List map to Tree map f f map f f LEAF a LEAF f a Tree Tree map f f NODE a ts NODE f a List map Tree map f f ts For ary datatyp es ie unparameterized typ es suchasnat the mapping function map f is the identity on that typ e Next we will showhow to dene the function T for the case of an arbitrary one parameter datatyp e aT with m constructors The declaration of suchatyp e has the form aT C T j j C T m m where T is the j th argumenttyp e of constructor C Of course the number of typ e i j i arguments can vary from constructor to constructor and can also b e zero Every T is i j atyp e expression build up from the typ e variable a recursive o ccurrences of aT and previously dened datatyp es Note that T is only allowed to o ccur with the parameter a ie instantiations of T are not allowed Let f b e some function from a typ e A to another typ e B Then the mapping of f over T map f AT BT T preserves constructors For a constructor C with k arguments we therefore have i T map f C x x C h T x h T x i i i k i i i i k i k T On ary constructors the function T map f is the identity for certain functions h i j As indicated by the notation the function h T dep ends on the typ e T in i j i j Ty is dened by induction on the structure of Ty as follows For a typ e expression Ty h h a f h aT T map f h T T D D map h T h T l l D stands here for an arbitrary previously datatyp e of some arity l For a general n ary datatyp e T the typ e of the mapping function is T map a b a b a a T b b T n n n n The general denition of T map f f follows exactly the same scheme as for the n T stays the same except that case n The denition of the auxiliary functions h i j equation is replaced by setting h a f i i for i n Although it is not usual in higher order logic the pro duct and sum typ e themselves can b e dened as datatyp es a b Inl a j Inr b a b a b Their mapping op erators are characterized by the following equations map f g Inl a Inl fa Sum map f g Inr b Inr gb Sum Prod map f g a b fa gb A treatment of the generalized mapping function in the categorical framework can b e found in Another generic function For the denition of representing sets we will b e interested in computing the range of T map f f It turns out that this can b e expressed in terms of another generic n function set a set a set a a T set T n n set A A which can b e dened for an arbitrary n ary datatyp e T Intuitively T n will consist of those elements of T which can b e generated from the sets A A n The meaning of generated will b e made precise using inductive denitions First let us consider the example of the typ e List The function List set a set a List set should takeasetA into the set of all lists with elements in A This set is characterized by the following twointro duction rules a A l List set A List set A Cons a l List set A Note how each rule corresp onds to the typing of one List constructor In fact wecan deriveevery rule systematically from the typing rule of the corresp onding constructor by simply replacing the name List by List set and a by A For a general datatyp e a a T with m constructors we obtain analogously n m intro duction rules for T set A A from the typing rules of the constructors n set and a by A for i n by replacing the name T by T i i By the principle of inductive denition a nite numb er of rules such as the ones ab ove uniquely sp ecies a set cf chapter of and the literature cited there This set is the intersection of all the sets which comply to those rules Supp ort for inductive denitions in higher order logic pro of systems has b een des crib ed in and Both approaches implement inductively dened sets as least xed p oints Our interest in T set stems from the equality range T map f f T set range f range f n n set is obviously monotonic We note the fact that T Representations of typ es The principal means to add new typ es in Isab elleHOL without risking inconsistencies is the subtype facility This function is similar to the HOL systems new type definition and allows to dene a new typ e T which is isomorphic to a nonempty subset S of an existing typ e RT Isomorphic here means that there exists an injective function T rep from the new typ e T onto its representing set S In the subtype package the new typ e is declared and constants are intro duced for the representation function T rep and an inverse abstraction function T The inverse relationship b etween these two abs functions and the fact that the representing set S is the image of the representation function are p ostulated as axioms RT T_rep T S T_abs Figure Denition of new typ es using subtype The use of the subtype declaration is the only waytoavoid the intro duction of non trivial axioms in the denition of a datatyp e T in Isab elleHOL It implies the following sub division of our task Construct a representing set S Dene the new typ e T byasubtype declaration This requires a pro of that S is not empty Dene the constructors by using the abstraction and representation functions Generate and prove the characteristic theorems In the following we will b e considering not just the representation of a single typ e but of a whole class C of typ es Such a representation
Load more

Recommended publications
  • ECSS-E-TM-40-07 Volume 2A 25 January 2011
    ECSS-E-TM-40-07 Volume 2A 25 January 2011 Space engineering Simulation modelling platform - Volume 2: Metamodel ECSS Secretariat ESA-ESTEC Requirements & Standards Division Noordwijk, The Netherlands ECSS‐E‐TM‐40‐07 Volume 2A 25 January 2011 Foreword This document is one of the series of ECSS Technical Memoranda. Its Technical Memorandum status indicates that it is a non‐normative document providing useful information to the space systems developers’ community on a specific subject. It is made available to record and present non‐normative data, which are not relevant for a Standard or a Handbook. Note that these data are non‐normative even if expressed in the language normally used for requirements. Therefore, a Technical Memorandum is not considered by ECSS as suitable for direct use in Invitation To Tender (ITT) or business agreements for space systems development. Disclaimer ECSS does not provide any warranty whatsoever, whether expressed, implied, or statutory, including, but not limited to, any warranty of merchantability or fitness for a particular purpose or any warranty that the contents of the item are error‐free. In no respect shall ECSS incur any liability for any damages, including, but not limited to, direct, indirect, special, or consequential damages arising out of, resulting from, or in any way connected to the use of this document, whether or not based upon warranty, business agreement, tort, or otherwise; whether or not injury was sustained by persons or property or otherwise; and whether or not loss was sustained from, or arose out of, the results of, the item, or any services that may be provided by ECSS.
    [Show full text]
  • Multi-Level Constraints
    Multi-Level Constraints Tony Clark1 and Ulrich Frank2 1 Aston University, UK, [email protected] 2 University of Duisburg-Essen, DE, [email protected] Abstract. Meta-modelling and domain-specific modelling languages are supported by multi-level modelling which liberates model-based engi- neering from the traditional two-level type-instance language architec- ture. Proponents of this approach claim that multi-level modelling in- creases the quality of the resulting systems by introducing a second ab- straction dimension and thereby allowing both intra-level abstraction via sub-typing and inter-level abstraction via meta-types. Modelling ap- proaches include constraint languages that are used to express model semantics. Traditional languages, such as OCL, support intra-level con- straints, but not inter-level constraints. This paper motivates the need for multi-level constraints, shows how to implement such a language in a reflexive language architecture and applies multi-level constraints to an example multi-level model. 1 Introduction Conceptual models aim to bridge the gap between natural languages that are required to design and use a system and implementation languages. To this end, general-purpose modelling languages (GPML) like the UML consist of concepts that represent semantic primitives such as class, attribute, etc., that, on the one hand correspond to concepts of foundational ontologies, e.g., [4], and on the other hand can be nicely mapped to corresponding elements of object-oriented programming languages. Since GPML can be used to model a wide range of systems, they promise at- tractive economies of scale. At the same time, their use suffers from the fact that they offer generic concepts only.
    [Show full text]
  • Union Types for Semistructured Data
    Edinburgh Research Explorer Union Types for Semistructured Data Citation for published version: Buneman, P & Pierce, B 1999, Union Types for Semistructured Data. in Union Types for Semistructured Data: 7th International Workshop on Database Programming Languages, DBPL’99 Kinloch Rannoch, UK, September 1–3,1999 Revised Papers. Lecture Notes in Computer Science, vol. 1949, Springer-Verlag GmbH, pp. 184-207. https://doi.org/10.1007/3-540-44543-9_12 Digital Object Identifier (DOI): 10.1007/3-540-44543-9_12 Link: Link to publication record in Edinburgh Research Explorer Document Version: Peer reviewed version Published In: Union Types for Semistructured Data General rights Copyright for the publications made accessible via the Edinburgh Research Explorer is retained by the author(s) and / or other copyright owners and it is a condition of accessing these publications that users recognise and abide by the legal requirements associated with these rights. Take down policy The University of Edinburgh has made every reasonable effort to ensure that Edinburgh Research Explorer content complies with UK legislation. If you believe that the public display of this file breaches copyright please contact [email protected] providing details, and we will remove access to the work immediately and investigate your claim. Download date: 27. Sep. 2021 Union Typ es for Semistructured Data Peter Buneman Benjamin Pierce University of Pennsylvania Dept of Computer Information Science South rd Street Philadelphia PA USA fpeterbcpiercegcisupenn edu Technical
    [Show full text]
  • Djangoshop Release 0.11.2
    djangoSHOP Release 0.11.2 Oct 27, 2017 Contents 1 Software Architecture 1 2 Unique Features of django-SHOP5 3 Upgrading 7 4 Tutorial 9 5 Reference 33 6 How To’s 125 7 Development and Community 131 8 To be written 149 9 License 155 Python Module Index 157 i ii CHAPTER 1 Software Architecture The django-SHOP framework is, as its name implies, a framework and not a software which runs out of the box. Instead, an e-commerce site built upon django-SHOP, always consists of this framework, a bunch of other Django apps and the merchant’s own implementation. While this may seem more complicate than a ready-to-use solution, it gives the programmer enormous advantages during the implementation: Not everything can be “explained” to a software system using graphical user interfaces. After reaching a certain point of complexity, it normally is easier to pour those requirements into executable code, rather than to expect yet another set of configuration buttons. When evaluating django-SHOP with other e-commerce solutions, I therefore suggest to do the following litmus test: Consider a product which shall be sold world-wide. Depending on the country’s origin of the request, use the native language and the local currency. Due to export restrictions, some products can not be sold everywhere. Moreover, in some countries the value added tax is part of the product’s price, and must be stated separately on the invoice, while in other countries, products are advertised using net prices, and tax is added later on the invoice.
    [Show full text]
  • Presentation on Ocaml Internals
    OCaml Internals Implementation of an ML descendant Theophile Ranquet Ecole Pour l’Informatique et les Techniques Avancées SRS 2014 [email protected] November 14, 2013 2 of 113 Table of Contents Variants and subtyping System F Variants Type oddities worth noting Polymorphic variants Cyclic types Subtyping Weak types Implementation details α ! β Compilers Functional programming Values Why functional programming ? Allocation and garbage Combinatory logic : SKI collection The Curry-Howard Compiling correspondence Type inference OCaml and recursion 3 of 113 Variants A tagged union (also called variant, disjoint union, sum type, or algebraic data type) holds a value which may be one of several types, but only one at a time. This is very similar to the logical disjunction, in intuitionistic logic (by the Curry-Howard correspondance). 4 of 113 Variants are very convenient to represent data structures, and implement algorithms on these : 1 d a t a t y p e tree= Leaf 2 | Node of(int ∗ t r e e ∗ t r e e) 3 4 Node(5, Node(1,Leaf,Leaf), Node(3, Leaf, Node(4, Leaf, Leaf))) 5 1 3 4 1 fun countNodes(Leaf)=0 2 | countNodes(Node(int,left,right)) = 3 1 + countNodes(left)+ countNodes(right) 5 of 113 1 t y p e basic_color= 2 | Black| Red| Green| Yellow 3 | Blue| Magenta| Cyan| White 4 t y p e weight= Regular| Bold 5 t y p e color= 6 | Basic of basic_color ∗ w e i g h t 7 | RGB of int ∗ i n t ∗ i n t 8 | Gray of int 9 1 l e t color_to_int= function 2 | Basic(basic_color,weight) −> 3 l e t base= match weight with Bold −> 8 | Regular −> 0 in 4 base+ basic_color_to_int basic_color 5 | RGB(r,g,b) −> 16 +b+g ∗ 6 +r ∗ 36 6 | Grayi −> 232 +i 7 6 of 113 The limit of variants Say we want to handle a color representation with an alpha channel, but just for color_to_int (this implies we do not want to redefine our color type, this would be a hassle elsewhere).
    [Show full text]
  • Bidirectional Typing
    Bidirectional Typing JANA DUNFIELD, Queen’s University, Canada NEEL KRISHNASWAMI, University of Cambridge, United Kingdom Bidirectional typing combines two modes of typing: type checking, which checks that a program satisfies a known type, and type synthesis, which determines a type from the program. Using checking enables bidirectional typing to support features for which inference is undecidable; using synthesis enables bidirectional typing to avoid the large annotation burden of explicitly typed languages. In addition, bidirectional typing improves error locality. We highlight the design principles that underlie bidirectional type systems, survey the development of bidirectional typing from the prehistoric period before Pierce and Turner’s local type inference to the present day, and provide guidance for future investigations. ACM Reference Format: Jana Dunfield and Neel Krishnaswami. 2020. Bidirectional Typing. 1, 1 (November 2020), 37 pages. https: //doi.org/10.1145/nnnnnnn.nnnnnnn 1 INTRODUCTION Type systems serve many purposes. They allow programming languages to reject nonsensical programs. They allow programmers to express their intent, and to use a type checker to verify that their programs are consistent with that intent. Type systems can also be used to automatically insert implicit operations, and even to guide program synthesis. Automated deduction and logic programming give us a useful lens through which to view type systems: modes [Warren 1977]. When we implement a typing judgment, say Γ ` 4 : 퐴, is each of the meta-variables (Γ, 4, 퐴) an input, or an output? If the typing context Γ, the term 4 and the type 퐴 are inputs, we are implementing type checking. If the type 퐴 is an output, we are implementing type inference.
    [Show full text]
  • Practical Subtyping for System F with Sized (Co-)Induction Rodolphe Lepigre, Christophe Raffalli
    Practical Subtyping for System F with Sized (Co-)Induction Rodolphe Lepigre, Christophe Raffalli To cite this version: Rodolphe Lepigre, Christophe Raffalli. Practical Subtyping for System F with Sized (Co-)Induction. 2017. hal-01289760v3 HAL Id: hal-01289760 https://hal.archives-ouvertes.fr/hal-01289760v3 Preprint submitted on 10 Jul 2017 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 - NonCommercial - NoDerivatives| 4.0 International License PRACTICAL SUBTYPING FOR SYSTEM F WITH SIZED (CO-)INDUCTION RODOLPHE LEPIGRE AND CHRISTOPHE RAFFALLI LAMA, UMR 5127 CNRS - Universit´eSavoie Mont Blanc e-mail address: frodolphe.lepigre j christophe.raff[email protected] Abstract. We present a rich type system with subtyping for an extension of System F. Our type constructors include sum and product types, universal and existential quanti- fiers, inductive and coinductive types. The latter two may carry annotations allowing the encoding of size invariants that are used to ensure the termination of recursive programs. For example, the termination of quicksort can be derived by showing that partitioning a list does not increase its size. The system deals with complex programs involving mixed induction and coinduction, or even mixed polymorphism and (co-)induction (as for Scott- encoded data types).
    [Show full text]
  • Programming with Gadts
    Chapter 8 Programming with GADTs ML-style variants and records make it possible to define many different data types, including many of the types we encoded in System F휔 in Chapter 2.4.1: booleans, sums, lists, trees, and so on. However, types defined this way can lead to an error-prone programming style. For example, the OCaml standard library includes functions List .hd and List . tl for accessing the head and tail of a list: val hd : ’ a l i s t → ’ a val t l : ’ a l i s t → ’ a l i s t Since the types of hd and tl do not express the requirement that the argu- ment lists be non-empty, the functions can be called with invalid arguments, leading to run-time errors: # List.hd [];; Exception: Failure ”hd”. In this chapter we introduce generalized algebraic data types (GADTs), which support richer types for data and functions, avoiding many of the errors that arise with partial functions like hd. As we shall see, GADTs offer a num- ber of benefits over simple ML-style types, including the ability to describe the shape of data more precisely, more informative applications of the propositions- as-types correspondence, and opportunities for the compiler to generate more efficient code. 8.1 Generalising algebraic data types Towards the end of Chapter 2 we considered some different approaches to defin- ing binary branching tree types. Under the following definition a tree is either empty, or consists of an element of type ’a and a pair of trees: type ’ a t r e e = Empty : ’ a t r e e | Tree : ’a tree * ’a * ’a tree → ’ a t r e e 59 60 CHAPTER 8.
    [Show full text]
  • Categorical Models of Type Theory
    Categorical models of type theory Michael Shulman February 28, 2012 1 / 43 Theories and models Example The theory of a group asserts an identity e, products x · y and inverses x−1 for any x; y, and equalities x · (y · z) = (x · y) · z and x · e = x = e · x and x · x−1 = e. I A model of this theory (in sets) is a particularparticular group, like Z or S3. I A model in spaces is a topological group. I A model in manifolds is a Lie group. I ... 3 / 43 Group objects in categories Definition A group object in a category with finite products is an object G with morphisms e : 1 ! G, m : G × G ! G, and i : G ! G, such that the following diagrams commute. m×1 (e;1) (1;e) G × G × G / G × G / G × G o G F G FF xx 1×m m FF xx FF m xx 1 F x 1 / F# x{ x G × G m G G ! / e / G 1 GO ∆ m G × G / G × G 1×i 4 / 43 Categorical semantics Categorical semantics is a general procedure to go from 1. the theory of a group to 2. the notion of group object in a category. A group object in a category is a model of the theory of a group. Then, anything we can prove formally in the theory of a group will be valid for group objects in any category. 5 / 43 Doctrines For each kind of type theory there is a corresponding kind of structured category in which we consider models.
    [Show full text]
  • Algebraic Data Types
    Composite Data Types as Algebra, Logic Recursive Types Algebraic Data Types Christine Rizkallah CSE, UNSW (and data61) Term 3 2019 1 Classes Tuples Structs Unions Records Composite Data Types as Algebra, Logic Recursive Types Composite Data Types Most of the types we have seen so far are basic types, in the sense that they represent built-in machine data representations. Real programming languages feature ways to compose types together to produce new types, such as: 2 Classes Unions Composite Data Types as Algebra, Logic Recursive Types Composite Data Types Most of the types we have seen so far are basic types, in the sense that they represent built-in machine data representations. Real programming languages feature ways to compose types together to produce new types, such as: Tuples Structs Records 3 Unions Composite Data Types as Algebra, Logic Recursive Types Composite Data Types Most of the types we have seen so far are basic types, in the sense that they represent built-in machine data representations. Real programming languages feature ways to compose types together to produce new types, such as: Classes Tuples Structs Records 4 Composite Data Types as Algebra, Logic Recursive Types Composite Data Types Most of the types we have seen so far are basic types, in the sense that they represent built-in machine data representations. Real programming languages feature ways to compose types together to produce new types, such as: Classes Tuples Structs Unions Records 5 Composite Data Types as Algebra, Logic Recursive Types Combining values conjunctively We want to store two things in one value.
    [Show full text]
  • Scala by Example (2009)
    Scala By Example DRAFT January 13, 2009 Martin Odersky PROGRAMMING METHODS LABORATORY EPFL SWITZERLAND Contents 1 Introduction1 2 A First Example3 3 Programming with Actors and Messages7 4 Expressions and Simple Functions 11 4.1 Expressions And Simple Functions...................... 11 4.2 Parameters.................................... 12 4.3 Conditional Expressions............................ 15 4.4 Example: Square Roots by Newton’s Method................ 15 4.5 Nested Functions................................ 16 4.6 Tail Recursion.................................. 18 5 First-Class Functions 21 5.1 Anonymous Functions............................. 22 5.2 Currying..................................... 23 5.3 Example: Finding Fixed Points of Functions................ 25 5.4 Summary..................................... 28 5.5 Language Elements Seen So Far....................... 28 6 Classes and Objects 31 7 Case Classes and Pattern Matching 43 7.1 Case Classes and Case Objects........................ 46 7.2 Pattern Matching................................ 47 8 Generic Types and Methods 51 8.1 Type Parameter Bounds............................ 53 8.2 Variance Annotations.............................. 56 iv CONTENTS 8.3 Lower Bounds.................................. 58 8.4 Least Types.................................... 58 8.5 Tuples....................................... 60 8.6 Functions.................................... 61 9 Lists 63 9.1 Using Lists.................................... 63 9.2 Definition of class List I: First Order Methods..............
    [Show full text]
  • An Ontology-Based Semantic Foundation for Organizational Structure Modeling in the ARIS Method
    An Ontology-Based Semantic Foundation for Organizational Structure Modeling in the ARIS Method Paulo Sérgio Santos Jr., João Paulo A. Almeida, Giancarlo Guizzardi Ontology & Conceptual Modeling Research Group (NEMO) Computer Science Department, Federal University of Espírito Santo (UFES) Vitória, ES, Brazil [email protected]; [email protected]; [email protected] Abstract—This paper focuses on the issue of ontological Although present in most enterprise architecture interpretation for the ARIS organization modeling language frameworks, a semantic foundation for organizational with the following contributions: (i) providing real-world modeling elements is still lacking [1]. This is a significant semantics to the primitives of the language by using the UFO challenge from the perspective of modelers who must select foundational ontology as a semantic domain; (ii) the and manipulate modeling elements to describe an Enterprise identification of inappropriate elements of the language, using Architecture and from the perspective of stakeholders who a systematic ontology-based analysis approach; and (iii) will be exposed to models for validation and decision recommendations for improvements of the language to resolve making. In other words, a clear semantic account of the the issues identified. concepts underlying Enterprise Modeling languages is Keywords: semantics for enterprise models; organizational required for Enterprise Models to be used as a basis for the structure; ontological interpretation; ARIS; UFO (Unified management, design and evolution of an Enterprise Foundation Ontology) Architecture. In this paper we are particularly interested in the I. INTRODUCTION modeling of this architectural domain in the widely- The need to understand and manage the evolution of employed ARIS Method (ARchitecture for integrated complex organizations and its information systems has given Information Systems).
    [Show full text]