DOCSLIB.ORG

PL Category: Logic Pls Introduction to Prolog

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
PL Category: Logic Pls Introduction to Prolog PL Category: Logic PLs Introduction to Prolog CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, April 19, 2019 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks ggchappell@alaska.edu © 2017–2019 Glenn G. Chappell Review PL Feature: Execution II [1/6] Recall. When a program is executed, the computations it specifies actually occur. In all cases, something drives the execution. § There is some task the computer is attempting to perform. § There is some strategy for carrying out the execution. Both of these can vary significantly from one programming language to another. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 2 Review PL Feature: Execution II [2/6] What task drives the execution of a Lua program? Answer. The code at global scope in a source file is executed. Strategy. The computer is given a sequence of commands. It carries out each, in order, performing the action that each specifies. If a command specifies that another function is to be called, then this becomes a subtask to be completed as part of the main task. C++, Java, and Forth—imperative PLs—are similar. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 3 Review PL Feature: Execution II [3/6] Scheme code does not consist of commands to be carried out, but rather expressions to be evaluated. Scheme is a more declarative PL than those mentioned earlier. We do not tell the computer what to do, but what the values of things are. What drives Scheme execution (in the REPL) is the evaluation of an expression, which generally results in a procedure call. Strategy. Evaluate the expression that forms the body of this procedure and return its value. § If this expression involves calls to other procedures, then those evaluations are carried out as subtasks. § If the evaluation of any of these expressions produces side effects, then these are performed. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 4 Review PL Feature: Execution II [4/6] Like Scheme, Haskell code does not consist of commands to be carried out, but rather expressions to be evaluated. Haskell is very much a declarative PL. What drives Haskell execution is a function call—to Main.main or some other function. Strategy. As with Scheme, evaluate the expression that forms the body of this function. If this expression involves calls to other functions, then those evaluations are carried out as subtasks. Haskell is a pure PL—it has no side effects—so Haskell execution per se consists entirely of evaluation. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 5 Review PL Feature: Execution II [5/6] But there is another element to Haskell execution. I/O values are descriptions of side effects. These are returned to the runtime environment, which performs the side effects. Some I/O values may include code to be executed with the wrapped value. Such code is also executed. This is how things like the following are handled. do line <- getLine putStrLn $ reverse line The call to reverse can only happen after a side effect has been performed. Such code must be called by the runtime. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 6 Review PL Feature: Execution II [6/6] Prolog is another declarative language. But instead of telling it values, we tell it what is true. Given a query (essentially a question—yes/no or “What … ?”) Prolog attempts to unify the query with something in its knowledge base (program). Prolog execution is driven by a query. The execution strategy involves unification. To unify two constructions means to make them the same by setting values of variables as necessary. Unification, in full generality, includes expression evaluation as a special case. But unification can also do things that evaluation cannot do. Can we unify [A, 6] and [4, B]? Yes. Set A to 4, B to 6. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 7 PL Category: Logic PLs Background [1/4] In the late 1960s, Stanford researcher Cordell Green proposed representing a computer program in terms of logical statements. The result was a programming paradigm that became known as logic programming. In logic programming, a computer program can be thought of as a knowledge base. It typically contains two kinds of knowledge. § Facts. Statements that are known to be true. § Rules. Ways to find other true statements from those known. Execution is then driven by a query: essentially a question. The computer attempts to answer the question using facts and rules. Logic programming typically has no notion of falsehood. There are statements the computer can prove to be true, and others that it cannot. But some of those others might be true. Logic programming is thus not so much about truth as provability. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 8 PL Category: Logic PLs Background [2/4] Here are some facts (the lower-case names will be explained). § gil is a child of ernest. § glenn is a child of gil. Here is a rule. (A, B, and C are free variables.) § If A is a child of B, and B is a child of C, then A is a grandchild of C. Here are some queries. 1. Is glenn a grandchild of ernest? 2. Is ernest a grandchild of glenn? 3. Is glenn a grandchild of bob? The answer to query #1 is “yes”. This is provable. It is not provable what the answers to queries #2 and #3 are. These are real people, and the facts and the rule are actually true. The correct answer to query #2 is “no”, and to query #3 is “yes”. So truth and provability are different. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 9 PL Category: Logic PLs Background [3/4] In the 1970s, programming languages based on logic- programming concepts began to appear. These are logic programming languages. Foremost among those was (and still is) Prolog. Others include Mercury, Oz, Gödel, and clp(FD)*. Designing a practical PL based solely on logic has turned out to be difficult—or perhaps impossible. Logic PLs nearly always “cheat” by including constructions that are not logical in nature. Some people would say that the effort to create a true logic-based programming language has failed. I would say that the effort was worthwhile, but what resulted was not what was originally planned. (I will have more to say about this later.) *“clp(FD)” stands for Constraint Logic Programming over Finite Domains. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 10 PL Category: Logic PLs Background [4/4] Logic programming may be something that can be offered as a library—if a PL supports the necessary constructions well enough. PLs with sufficient support seem to have been rare until recently. But there are now a number of actively maintained logic- programming libraries for various mainstream PLs. In particular, several logic-programming packages for the Python programming language appear to be well spoken of (but I have no experience with any of them). One also sees logic- programming libraries for various Lisp-family PLs. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 11 PL Category: Logic PLs Typical Characteristics In a typical logic programming language: § A program consists of facts and rules. § Execution begins with a query, which establishes a goal. During execution, various subgoals may be established. § Execution is primarily interactive, based on a source file. § Execution is about finding what can be proven—not what is true. § So negation says something fails to be provable, not that it is false. § Unification is the primary proof tool. § Typing is dynamic and implicit. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 12 Introduction to Prolog History [1/2] In the early 1970s, a group at the U. of Aix-Marseille (France) began an effort to produce a logic programming language. The group was led by Alain Colmeraur, and Cordell Green’s ideas were their starting point. The PL was called Prolog, short for “PROgrammation en LOGique” (French for “programming in logic”). The first version of Prolog was released in 1972. Prolog was, and continues to be, the most important logic PL. There was a flurry of interest in Prolog in the 1970s. This has mostly faded, but an active—although relatively small— community remains. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 13 Introduction to Prolog History [2/2] In 1987, a group at the University of Amsterdam produced a prolog implementation called SWI-Prolog. It is now available free on all major platforms and is actively maintained. In 1995, an ISO standard for Prolog was released. In 2000, corrections and a module extension were published—but not a completely new standard. In 1996, work began on a free ISO Prolog implementation under the auspices of the GNU Project. Initially named “Calypso”, this implementation is now called gprolog; it is what we will use. Proprietary, non-ISO varieties of Prolog also exist. The most successful is probably Visual Prolog (formerly Turbo Prolog). Unlike most versions of Prolog, Visual Prolog has static typing and support for object-oriented programming. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 14 Introduction to Prolog Characteristics — General Prolog is a logic programming language. Prolog execution is driven by a query, which establishes a goal. The primary execution strategy involves unification. Prolog attempts to unify using backtracking search. Prolog has some support for reflection (which we will not look at closely). From here on, “Prolog” means “ISO Standard Prolog”, as implemented in gprolog. 19 Apr 2019 CS F331 / CSCE A331 Spring 2019 15 Introduction to Prolog Characteristics — Functions & Predicates Prolog does not really use functions, as we generally think of them—except that there are the usual numeric functions used in numeric computation.
Load more

