SICStus Prolog

SICStus Prolog
Original author(s)	Mats Carlsson
Developer(s)	RISE SICS
Initial release	1986;38 years ago
Stable release	4.9.0 / December 18, 2023;17 days ago
Written in	C, Prolog
Operating system	Cross-platform
Type	Logic programming
License	Proprietary
Website	sicstus.sics.se

Last updated January 05, 2024

SICStus Prolog is a proprietary, ISO-conforming implementation of the logic programming language Prolog. It is developed by the Swedish Institute of Computer Science since 1985 and puts a strong focus on performance and scalability.

History

Around 1985, the Swedish Institute of Computer Science (SICS) was founded and Mats Carlsson joined SICS to develop a Prolog engine that would be a platform for research in or-parallelisation of Prolog. This work was performed in the context of the informal Gigalips project, involving David H.D. Warren at SRI International and researchers from Manchester and Argonne National Laboratory, as well as and-parallel efforts. This resulted in quite mature or-parallel Prologs, such as Aurora and MUSE. The objective of these Prologs was to achieve effective speedups through or-parallel execution transparently for the programmer while supporting full Prolog. This led to SICS distributing SICStus Prolog, which quickly became popular in the academic environment.^[1]

A preliminary specification of SICStus existed in 1986, drawing inspiration from DEC-10 Prolog as well as from Quintus. In addition to the open-source nature, powerful reasons for its popularity were the compatibility with the DEC-10 and Quintus Prolog de-facto standards, very good performance, and compact generated code. Execution profiling and native code compilation were also added later. At the end of the 80s, the Swedish Funding Agency and several companies funded the industrialization of SICStus, which eventually became a commercial product.

By 1995, SICStus was considered a de-facto reference the performance of Prolog implementations.^[2]

In 1998, SICS acquired Quintus Prolog and a number of its features made their way into newer SICStus Prolog versions. It also supports several constraint domains, including a powerful finite domain solver. The SICStus codebase is still actively maintained by SICS.^[1]

Features

SICStus is an ISO-conforming Prolog implementation based on the Warren Abstract Machine, which has a strong focus on performance and stability.^[1] It also provides support for web-based applications. SICStus supports several constraint domains, incorporating an externally developed implementation of the constraint logic programming library CLP(R) based on attributed variables,^[3] for constraint solving over real and rational numbers, and a high-performance native implementation of CLP(FD) for constraint solving over integers.^[4] It features many essentials for constraint solvers, such as coroutines, attributed variables, and unbounded integers. The block coroutining declaration is particularly efficient. It also incorporates many of the characteristics, features, and library modules of Quintus Prolog. Since release 4.3, SICStus also contains a JIT (just-in-time) compiler to native code, but currently has no multithreading or tabling support.^[1]

SICStus includes a modified version of the plunit unit testing library originally developed for SWI-Prolog and a custom integrated development environment named SPIDER.^[1]

Influence

SICStus is used in many commercial applications, and has also served as the basis for other logic programming systems.^[1] As part of the Gigalips project, SICStus was the basis for the original development of the and-parallel Prolog implementation &-Prolog, which later developed into the Ciao system.^[1] The reference implementation of the logic programming language Gödel , that first appeared around 1992, was built on top of SICStus Prolog, employing a different syntax style.^[1]

Related Research Articles

Logic programming is a programming, database and knowledge-representation and reasoning paradigm which is based on formal logic. A program, database or knowledge base in a logic programming language is a set of sentences in logical form, expressing facts and rules about some problem domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:

Prolog is a logic programming language that has its origins in artificial intelligence and computational linguistics.

Constraint programming (CP) is a paradigm for solving combinatorial problems that draws on a wide range of techniques from artificial intelligence, computer science, and operations research. In constraint programming, users declaratively state the constraints on the feasible solutions for a set of decision variables. Constraints differ from the common primitives of imperative programming languages in that they do not specify a step or sequence of steps to execute, but rather the properties of a solution to be found. In addition to constraints, users also need to specify a method to solve these constraints. This typically draws upon standard methods like chronological backtracking and constraint propagation, but may use customized code like a problem-specific branching heuristic.

In computer science, declarative programming is a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow.

SWI-Prolog is a free implementation of the programming language Prolog, commonly used for teaching and semantic web applications. It has a rich set of features, libraries for constraint logic programming, multithreading, unit testing, GUI, interfacing to Java, ODBC and others, literate programming, a web server, SGML, RDF, RDFS, developer tools, and extensive documentation.

Constraint Handling Rules (CHR) is a declarative, rule-based programming language, introduced in 1991 by Thom Frühwirth at the time with European Computer-Industry Research Centre (ECRC) in Munich, Germany. Originally intended for constraint programming, CHR finds applications in grammar induction, type systems, abductive reasoning, multi-agent systems, natural language processing, compilation, scheduling, spatial-temporal reasoning, testing, and verification.

Answer set programming (ASP) is a form of declarative programming oriented towards difficult search problems. It is based on the stable model semantics of logic programming. In ASP, search problems are reduced to computing stable models, and answer set solvers—programs for generating stable models—are used to perform search. The computational process employed in the design of many answer set solvers is an enhancement of the DPLL algorithm and, in principle, it always terminates.

