What are some interesting examples of Prolog?

One of the most interesting applications of Prolog I have seen in the recent past is the formalization of dose-escalation trial designs that occur in clinical oncology. In particular, David C. Norris has implemented a Prolog formulation of the cumulative cohort design (CCD) as part of his precautionary package:

https://github.com/dcnorris/precautionary/blob/main/exec/pro...

This Prolog program can be used to exhaustively enumerate all possible arising cases, and also to complete partially given trials. In addition to the specific usage mode of telling the clinician what action to perform next after a sequence of events has occurred, it is also possible to ask interesting questions about the trial design as a whole, such as whether specific cases can arise at all, or whether a specific instance was performed according to the protocol. In this sense, the formulation truly serves as an executable specification of trial designs that are otherwise stated only comparatively informally in the medical literature, and may even be subject to divergent interpretations. The formulation uses Scryer Prolog and the latest Prolog language constructs (such as if_/3 and CLP(ℤ) constraints) to achieve a short and very general description. Such declarative specifications may help considerably to improve safety and efficiency of clinical trials, by making all steps and outcomes amenable to analysis and comparison.

Theorem provers and reasoning engines are also often implemented in Prolog. A recent example is solidarity by Jos De Roo:

https://github.com/josd/solidarity

Prolog is also frequently used for prototyping interpreters. For example, Adrián Arroyo Calle is working on a MIPS simulator written in Prolog:

https://github.com/aarroyoc/mipsie

Simon Forman has implemented a Prolog interpreter of Joy in which, remarkably, the declarative description also serves as a type inferencer and type checker:

https://git.sr.ht/~sforman/Thun/tree/master/item/source/thun...

Porting this code to Scryer Prolog could be an interesting project if it appeals to you. There is already an issue for it and pertaining discussion:

https://github.com/mthom/scryer-prolog/issues/388

TerminusDB CTO here.

Echoing what triska said, CLP(ℤ) and friends are some of the most under-appreciated aspects of prolog implementations.

I'm amazed that programmers still don't have access to CLP when trying to do scheduling and planning solutions.

As an example in practice, what if you want to know about a transaction in which a number of entities transitively had holdings in one of the beneficiaries of the transaction at that particular time. The date window is not known, and the date windows are important in the ownership chain as well as the transactions that are being undertaken.

With CLP(FD) you can ask for a window of time, and the solution will zoom in on an appropriate time window which exists for the entire chain and match the time of the transaction.

Now try to do this query in SQL. It's almost impossibly hard.

I can't wait until I have the time to implement constraint variables for TerminusDB, but at the minute we are still working on more prosaic features.

Aside from that there are very interesting program correctness and optimisation systems which are based on prolog (usually a datalog). For instance Soufflé: https://souffle-lang.github.io

There exists a formulation of the Japanese Constitution in Prolog, which can then be called with a proposition to determine its constitutionality.

Not exactly a big codebase, but it was a revelation for me how natural typecheckers can feel in Prolog: I basically rewrote typing rules with some tweaks: [1]

Also, tests were surprisingly enjoyable in Prolog: [2].

[1] https://github.com/EarlGray/language-incubator/blob/29755c32... [2] https://github.com/EarlGray/language-incubator/blob/29755c32...

Not sure how helpful it is for your purposes, but I found the usage of Prolog in Windows NT to dynamically build the network stack super fascinating: https://web.archive.org/web/20040603192757/research.microsof...

I use it for reverse engineering unknown struct layouts for DWG classes. A field packing problem.

I'm using picat, a better Prolog dialect, and generate the facts automatically from C to generate the field layouts via picat automatically.

https://github.com/LibreDWG/libredwg/blob/master/examples/AC...

optimization problems as in compilers are extremely natural in Prolog.

