gprolog.org

Finite domains (FD) in GNU Prolog let a logic variable range over a bounded set of integers instead of being a free, unbound term. You post constraints over those variables, and the solver prunes impossible values before any search happens. GNU Prolog is a free Prolog compiler with a built-in FD constraint solver, so you get constraint programming and ISO-standard Prolog in one system without a separate library or explicit domain declarations.

Finite domains vs. plain Prolog unification

In plain Prolog, an unbound variable stands for anything, and X = 3 simply binds it. There is no notion of "X must be between 1 and 9." You can only test a value after it is bound, so combinatorial problems are solved by generate-and-test: enumerate candidates, then check each one. That is correct but slow, because failures are detected late.

A finite-domain variable is different in one key way: its possible values are restricted up front, and constraints propagate that restriction. If X has domain 1..9 and you post X #> 7, the solver immediately narrows X to 8..9. Any later constraint that would empty a domain fails at once rather than after a long enumeration.

How GNU Prolog integrates FD variables

GNU Prolog's FD variables are fully compatible with ordinary Prolog variables and integers, and the site states there is no need for explicit FD declarations. You do not open a special mode or declare a variable's type; you introduce a domain by using FD constraints on it. This keeps FD code readable as normal Prolog and lets you mix constraint solving with the rest of the language (unification, recursion, DCGs, the C interface).

The solver itself is described as very efficient and comparable to commercial solvers, and high-level constraints can be described in terms of simple primitives. That means the predefined constraints are convenient surface syntax over a smaller core, which is useful to know when you want to write your own propagator.

The typical workflow

Constraint programs in GNU Prolog follow three phases:

1. Declare domains — restrict each variable to a finite range, e.g. X :: 1..9 or via an arithmetic FD constraint.
2. Post constraints — relate variables with arithmetic relations, all_different, and similar predefined constraints. The solver propagates and prunes domains.
3. Label / search — assign concrete values to the remaining variables (labeling), backtracking through the reduced search space.

The important point is ordering: propagation does the pruning, labeling does the enumeration. If you label too early you lose the benefit of propagation; if you never label you get a store of constrained variables but no concrete solution.

A small example

A classic fit is Sudoku-style or assignment puzzles, where each cell has domain 1..9 and rows, columns, and boxes must be all-different. In GNU Prolog you would:

• give every cell the domain 1..9,
• post all_different on each row, column, and 3×3 box,
• post the given clues as equalities,
• then label the cells.

Propagation alone often fills many cells before search begins, which is exactly the gain over generate-and-test. The same pattern applies to scheduling: tasks with start times in a range, precedence constraints between them, and all_different on shared resources.

What you get beyond the solver

GNU Prolog is a compiler as well as an interpreter. It accepts Prolog+constraint programs and produces native, stand-alone executables (comparable to how gcc turns C into a binary), and it avoids linking most unused built-in predicates, so executables can be small. The Prolog side conforms to the ISO standard with extensions such as global variables, DCGs, sockets, and an OS interface, and there are more than 300 built-in predicates plus a Prolog debugger and a low-level WAM debugger.

Choosing it, with conditions

GNU Prolog suits you if you want FD constraint solving and native compilation in one free system, and you are comfortable with Prolog syntax. It is a strong fit for combinatorial puzzles, scheduling, and assignment problems where domains are naturally finite integer ranges. If your problem needs continuous or real-valued constraints, or a large ecosystem of external constraint libraries, this FD solver is not aimed at that. The current stable version listed on the site is gprolog-1.5.0; check the manual and supported-platforms pages for details on your target system before committing.

In GNU Prolog, a constraint is a relation you state over finite-domain (FD) variables, and the built-in FD solver propagates that relation to prune the values each variable can still take. You write ordinary Prolog plus constraints; GNU Prolog accepts the combined "Prolog+constraint" program and can compile it to a stand-alone native binary. This page explains the mechanism and the workflow; for the exact list of predefined constraints and solver predicates, use the GNU Prolog manual linked from the site.

Constraint logic programming and finite domains

Constraint logic programming (CLP) extends logic programming by letting you state relations over variables rather than enumerate assignments yourself. In the finite-domain variant, each variable ranges over a finite set of integers. Instead of generating and testing candidate values, the solver reasons about the domains and removes values that cannot satisfy the posted constraints.

GNU Prolog includes "an efficient constraint solver over Finite Domains (FD)," which the site describes as opening constraint logic programming to the user by "combining the power of constraint programming to the declarativity of logic programming." The solver is characterized as "very efficient" and "comparable to commercial solvers."

How FD variables integrate with Prolog

The integration is deliberately transparent:

• FD variables are "well integrated into the Prolog environment (full compatibility with Prolog variables and integers)."
• There is "no need for explicit FD declarations" — you do not have to pre-declare a variable as finite-domain before constraining it.
• High-level constraints "can be described in terms of simple primitives," and the system ships with "a lot of predefined constraints."