ECLiPSe is a software system for the development and deployment of constraint logic programming applications, e.g., in the areas of optimization, planning, scheduling, resource allocation, timetabling, transport, etc. It is also suited for teaching most aspects of combinatorial problem solving, e.g., problem modeling, constraint programming, mathematical programming, and search techniques. It contains constraint solver libraries, a high-level modeling and control language, interfaces to third-party solvers, an integrated development environment and interfaces for embedding into host environments.

In computer science, a term index is a data structure to facilitate fast lookup of terms and clauses in a logic program, deductive database, or automated theorem prover.

In computer science, the well-founded semantics is a three-valued semantics for logic programming, which gives a precise meaning to general logic programs.

XSB is the name of a dialect of the Prolog programming language and its implementation developed at Stony Brook University in collaboration with the Katholieke Universiteit Leuven, the New University of Lisbon, Uppsala University and software vendor XSB, Inc.

Logtalk is an object-oriented logic programming language that extends and leverages the Prolog language with a feature set suitable for programming in the large. It provides support for encapsulation and data hiding, separation of concerns and enhanced code reuse. Logtalk uses standard Prolog syntax with the addition of a few operators and directives.

B-Prolog was a high-performance implementation of the standard Prolog language with several extended features including matching clauses, action rules for event handling, finite-domain constraint solving, arrays and hash tables, declarative loops, and tabling. First released in 1994, B-Prolog is now a widely used CLP system. The constraint solver of B-Prolog was ranked top in two categories in the Second International Solvers Competition, and it also took the second place in P class in the second ASP solver competition and the second place overall in the third ASP solver competition. B-Prolog underpins the PRISM system, a logic-based probabilistic reasoning and learning system. B-Prolog is a commercial product, but it can be used for learning and non-profit research purposes free of charge. B-Prolog is not anymore actively developed, but it forms the basis for the Picat programming language.

YAP is an open-source, high-performance implementation of the Prolog programming language developed at LIACC/Universidade do Porto and at COPPE Sistemas/UFRJ. Its Prolog engine is based in the WAM, with several optimizations for better performance. YAP follows the Edinburgh tradition, and is largely compatible with the ISO-Prolog standard and with Quintus Prolog and SICStus Prolog. YAP has been developed since 1985. The original version was written in assembly, C and Prolog, and achieved high performance on m68k-based machines.

The following Comparison of Prolog implementations provides a reference for the relative feature sets and performance of different implementations of the Prolog computer programming language. A comprehensive discussion of the most significant Prolog systems is presented in an article published in the 50-years of Prolog anniversary issue of the journal Theory and Practice of Logic Programming (TPLP)..

CLP(R) is a declarative programming language. It stands for constraint logic programming (real) where real refers to the real numbers. It can be considered and is generally implemented as a superset or add-on package for a Prolog implementation.

Ciao is a general-purpose programming language which supports logic, constraint, functional, higher-order, and object-oriented programming styles. Its main design objectives are high expressive power, extensibility, safety, reliability, and efficient execution.

BNR Prolog, also known as CLP(BNR), is a declarative constraint logic programming language based on relational interval arithmetic developed at Bell-Northern Research in the 1980s and 1990s. Embedding relational interval arithmetic in a logic programming language differs from other constraint logic programming (CLP) systems like CLP(R) or Prolog-III in that it does not perform any symbolic processing. BNR Prolog was the first such implementation of interval arithmetic in a logic programming language. Since the constraint propagation is performed on real interval values, it is possible to express and partially solve non-linear equations.

Tabling is a technique first developed for natural language processing, where it was called Earley parsing. It consists of storing in a table partial successful analyses that might come in handy for future reuse.

Quintus Prolog is a proprietary implementation of the Prolog programming language based on the Warren Abstract Machine. Originally developed by Quintus Computer Science, it is currently maintained by SICS. It was long known as the most highly-performing implementation of Prolog, and the early 1990s, it defined a de facto standard for Prolog implementations.

References

1 2 3 4 5 6 7 8 Körner, Philipp; Leuschel, Michael; Barbosa, João; Costa, Vítor Santos; Dahl, Verónica; Hermenegildo, Manuel V.; Morales, Jose F.; Wielemaker, Jan; Diaz, Daniel; Abreu, Salvador; Ciatto, Giovanni (2022). "Fifty Years of Prolog and Beyond". Theory and Practice of Logic Programming. 22 (6): 776–858. doi:10.1017/S1471068422000102. hdl: 10174/33387 . ISSN 1471-0684.
↑ Codognet, Philippe; Diaz, Daniel (1995-06-16), "wamcc: Compiling Prolog to C", Logic Programming, The MIT Press, pp. 317–332, ISBN 978-0-262-29143-9 , retrieved 2023-12-18
↑ Holzbaur, Christian (1995). "OEFAI clp(q,r) Manual Revision 1.3.2,". ÖFAI Technical Reports Online (95–09).
↑ Geleßus, David; Leuschel, Michael (2022). "Making ProB Compatible with SWI-Prolog". Theory and Practice of Logic Programming. 22 (5): 755–769. arXiv: 2205.04373 . doi: 10.1017/S1471068422000230 . ISSN 1471-0684.