I wrote commercial Prolog applications circa 1990 and it is the nicest programming language that I know (I used over 30 in my 50 year career); I recommend the book The Art of Prolog, by Ehud Shapiro. Also the idea that with Prolog, you can easily write programs that write programs (I wrote a few of those) and that it may be feasible to scale up a program to fill in the code to match input and output descriptions, and build possibly unlimited complex logic on top of simpler components, as I think Shapiro was working on this approach in the 1990's for the Israeli gov., before the project went under the covers, it seems.

Not a lot of code but a somewhat different use of Prolog than you're likely to see elsewhere. I used my fork of a MQTT library for Prolog (https://github.com/sprior/swi-mqtt-pack) to implement the central controller for my home automation system. The system responds to MQTT events and then coordinates the appropriate action by sending MQTT messages to other home services. Recent versions of SWI-Prolog also support redis and I've started using that to store device configuration and state between services. The MQTT version is actually a reimplementation of my previous version which used CORBA for inter-service communication.

I don't distribute the home automation code however it's pretty specific to my house. The MQTT library provides some building block examples.

You can also see some other comments I've made on HN which describe some other details.

The Tau Prolog (http://tau-prolog.org) system (written in JS) is used here https://www.codebymath.com/index.php/welcome/lesson_menu#pro... to use Prolog as a way of teaching mathematical concepts.

The first version of erlang was written in prolog. https://wikipedia.org/wiki/Erlang_(programming_language)

Mercury (https://mercurylang.org) is a language descended from Prolog that has some interesting examples. Personally I think it shows a lot more promise than many other languages people get very excited about.

I used Prolog at my job to fill out complex regulatory forms required in the financial industry. I have a Perl module that queries an Oracle database and constructs the facts database. This is paired with a set of rules to write out the form elements.

I have one other Prolog project that is part of a tool. It explains the relationship between potentially related people. It is used in financial surveillance.

Gerrit's prolog rules may be worth a look: https://gerrit-documentation.storage.googleapis.com/Document... .

You could look at "PRESS: PRolog Equation Solving System", "a system for solving symbolic, transcendental, non-differential equations."

    Journal of Symbolic Computation
    Volume 7, Issue 1, January 1989, Pages 71-84
    "Solving symbolic equations with PRESS"

https://www.sciencedirect.com/science/article/pii/S074771718...

Source: https://github.com/maths/PRESS

- - - -

BTW, Does anyone know where I can find the source for MIXTUS partial evaluation system?

At work we modelled our role-based access control logic in prolog. Once you realise that your authorization is logic programming, you gain access to better tools, more formal ways to think about it, and a treasure trove of literature. :)

I write Prolog version bulletML in Prolog.

https://github.com/hsk/bulletpl/blob/master/bulletpl/1943_ro...

It is a movement of the rolling fire of CAPCOM shooting game 1943.

Original Bullet ML DSL is XML base, however this version base Edinburgh Prolog format.

http://www.asahi-net.or.jp/~cs8k-cyu/bulletml/index_e.html

At the public funded project http://vvm-projekt.de we are developing methods for verification and validation of autonomous driving. My team developed an analysis method for information flow in urban intersections. The software is implemented in PROLOG (Logtalk). See paper about here (German, will follow in English soon) https://arxiv.org/abs/2108.00252 and infos about implementation https://www.vvm-projekt.de/fileadmin/user_upload/Mid-Term/VV... and https://www.vvm-projekt.de/fileadmin/user_upload/Mid-Term/VV... (English). The project will be finished mid 2023

Cheers Hans

Alpino is a natural language parser and generator for Dutch, written largely in (SICStus) Prolog and some C/C++:

https://github.com/rug-compling/Alpino

Even in the age of neural parsers, it's still one of the most competitive parsers for Dutch.

Not sure it is recommended reading, but maybe to see what else you could do with Prolog besides interpreters, DSLs etc:

As part of a knowledge systems course we built a small game in (mostly) Prolog

https://github.com/tobischo/mine-prolog-tba

https://www.metalevel.at/prolog/showcases/ https://www.metalevel.at/lisprolog/

Not sure if you'd consider this a "complete application" that is bigger than a "Hello-World-esque example" but I've worked on a Discord bot in SWI Prolog[1] for a while with a friend. It was an interesting experience and although a lot of the work (e.g. SWI has a ready-made library for interfacing with WebSockets and sending out HTTPS requests).

Some interesting applications of Prolog specifically include using predicates to filter messages by certain criteria (e.g. if it was sent by the bot's account or not), being able to hot-reload by invoking the make/0 predicate, and homoiconicity to (in theory) easily evaluate random code supplied by a user.

[1]: https://github.com/prolord-pl/prolord

Here's an example for a problem that's moderately difficult to do recursively, hard to do iteratively, and trivial in Prolog:

Given that you have the following coins, 1¢ (i.e. 1 cent or $0.01), 5¢, 10¢, 25¢, 50¢, how many different ways are there to give change for a dollar? For example, one way would be to give 2x50c, another would be to give 100x1c. How many are there total?

In most languages this is not super easy to do unless you're very comfy with recursion.

In Prolog the solution is basically (pseudocode):

    100 = a*50 + b*25 + c*10 + d*5 + e*1

and Prolog will just figure out all possible combinations for you.

The challenge with Prolog as far as I understand is making things fast.

Make files are prolog programs in drag.

I usually check out the GitHub Trending page for a programming language. Amusingly, the project you linked is the only result for Prolog this month on GitHub.

https://github.com/trending/prolog?since=monthly

DFS Tools [0] is a Prolog implementation of the Distributional Formal Semantics framework [1].

[0] https://github.com/hbrouwer/dfs-tools [1] https://www.sciencedirect.com/science/article/pii/S089054012...

Don't think you'd get the codebase for it, but I know this is built in SWI prolog https://www.securitease.com/ . Looks like it was presented a decade ago https://dtai.cs.kuleuven.be/CHR/files/Elston_SecuritEase.pdf

I've recently come across "The Eye of Horus", a paper + associated code base [1] analysing attacking transactions on smart contracts using DataLog (a subset of Prolog). Not all of it is written in DataLog, but the vulnerability analysis is - the core component of the framework.

[1] https://arxiv.org/abs/2101.06204

Norvig’s AI book has a lot of prolog in it.

Lots of neat examples in this book: https://www.amazon.com/Clause-Effect-Programming-Working-Pro...

A great Prolog project would be the implementation of Godel's logic language.

Not an example of prolog but I wish Ed had time to continue developing https://github.com/ekmett/guanxi.

I made this demo project a while back, you might find it useful:

https://github.com/SallySoul/regexc

eval(I,I):-integer(I).

eval(E1+E2,I):- eval(E1,I1),eval(E2,I2), I is I1+I2.

eval(E1E2,I):- eval(E1,I1),eval(E2,I2), I is I1I2.

:- eval(12+34,R),writeln(R),R=14.

:- halt.

Very simple Operational Semantics.

this mean

syntax

e ::= i | e+e | e * e

evaluation rule

-------------- (E-Int)

i1-->i1

e1-->i1 e2-->i2

i is i1+i2

------------------- (E-Plus)

e1+e2 --> i

e1-->i1 e2-->i2

i is i1i2

------------------- (E-Times)

e1*e2 --> i

I vaguely remember Maemo on Nokia N900 used Prolog to manage the sound system (notifications, priorities etc).

What’s the best way to get started with Prolog on macOS? Implementations, editors, etc?

Prolog is a programming language that was developed in the 1970s. It is a logic-based programming language, which is pretty different from your typical programming language. Instead of writing functions and then having the computer execute them, Prolog lets you write rules and it will try to deduce the answers to your questions.

It's a pretty wild concept, and there are tons of cool examples of what Prolog can do. Some examples are:

- A solver for Suduko puzzles: https://rosettacode.org/wiki/Sudoku#Prolog

- A simple game where you guess a person's age: https://rosettacode.org/wiki/Guess_the_number#Prolog

- A family tree program: https://rosettacode.org/wiki/Family_tree#Prolog