Recommended publications
  • Portability of Prolog Programs: Theory and Case-Studies
    Portability of Prolog programs: theory and case-studies Jan Wielemaker1 and V´ıtorSantos Costa2 1 VU University Amsterdam, The Netherlands, J.Wielemaker@cs.vu.nl 2 DCC-FCUP & CRACS-INESC Porto LA Universidade do Porto, Portugal vsc@dcc.fc.up.pt Abstract. (Non-)portability of Prolog programs is widely considered as an important factor in the lack of acceptance of the language. Since 1995, the core of the language is covered by the ISO standard 13211-1. Since 2007, YAP and SWI-Prolog have established a basic compatibility framework. This article describes and evaluates this framework. The aim of the framework is running the same code on both systems rather than migrating an application. We show that today, the portability within the family of Edinburgh/Quintus derived Prolog implementations is good enough to allow for maintaining portable real-world applications. 1 Introduction Prolog is an old language with a long history, and its user community has seen a large number of implementations that evolved largely independently. This sit- uation is totally different from more recent languages, e.g, Java, Python or Perl. These language either have a single implementation (Python, Perl) or are con- trolled centrally (a language can only be called Java if it satisfies certain stan- dards [9]). The Prolog world knows dialects that are radically different, even with different syntax and different semantics (e.g., Visual Prolog [11]). Arguably, this is a handicap for the language because every publically available significant piece of code must be carefully examined for portability issues before it can be applied. As an anecdotal example, answers to questions on comp.lang.prolog typically include \on Prolog XYZ, this can be done using .
    [Show full text]
  • Prolog Basics
    Prolog basics A little background on Prolog Facts and queries "Can you prove it?" Atoms and numbers Predicates, terms, and structures Fact/query mismatches More queries Operators are structures Alternative representations Unification Query execution CSc 372, Fall 2006 Prolog, Slide 1 W. H. Mitchell (whm@msweng.com) A little background on Prolog The name comes from "programming in logic". Developed at the University of Marseilles (France) in 1972. First implementation was in FORTRAN and written by Alain Colmeraurer. Originally intended as a tool for working with natural languages. Achieved great popularity in Europe in the late 1970s. Was picked by Japan in 1981 as a core technology for their "fifth generation" project. Prolog is a commercially successful language. Many companies have made a business of supplying Prolog implementations, Prolog consulting, and/or applications in Prolog. There are many free implementations of Prolog available. We'll be using SWI-Prolog. CSc 372, Fall 2006 Prolog, Slide 2 W. H. Mitchell (whm@msweng.com) Facts and queries A Prolog program is a collection of facts, rules, and queries. We'll talk about facts first. Here is a small collection of Prolog facts: % cat foods.pl food('apple'). food('broccoli'). food('carrot'). food('lettuce'). food('rice'). These facts enumerate some things that are food. We might read them in English like this: "An apple is food", "Broccoli is food", etc. A fact represents a piece of knowledge that the Prolog programmer deems to be useful. The name food was chosen by the programmer. One alternative is edible('apple'). 'apple' is an example of an atom.
    [Show full text]
  • Ada User Journal
    ADA Volume 23 USER Number 3 JOURNAL September 2002 Contents Page Editorial Policy for Ada User Journal 122 Editorial 123 News 125 Conference Calendar 160 Forthcoming Events 167 Articles Michael Kersten, Joerg Matthes, Christian Fouda Manga, Stephan Zipser and Hubert B. Keller “Customizing UML for the Development of Distributed Reactive Systems and Ada 95 Code Generation” 175 Ada-Europe 2002 Sponsors 184 Ada-Europe Associate Members (National Ada Organizations) Inside Back Cover Ada User Journal Volume 23, Number 3, September 2002 122 Editorial Policy for Ada User Journal Publication Original Papers Commentaries Ada User Journal – The Journal for the Manuscripts should be submitted in We publish commentaries on Ada and international Ada Community – is accordance with the submission software engineering topics. These published by Ada-Europe. It appears guidelines (below). may represent the views either of four times a year, on the last days of individuals or of organisations. Such March, June, September and All original technical contributions are articles can be of any length – December. Copy date is the first of the submitted to refereeing by at least two inclusion is at the discretion of the month of publication. people. Names of referees will be kept Editor. confidential, but their comments will Opinions expressed within the Ada Aims be relayed to the authors at the User Journal do not necessarily discretion of the Editor. Ada User Journal aims to inform represent the views of the Editor, Ada- readers of developments in the Ada The first named author will receive a Europe or its directors. programming language and its use, complimentary copy of the issue of the general Ada-related software Journal in which their paper appears.
    [Show full text]
  • Symbolic Analysis and Atomistic Model As a Basis for a Program Comprehension Methodology
    JYVÄSKYLÄ STUDIES IN COMPUTING 90 Erkki Laitila Symbolic Analysis and Atomistic Model as a Basis for a Program Comprehension Methodology JYVÄSKYLÄN YLIOPISTO JYVÄSKYLÄ STUDIES IN COMPUTING 90 Erkki Laitila Symbolic Analysis and Atomistic Model as a Basis for a Program Comprehension Methodology Esitetään Jyväskylän yliopiston informaatioteknologian tiedekunnan suostumuksella julkisesti tarkastettavaksi yliopiston Agora-rakennuksessa (Ag Aud. 3) huhtikuun 26. päivänä 2008 kello 12. Academic dissertation to be publicly discussed, by permission of the Faculty of Information Technology of the University of Jyväskylä, in the Building Agora (Ag Aud. 3), on April 26, 2008 at 12 o'clock noon. UNIVERSITY OF JYVÄSKYLÄ JYVÄSKYLÄ 2008 Symbolic Analysis and Atomistic Model as a Basis for a Program Comprehension Methodology JYVÄSKYLÄ STUDIES IN COMPUTING 90 Erkki Laitila Symbolic Analysis and Atomistic Model as a Basis for a Program Comprehension Methodology UNIVERSITY OF JYVÄSKYLÄ JYVÄSKYLÄ 2008 Editors Tommi Kärkkäinen Department of Mathematical Information Technology, University of Jyväskylä Irene Ylönen, Marja-Leena Tynkkynen Publishing Unit, University Library of Jyväskylä Cover picture by Erkki Laitila URN:ISBN:978-951-39-3252-7 ISBN 978-951-39-3252-7 (PDF) ISBN 978-951-39-2908-4 (nid.) ISSN 1456-5390 Copyright ©2008 , by University of Jyväskylä Jyväskylä University Printing House, Jyväskylä 2008 3 ABSTRACT Laitila, Erkki Symbolic Analysis and Atomistic Model as a Basis for a Program Comprehension Methodology Jyväskylä: University of Jyväskylä, 2008, 326 p. (Jyväskylä Studies in Computing, ISSN 1456-5390; 90) ISBN 978-951-39-3252-7 (PDF), 978-951-39-2908-4 (nid.) Finnish summary Diss. Research on program comprehension (PC) is very important, because the amount of source code in mission-critical applications is increasing world-wide.
    [Show full text]
  • Prolog: Beyond the Text & Summary
    Prolog: Beyond the text & Summary Artificial Intelligence Programming in Prolog Lecturer: Tim Smith Lecture 18 29/11/04 29/11/04 AIPP Lecture 18: Beyond the Text & Summary 1 Contents • Prolog: Beyond the text – Tcl/tk – Java and prolog – Visual Prolog ~ COGENT * Will not be examined on ‘Beyond the text’. It presents advanced Prolog details beyond the specification of this course*. • Exam details • Lecture Summaries 29/11/04 AIPP Lecture 18: Beyond the Text & Summary 2 Creating Prolog GUIs • In AIPP we have only been using Prolog at the command line. • This makes it seem of limited use, more “retro”, compared to other languages, such as Java, which have significant graphical components. • But, Prolog does not have to be just textual! • Various techniques exists for creating Graphical User Interfaces (GUIs) for Prolog: – Tcl/tk – Jasper (Java interface) – Visual Basic (not discussed) – Visual Prologtm • Details on all of these available in the SICStus manual. http://www.sics.se/sicstus/docs/latest/html/sicstus.html/ 29/11/04 AIPP Lecture 18: Beyond the Text & Summary 3 Tcl/Tk • Tcl/Tk (“tickle/tee-kay”) – a scripting language and – toolkit for manipulating window based interfaces. • Very simple to code and quickly prototype cross- platform GUIs. • You might have come across Tcl/Tk on the HCI course. • SICStus Prolog contains a Tcl/Tk library (tcltk) which allows GUIs to be controlled and created: 1. The Prolog program loads the Tcl/Tk Prolog library, 2. creates a Tcl/Tk interpreter, and 3. sends commands to the interpreter to create a GUI. 4. The user interacts with the GUI and therefore with the underlying Prolog system.
    [Show full text]
  • Visual Prolog Classes
    Visual Prolog Version 5.x Language Tutorial (c) Copyright 1986-2001 Prolog Development Center A/S H.J. Holst Vej 3-5C, DK - 2605 Broendby, Copenhagen Denmark Copyright The documentation for this software is copyrighted, and all rights are reserved. It may not be reproduced, transmitted, stored in a retrieval system, or translated, either by electronic, mechanical or any other means, without the prior written consent of Prolog Development Center A/S. The software products described in these manuals are also copyrighted, and are licensed to the End User only for use in accordance with the End User License Agreement, which is printed on the diskette packaging. The prospective user should read this agreement carefully prior to use of the software. Visual Prolog is a registered trademark of Prolog Development Center A/S. Other brand and product names are trademarks or registered trademarks of their respective holders. Table of Contents Part 1 Introduction to Visual Prolog Chapter 1, Using Visual Prolog's Visual Development Environment What Needs to be Installed for This Book? ....................................................... 6 Starting the Visual Prolog's Visual Development Environment........................ 7 Creating the TestGoal Project for Running the Examples................................. 8 Opening an Editor Window ............................................................................. 11 Running and Testing a Program....................................................................... 11 Testing Language Tutorial Examples
    [Show full text]
  • Prolog Language
    Prolog Language #prolog Table of Contents About 1 Chapter 1: Getting started with Prolog Language 2 Remarks 2 Implementations 2 Examples 2 Installation or Setup 2 append/3 3 CLP(FD) Constraints 3 Database Programming 4 Hello, World 6 Hello, World in the interactive interpreter 6 Hello, World from a file 6 Chapter 2: Coding guidelines 8 Examples 8 Naming 8 Indentation 8 Order of arguments 8 Chapter 3: Constraint Logic Programming 10 Examples 10 CLP(FD) 10 CLP(Q) 10 CLP(H) 10 Chapter 4: Control structures 11 Examples 11 Disjunction (logical OR), implicit vs. explict 11 Conjunction (logical AND) 11 Cut (remove choice points) 11 Chapter 5: Data Structures 13 Examples 13 Lists 13 Pairs 13 Association lists 14 Terms 14 Terms with named fields using library(record) 14 Chapter 6: Definite Clause Grammars (DCGs) 16 Examples 16 Anything at all: `... //0` 16 Parsing with DCGs 16 Extra goals 16 Extra arguments 17 Chapter 7: Derivation trees 18 Examples 18 Proof tree 18 Chapter 8: Difference Lists 20 Introduction 20 Examples 20 Basic usage 20 Evaluate an arithmetic expression 21 Chapter 9: Error handling and exceptions 23 Examples 23 Instantiation errors 23 General points about error handling 23 Cleaning up after exceptions 23 Type and domain errors 23 Chapter 10: Extra-logical Predicates 25 Examples 25 Predicates with side effects 25 Meta-logical predicates 25 All-solutions predicates 25 !/0 and related predicates 25 Chapter 11: Higher-Order Programming 27 Examples 27 call/N predicates 27 maplist/[2,3] 27 Meta-call 27 foldl/4 27 Call a list of goals
    [Show full text]
  • Detailed Syllabus
    SEMESTER 1 15XW11 CALCULUS AND ITS APPLICATIONS 3 2 0 4 BASIC CONCEPTS: Functions – Graphs, limit, continuity, jump discontinuity, piecewise continuity, periodic, differentiable, integrable, absolutely integrable functions. Fundamental theorem of calculus (statement only). Sequences – increasing, decreasing, bounded, function limit properties (No Proof). Series – convergence and divergence – alternating series test, absolute convergence – ratio test, power series. (7+5) FOURIER SERIES : Periodic waveforms, even and odd functions, orthogonality relations, Fourier series - Dirchlet’s conditions, statement of Fourier Theorem, Fourier Co-effecients – change of scale , Half range series, Parseval’s theorem – average power of a signal, RMS value, applications – frequency response of a linear system. (8+5) FUNCTIONS OF TWO VARIABLES: Introduction- partial derivative and its geometrical interpretation. Taylor series about a point - Maxima, minima - Constrained maxima and minima – Lagrange multiplier method. (7+5) INTEGRAL CALCULUS: Evaluation of multiple integrals - Change the order of integration - Application of multiple integrals to find area and volume - Beta and Gamma Integrals - Evaluation of definite integrals in terms of Beta and Gamma functions. (8+5) ORDINARY DIFFERENTIAL EQUATIONS OF FIRST ORDER: Modeling- Geometrical meaning- Exact differential equations, Integrating factors- linear differential equations, Bernouli equations - Applications to linear systems. (7+5) LINEAR DIFFERENTIAL EQUATIONS OF SECOND AND HIGHER ORDER: Homogeneous linear equations of second order and higher order equations with constant coefficients. Euler-Cauchy equation, Non-homogeneous equations, Solution by variation of parameter - Applications to linear systems. (8+5) Total L:45+T:30 = 75 TEXT BOOKS : 1. Erwin Kreyszig, “Advanced Engineering Mathematics”, John Wiley, 2014. 2. Maurice D. Weir, Joel Hass, Frank R. Giordano, “Thomas’ Calculus”, Pearson, 2013.
    [Show full text]
  • Logic Programming with Prolog Max Bramer
    Logic Programming with Prolog Max Bramer Logic Programming with Prolog Max Bramer, BSc, PhD, CEng, FBCS, FIEE, FRSA, ILTM Department of Computer Science and Software Engineering University of Portsmouth United Kingdom British Library Cataloguing in Publication Data A catalogue record for this book is available from the British Library Library of Congress Control Number: 2005923526 Apart from any fair dealing for the purposes of research or private study, or criticism or review, as permitted under the Copyright, Designs and Patents Act 1988, this publication may be repro- duced, stored or transmitted, in any form or by any means, with the prior permission in writing of the publishers, or in the case of reprographic reproduction in accordance with the terms of licenses issued by the Copyright Licensing Agency. Enquiries concerning reproduction outside those terms should be sent to the publishers. ISBN-10: 1-85233-938-1 ISBN-13: 978-1852-33938-8 Springer Science+Business Media springeronline.com © Max Bramer 2005 The use of registered names, trademarks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant laws and regula- tions and therefore free for general use. The publisher makes no representation, express or implied, with regard to the accuracy of the information contained in this book and cannot accept any legal responsibility or liability for any errors or omissions that may be made. Printed in the United States of America 34-543210 Printed on acid-free paper SPIN 11344445 Introduction Logic Programming is the name given to a distinctive style of programming, very different from that of conventional programming languages such as C++ and Java.
    [Show full text]
  • Translation of Visual Prolog Programs Into UML Models
    Translation of Visual Prolog programs into UML models Ivan Andrianov System Programming Department, Computational Mathematics and Cybernetics Faculty, Moscow State University andrianov.sp.cmc@gmail.com 1 Introduction Modification and support of systems written in logical programming languages is a difficult task because of the lack of software engineering tools for logical programs. Currently there are a lot of software engineering tools for object-oriented programs. Therefore the translation of a logical program into an object model task is really urgent. The task solution allows us to get models corresponding to logical programs. For these object models we can use object-oriented software engineering tools in full, e.g., modify object models and generate the object-oriented language code from them. 1990s were the time of the active research on the logical programs analysis and modification topic. In that time algorithms resolving the predicate argument type inference (e.g., GAIA [1]) and the predicate mode inference (e.g., MDDAA [2]) problems were developed for standard Prolog programs. These algorithms were used for Prolog interpreter and compiler optimization purposes. In this article logical programs are analyzed for other purposes. The task is a transition from logical programs terms to object models terms. The 1990s algorithms can't applied for the task. In this article we deal with logical programs written in the Visual Prolog [3] language. Consider features of Visual Prolog differing it from standard Prolog dialects. 1 domains : 2 department type = financial , logistics , technical. 3 date = d(integer , integer , integer). 4 person = p(string , date). 5 department = dep(string , department type ) .
    [Show full text]
  • Frequently Asked Questions - Comp.Lang.Prolog
    Frequently Asked Questions - comp.lang.prolog Markus Triska (Mar. 2 2007 - ... ) Remko Troncon (Jan. 6 2002 - Mar. 2 2007) Dirk-Jan Faber (Feb. 1 1999 - Jan. 6 2002) Jamie Andrews (Aug 26 1992 - Oct. 16 1997) General Information: This article contains the answers to some Frequently Asked Questions (FAQ) often seen in news://comp.lang.prolog/. It is posted (twice a month, currently on the 2nd and 16th) to help reduce volume in this newsgroup and to provide hard-to-find information of general interest. The World Wide Web URL for this FAQ is: http://www.logic.at/prolog/faq/ Please send questions about the FAQ and updates to <triska@logic.at>. 1. What is the Association for Logic Programming? To keep up with the current state of logic programming technology, readers can join the Association for Logic Programming (ALP) and receive their Newsletter. For details on how to join or send in contributions, check http://www.cs.nmsu.edu/ALP/ or contact Sandro Etalle <etalle@cs.utwente.nl> The Prolog Resource Guide (v0.6) was printed in issue 5/1 of the Newsletter (Feb. 1992). This lists information concerning Prolog Archives, Books, Suppliers, etc. It is now maintained by Mark Kantrowitz (<Mark.Kantrowitz@glinda.oz.cs.cmu.edu>), and used to be posted periodically to news://comp.lang.prolog. 2. Where can I get a free Prolog for system X (PC, Mac, Unix or other)? The following are anonymous-FTP sites for free Prologs (or related languages) which are either in the public domain or are "copy-lefted" (permitted to be copied with some restrictions on commercial use).
    [Show full text]
  • 2P-Kt: a Kotlin-Based, Multi-Platform Framework for Symbolic AI
    ALMA MATER STUDIORUM { UNIVERSITA` DI BOLOGNA CAMPUS DI CESENA Scuola di Ingegneria e Architettura Corso di Laurea Magistrale in Ingegneria e Scienze Informatiche 2p-kt: A Kotlin-based, Multi-Platform Framework for Symbolic AI Tesi di laurea magistrale Relatore Presentata da Prof. ANDREA OMICINI ENRICO SIBONI Co-relatore Dott. GIOVANNI CIATTO Terza Sessione di Laurea Anno Accademico 2018-2019 2 Abstract Today complex software systems are typically built as aggregates of hetero- geneous components, where symbolic AI may effectively help facing key issues such as intelligence of components and management of interaction. However, most solutions for symbolic manipulation are currently either proof of concept imple- mentations or full-fledged monolithic runtimes, mostly targeting a single platform or a specific problem. Among the many, two decades ago, the tuProlog engine proposed a flexible and modular architecture on top of a portable platform { namely, the JVM { which should have overcome the aforementioned problems. Sadly, the technology of the time forced some design choices which are nowadays limiting its development and its porting on other platforms { critical for modern AI {, such as JavaScript (JS) or iOS. For such reasons in this thesis we propose (the design and development of) 2p-kt, an object-oriented, modular engine for symbolic manipulation written in pure Kotlin { thus supporting compilation on several platforms, there including JVM, and JS {, coming with a natural support for Prolog-like SLD resolution but virtually open to other resolution strategies. 2p-kt design is conceived to maximise components deployability, lightweightness, reusability and configurability, while minimising their mutability, and keeping its architecture open to the injection of new Prolog libraries or resolution strategies.
    [Show full text]