The practical consequence: you can mix FD variables with ordinary Prolog variables and integers in the same program, and add constraints as goals, without a separate declaration layer.

From a Prolog+constraint program to a native executable

GNU Prolog is a compiler, not only an interpreter. The workflow the site describes:

1. Write a Prolog+constraint program — Prolog clauses plus FD constraints.
2. Compile it with the command-line compiler, which accepts "a wide variety of files: Prolog files, C files, WAM files,..." and generates assembly code directly.
3. Get a stand-alone executable. Because "most of unused built-in predicates are not linked," the binary "can be quite small."

Alongside native compilation, GNU Prolog offers "a classical interactive interpreter (top-level) with a debugger," so you can develop and test interactively before compiling.

What the Prolog side provides

The surrounding system matters because constraints live inside it:

• Conformance to the ISO standard for Prolog (floating point numbers, streams, dynamic code, and more).
• Extensions useful in practice: global variables, definite clause grammars (DCG), sockets interface, operating system interface.
• More than 300 built-in predicates.
• A Prolog debugger and a low-level WAM debugger.
• A "powerful bidirectional interface between Prolog and C."

Reported performance: compiled (native-code) predicates are "as fast as wamcc on average," consulted (byte-code) predicates are "5 times faster than wamcc," and assembly generation is "15 times faster than wamcc + gcc."

Where to find the predefined constraints

The site's feature list states there are "a lot of predefined constraints" but does not enumerate them in the excerpt available here. The authoritative list of predefined constraints and solver predicates is in the Manual, which is a section of the GNU Prolog web site. Treat the manual as the reference for exact predicate names and semantics rather than inferring them from this overview.

Practical takeaways

• Constraints in GNU Prolog are FD relations posted over variables that range over finite integer sets; the solver propagates them to reduce domains.
• You do not declare FD variables explicitly — they are compatible with ordinary Prolog variables and integers.
• You can develop in the interactive top-level and then compile to a stand-alone native binary.
• Current stable version listed on the site: gprolog-1.5.0.
• For the concrete constraint vocabulary, consult the Manual section of gprolog.org.

GNU Prolog is a free Prolog compiler with constraint solving over finite domains, developed by Daniel Diaz. It accepts Prolog+constraint programs and produces native binaries the way gcc produces executables from C source — the resulting executable is stand-alone and can be quite small, because GNU Prolog avoids linking the code of most unused built-in predicates. Choose it when you want ISO-standard Prolog, native-code compilation to a self-contained binary, and an efficient finite-domain (FD) solver in one system. The current stable version listed on the project site is gprolog-1.5.0.

The two ways to run GNU Prolog

GNU Prolog gives you both a compiler and an interpreter, and they serve different purposes.

The compiler is driven from a simple command line and accepts a wide variety of files — Prolog files, C files, WAM files, and more. Because it generates assembly code directly, the site reports it is 15 times faster than the older wamcc + gcc route. Compiled (native-code) predicates run as fast as wamcc on average, and consulted (byte-code) predicates run 5 times faster than wamcc. The project describes overall performance as comparable to commercial systems.

How the FD constraint solver works

The FD solver is the part that makes GNU Prolog a constraint logic programming system rather than just a Prolog compiler. The key design choice is integration: FD variables are fully compatible with ordinary Prolog variables and integers, and there is no need for explicit FD declarations. You write constraints directly over your variables, and the solver propagates and prunes the domains.

The site describes the solver as very efficient (comparable to commercial solvers), with high-level constraints expressible in terms of simple primitives and a large set of predefined constraints. This is what opens constraint logic programming to the user — combining constraint programming's power with logic programming's declarativity.

A concrete way to think about it: instead of generating and testing candidate values one at a time, you state the relations among variables and let the solver narrow each variable's domain until a consistent assignment remains. That is the difference between search-then-check and constrain-then-propagate.

What else is in the system

Beyond compilation and constraints, GNU Prolog includes:

• ISO conformance with practical extensions — the Prolog part conforms to the ISO standard (floating point numbers, streams, dynamic code, and so on), plus extensions such as global variables, definite clause grammars (DCG), a sockets interface, and an operating system interface.
• 300+ built-in predicates.
• Debugging tools — a Prolog debugger and a low-level WAM debugger.
• Line editing under the interactive interpreter, with completion on atoms.
• A powerful bidirectional interface between Prolog and C, which matters if you need to call C from Prolog or embed Prolog in a C program.

When GNU Prolog fits — and when to look elsewhere

GNU Prolog is a strong fit when your requirements line up with its design:

• You want to distribute a stand-alone executable rather than require a Prolog installation on the target machine.
• Your problem is a finite-domain constraint problem — scheduling, assignment, combinatorial search — and you want the solver integrated with ordinary Prolog variables rather than bolted on.
• You want ISO-standard Prolog with extensions like DCG, sockets, and OS access.
• You need a C interface in either direction.

Consider other systems when your needs point elsewhere: if you depend on a large ecosystem of third-party libraries, or on features outside the ISO core that GNU Prolog doesn't list (the site's feature list is the reference here), another Prolog may serve you better. The site also maintains a manual, a download page, mailing lists, and a bug-reporting channel, so you can verify current capabilities and platform support before committing.

Practical starting point

1. Check the Manual and Download sections of the project site for the current release and supported platforms.
2. Prototype in the interactive top-level, using the debugger when a predicate misbehaves.
3. Once the logic and constraints behave, compile to a native binary and confirm the executable runs stand-alone on a machine without GNU Prolog installed.
4. If you hit a limitation, the mailing lists and bug reporting pages are the project's own channels for answers.

A Prolog compiler translates Prolog source into a lower-level form that runs without the original source, and GNU Prolog is a free Prolog compiler that accepts Prolog+constraint programs and produces native binaries, much as gcc produces an executable from C source. The resulting executable is stand-alone, so you can ship it to a machine that has no GNU Prolog installed. This page covers what that means in practice, how the finite-domain (FD) solver fits in, and what to check before adopting it.

Compiler vs. interpreter

Most Prolog systems are used interactively: you load a file, get a top-level prompt, and query predicates while the source is present. That is an interpreter model, and it is convenient for development but ties execution to the Prolog system.

A compiler model instead emits a program that runs on its own. GNU Prolog offers both: native-code compilation for deployment, plus a classical interactive interpreter (top-level) with a debugger for development. So you are not choosing one or the other — you develop in the top-level and compile when you want a deliverable.

How GNU Prolog turns Prolog into a native binary

According to the GNU Prolog site, the compiler:

• Accepts a wide variety of input files on the command line: Prolog files, C files, WAM files, and others.
• Generates assembly code directly, which the site describes as 15 times faster than the older wamcc + gcc route.
• Produces stand-alone executables, like gcc does from a C source.
• Avoids linking the code of most unused built-in predicates, which keeps executable size quite small.

The practical consequence of that last point: a program that uses a handful of predicates does not carry the whole built-in library. Size scales with what you actually call, not with the size of the system.

Basic command-line workflow

The site documents a simple command-line compiler but does not reproduce the exact flags in the excerpt, so treat the following as the shape of the workflow rather than a verbatim command:

1. Write your program in a .pl file, including any FD constraints.
2. Invoke the GNU Prolog compiler on that file from the shell.
3. The compiler emits an executable in the current directory (or the output path you specify).
4. Run the executable directly — it does not need GNU Prolog present.

Verify success by running the produced binary on a machine or container without GNU Prolog installed. If it runs, the stand-alone property holds. If it fails to find predicates, check whether you relied on something that was not linked in.

Common sticking points to expect: mixing Prolog and C sources in one invocation, and forgetting that only used built-ins get linked — so anything resolved dynamically at runtime needs attention.

The finite-domain solver and why it is integrated

GNU Prolog includes an efficient constraint solver over Finite Domains, described as comparable to commercial solvers. The integration detail that matters most:

• FD variables are fully compatible with ordinary Prolog variables and integers.
• There is no need for explicit FD declarations.

That means you do not switch languages or add boilerplate to use constraints — you write Prolog, and constraints are available. The site notes that high-level constraints can be described in terms of simple primitives, and that many predefined constraints ship with the system.

This combination — declarativity of logic programming plus constraint propagation — is the reason to reach for GNU Prolog when a problem is naturally expressed as "assign values to variables subject to constraints" rather than as a search you write by hand.

Performance: what the site claims

Read these as relative comparisons to the wamcc lineage, not as absolute benchmarks against every other Prolog. If raw speed on your workload is the deciding factor, measure it on your own predicates.

What else comes with it

Beyond the compiler and FD solver, the site lists:

• ISO standard conformance for the Prolog part, with extensions such as global variables, DCGs, sockets, and an OS interface.
• More than 300 built-in predicates.
• A Prolog debugger and a low-level WAM debugger.
• Line editing under the interactive interpreter, with completion on atoms.
• A bidirectional interface between Prolog and C.

The current stable version listed is gprolog-1.5.0, and the site maintains a manual, a supported-platforms list, mailing lists, and a bug-reporting channel.

When to choose it

GNU Prolog fits when you want:

• A stand-alone native executable rather than a system-dependent script.
• Small binaries, thanks to unused-predicate elimination.
• FD constraint solving without leaving Prolog.
• An ISO-conformant Prolog with practical extensions and a C interface.

It fits less well if you need a large ecosystem of third-party libraries, or if you depend on features outside the ISO core and its documented extensions. Check the manual and supported-platforms page for your target before committing, and confirm the current version and any build requirements there rather than assuming them.