# How I accidentally learned Prolog

This year at the London Computation Club, we’ve been reading Types and Programming Languages (TAPL). We covered about half the book, completing three of the book’s six sections: Untyped Systems, Simple Types, and Subtyping. It’s probably the most challenging text we’ve tackled in the club, and certainly one of the most challenging books I’ve read, especially as I have no formal computer science training.

Despite its difficulty, as we got into it I began to find it surprisingly accessible. It is entirely possible to read the book and get a lot out of it even if you approach it informally and skip over all the mathematical proofs. However, to get much out of it you will need to become familiar with one core concept: formal definitions of logical rules for the evaluation and typing of programs. Exploring these rules with code meant that as well as learning the material in the book, I accidentally learned the basics of logic programming, a radically different way of thinking about code if you’re used to imperative systems.

The first formal system we encounter in the book is a very simple language consisting only of the boolean values `true` and `false`, and the conditional expression `if x then y else z`. We learn how to formally describe a process for evaluating expressions in this language, via the following rules.

First, an if-expression whose condition is the literal value `true`, reduces to the then-expression. We say that `(if true then \$t2 else \$t3)` evaluates to `\$t2` in one step, and we use the symbol `->` to mean “evaluates in one step to”. TAPL calls this rule `E-IfTrue`, and we write it as:

``````rule E-IfTrue {
(if true then \$t2 else \$t3) -> \$t2
}
``````

Second, an if-expression whose condition is `false`, reduces to the else-expression:

``````rule E-IfFalse {
(if false then \$t2 else \$t3) -> \$t3
}
``````

Finally, if the condition does not yet have a specific value, but can be reduced, then we reduce the whole if-expression by reducing the condition. This is written as the following rule, which says that if `\$t1` evaluates to `\$t1'`, then `(if \$t1 then \$t2 else \$t3)` evaluates to `(if \$t1' then \$t2 else \$t3)`, i.e. if the condition is not yet one of the exact values `true` or `false`, then reduce it one step.

``````rule E-If {
\$t1 -> \$t1'
---------------------------------------------------------
(if \$t1 then \$t2 else \$t3) -> (if \$t1' then \$t2 else \$t3)
}
``````

The text above the line is the premise of the rule, and the text below the line is its conclusion. Rules without this line, like `E-IfTrue`, should be read as just a conclusion, with no premises: they state things that are true without depending on any other conditions.

We can use these rules to evaluate nested conditional expressions:

``````(if (if true then false else true) then false else true) -> ?
``````

Neither `E-IfTrue` nor `E-IfFalse` match this statement; the condition of the outer if-expression does not have the literal value `true` or `false`, it is itself another if-expression. So we need to use `E-If` to reduce the inner expression, `(if true then false else true)`.

This inner expression matches `E-IfTrue` and so we can reduce it directly to `false`. We write a proof of this result as:

``````——————————————————————————————————————— E-IfTrue
(if true then false else true) -> false
``````

The line above the result tells us which rule was used to prove it. We can use this result to evaluate our original if-expression, since we know its condition can be reduced.

``````                          ——————————————————————————————————————— E-IfTrue
(if true then false else true) -> false
——————————————————————————————————————————————————————————————————————————————————————————— E-If
(if (if true then false else true) then false else true) -> (if false then false else true)
``````

This proof says: because we know from `E-IfTrue` that ```(if true then false else true)``` evaluates to `false`, we therefore know by `E-If` that the outer expression evaluates to `(if false then false else true)`. We could evaluate this one more time by applying `E-IfFalse`:

``````——————————————————————————————————————— E-IfFalse
(if false then false else true) -> true
``````

From this chain of reasoning, we know that our original expression ultimately evaluates to `true`. There are no rules whose conclusion has the form ```true -> \$t```, so this cannot be evaluated further.

This language might not seem especially useful, but this process of defining semantics as a set of formal rules is what lets us prove things about programs, and all the type systems in the book are defined as sets of rules like this.

For example, we can write rules that say both `true` and `false` have type `Bool`; the symbol `:` means “has the type”:

``````rule T-True {
true : Bool
}

rule T-False {
false : Bool
}
``````

Then we can write a more complicated rule for the type of if-expressions. An if-expression evaluates to either its then-clause or its else-clause, and the type of an if-expression should match the type of what it evaluates to – in type systems, this property of the type remaining the same after evaluation is called preservation. This means that the then- and else-clause should have the same type. We write this rule to say: if the condition has type `Bool`, and the two clauses both have some type `\$T`, then the whole expression has type `\$T`. (This rule has three premises and they are divided by a `/` symbol.)

``````rule T-If {
\$t1 : Bool / \$t2 : \$T / \$t3 : \$T
--------------------------------
(if \$t1 then \$t2 else \$t3) : \$T
}
``````

We can glue these rules together to prove the type of compound expressions, for example:

``````———————————— T-False   ——————————— T-True   ———————————— T-False
false : Bool           true : Bool          false : Bool
———————————————————————————————————————————————————————— T-If
(if false then true else false) : Bool
``````

In this language where booleans are the only type this is not particularly interesting, but as more forms are added to the language, we write typing rules for them. For example, we say the value `0` has type `Nat`, short for “natural number”.

``````rule T-Zero {
0 : Nat
}
``````

We also add a function called `iszero`; `iszero 0` evaluates to `true` and all other inputs return `false`. Its typing rule says that if its input has type `Nat`, then its result has type `Bool`.

``````rule T-IsZero {
\$t : Nat
------------------
(iszero \$t) : Bool
}
``````

Now we can show that if-expressions can have other types, if their clauses are things other than booleans:

``````——————————— T-True   ——————— T-Zero   ——————— T-Zero
true : Bool          0 : Nat          0 : Nat
————————————————————————————————————————————— T-If
(if true then 0 else 0) : Nat
``````

And we can also decide some programs won’t compile, because the types don’t match. For example, `if 0 then true else false` cannot be typed, because the first premise in `T-If` becomes `0 : Bool`, which cannot be matched to any rule. `if true then 0 else false` cannot be typed, because `0` and `false` have different types and the repeated variable `\$T` in `T-If` means the types must match.

We can build arbitrarily nested trees of these proofs as our expressions become more complex:

``````     ——————— T-Zero
0 : Nat
————————————————— T-IsZero   ——————————— T-True   ———————————— T-False
(iszero 0) : Bool            true : Bool          false : Bool
—————————————————————————————————————————————————————————————— T-If
(if (iszero 0) then true else false) : Bool
``````

TAPL progresses by inventing increasingly sophisticated typing rules that let us put useful constraints on programs and reject those that would crash at runtime. All these typing rules are essentially of the same kind we’ve seen above: a (possibly empty) set of premises followed by a conclusion, containing variables that can be filled in with arbitrary expressions.

The rules as I’ve written them above are very close to how they’re presented in the book, with minor modifications for writing them as ASCII text. In fact, the rules written out like this can be directly interpreted by a library I wrote to implement the ideas in the book: Infer. It’s based on an initial version of the idea, Tom Stuart’s inference-rules, and all it does is attempt to match input statements to the rules, and print a proof if a match can be found. For example, here’s the code for the last example:

``````rules = Infer.lang('./rules.txt')
expr  = Infer.expr('(if (iszero 0) then true else false) : \$?')

state = rules.derive(expr).first
Infer.print_derivation(state.build_derivation)
``````

Infer figures out what the value of that variable `\$?` should be, and generates a proof for the result it found. The process it goes through to do this is fairly simple. We start with the statement we’re trying to prove:

``````(if (iszero 0) then true else false) : \$?
``````

Infer has almost no built-in syntax; the only rules are that things beginning with `\$` are variables, and parentheses group things. Everything else is an arbitrary meaningless symbol from Infer’s point of view, and all it’s trying to do is find rules whose conclusions can be made to match this statement.

What do we mean by matching in this context? It means that two sequences of symbols can be made equal to each other by replacing variables. For example, the sequences `1 \$X 3` and `1 2 \$Y` can be made equal by setting `\$X` = `2` and `\$Y` = `3`. Occurrences of the same variable must be equal, so for example `\$X \$X` can be made to match `2 2` but not `3 4`.

If we look through the rules above, the only one whose conclusion has the right form to match our target statement is `T-If`, whose conclusion is

``````(if \$t1 then \$t2 else \$t3) : \$T
``````

We match this against our target statement:

``````(if (iszero 0) then true else false) : \$?
``````

This match gives us:

• `\$t1` = `(iszero 0)`
• `\$t2` = `true`
• `\$t3` = `false`
• `\$T` = `\$?`

Then we look at the premises of `T-If`. First, we require `\$t1 : Bool`, that is `(iszero 0) : Bool`. There is a rule whose conclusion matches this: `T-IsZero` with `(iszero \$t) : Bool`. This gives us `\$t` = `0`, and this rule has premise `\$t : Nat`, which is satisfied by using `T-Zero` to show `0 : Nat`. That takes care of the first premise in `T-If`.

The next premise says that `\$t2 : \$T`, and at this point we know `\$t2` is `true`. Is there a rule to match `true : \$T`? Yes: `T-True` says `true : Bool`, so that means `\$T` must be `Bool`.

Now the final premise: `\$t3 : \$T`. We now know both `\$t3` and `\$T`, so we want to show that `false : Bool`, and indeed we can do that using `T-False`. If we had previously decided `\$T` was `Nat`, then we’d be trying to match ```false : Nat```, and there is no rule that will generate this, so the expression cannot be typed.

Having proved all the premises, we can apply `T-If` to conclude the type of the entire expression, and since we have matched the `\$?` variable to `\$T`, we can conclude that `\$?` is `Bool`.

This example demonstrates the basic mechanics of answering questions like “what type does this expression have”. We phrase the question as a statement like “the expression has type `?`”, and then we match the statement against the rules to try to find out what `?` is. When a rule has premises, we recursively try to match each of those in the same way, storing the values of variables as we go. The trace of rules invoked as we match parts of the statement forms a proof of the statement.

This method might not look very powerful, but it can actually be used to perform arbitrary computation, and it is the basis of logic programming. Rather than executing a sequence of statements, as imperative programs do, logic programs are declarative sets of rules that input queries are matched against. A query is just any statement we’d like to prove, and it may have variables in it: `(if true then false else true) : \$?` is a query where we’d like to know the value of `\$?` if one exists.

Logic programming is radically different to imperative programming, and has some powerful properties. We can view the above rules as defining a function that computes the type of an expression, if it can be typed. Each expression should have a single well-defined type, and so this function should return a single value, as we are used to in imperative languages. However, logic functions don’t have to behave that way: they can generate any number of results, and they can be run “backwards”.

For example, rather than ask for the type of an expression, we could ask for all the expressions that have type `Bool`. We’d express this as the query ```\$? : Bool```, and we can evaluate it just as we did before:

``````expr = Infer.expr('\$? : Bool')

rules.derive(expr).each do |state|
Infer.print_derivation(state.build_derivation)
end
``````

This will print a few obvious things that we can reach in one step:

``````——————————— T-True
true : Bool
``````

It will also print things that require a little more work:

``````     ——————— T-Zero
0 : Nat
————————————————— T-IsZero
(iszero 0) : Bool
``````

It will generate complex nested expressions:

``````     ——————— T-Zero
0 : Nat
————————————————— T-IsZero   ——————— T-Zero   ——————— T-Zero
(iszero 0) : Bool            0 : Nat          0 : Nat
————————————————————————————————————————————————————— T-If
(if (iszero 0) then 0 else 0) : Nat
————————————————————————————————————————————— T-IsZero
(iszero (if (iszero 0) then 0 else 0)) : Bool
``````

And it just keeps going, generating an infinite series of all the expressions that have the desired type:

``````                                           ——————— T-Zero
0 : Nat
————————————————— T-IsZero   ——————— T-Zero   ——————— T-Zero
(iszero 0) : Bool            0 : Nat          0 : Nat
——————————— T-True   ——————— T-Zero   ————————————————————————————————————————————————————— T-If
true : Bool          0 : Nat                   (if (iszero 0) then 0 else 0) : Nat
—————————————————————————————————————————————————————————————————————————————————— T-If
(if true then 0 else (if (iszero 0) then 0 else 0)) : Nat
——————————————————————————————————————————————————————————————————— T-IsZero
(iszero (if true then 0 else (if (iszero 0) then 0 else 0))) : Bool
``````

This ability to explore all the possible true statements from a declarative set of rules is core to logic programming, and it makes it particularly good at search and constraint-solving problems.

Generating all possible results like this certainly felt like a neat trick when I first encountered it. (Incidentally, my first encounter with this technique was via a language called microKanren in Tom’s talk Hello, declarative world.) But how does one do real programming? How do we handle state and use data structures? The answer involves a little bit of retraining your brain, so let’s take another example from TAPL.

When we introduce user-defined functions, they look like this: `λx: T. t`. This is, the symbol `λ` (lambda), followed by a parameter `x`, then the parameter’s type `T`, and finally the function’s body, which is a single term `t`. Here’s an example function:

``````λn: Nat. (if (iszero n) then false else true)
``````

When we type-check a program, we recursively go into every sub-expression in the program and work out its type. To computer the type of `(iszero n)` above, we need to know the type of `n` – we need to remember that the function definition says that `n` has type `Nat`, which would means `(iszero n)` is a well-typed expression. We do this with something called a typing context, which is just a data structure that remembers the types of any parameters that are currently in scope.

In Ruby, we’d just use a hash for that: `{ 'x' => Nat }`. Each time we enter a lambda-expression, we add its parameter and type to this hash, and then carry the hash down into the function’s body as we check its type. But the language we’ve seen above doesn’t have any apparent data structures, or ways of updating them, so we need to invent one.

In TAPL, typing contexts are referred to by the letter `Γ` (gamma). A context is a list of pairs of parameters and their types. The structure of these lists is defined recursively; a context is either:

• the empty context, `∅`
• a context with a parameter-type pair `x : T` appended

So, these are all valid contexts:

``````∅
(∅ , x : Bool)
((∅ , x : Bool) , y : Nat)
``````

We can then write a pair of rules for getting the type of a variable in a given context; the statement `Γ ⊢ x : T` means “in context `Γ`, the term `x` has type `T`”. First, we use pattern-matching on the structure of the context: if the context ends with the pair `\$x : \$T`, then the type of `\$x` in the context is `\$T`.

``````rule T-Var-1 {
(\$Γ, \$x : \$T) ⊢ \$x : \$T
}
``````

Then we write a case for when the parameter doesn’t match the last pair in the context. By writing `(\$Γ, \$y : \$S)`, we destructure the context into its final pair `\$y : \$S` and everything before it, `\$Γ`. The premise says that if `\$x` has type `\$T` in this reduced context, then it has the same type in the reduced context with one pair added.

``````rule T-Var-2 {
\$Γ ⊢ \$x : \$T
-----------------------
(\$Γ, \$y : \$S) ⊢ \$x : \$T
}
``````

These rules define a recursive method for looking up the type of a parameter in a list of key-value pairs. Here are a couple of proofs that show the recursion working, first for the base case:

``````————————————————————————— T-Var-1
(∅ , x : Bool) ⊢ x : Bool
``````

And then for the recursive case:

``````      ——————————————————————— T-Var-1
(∅ , y : Nat) ⊢ y : Nat
———————————————————————————————————— T-Var-2
((∅ , y : Nat) , x : Bool) ⊢ y : Nat
``````

(These were derived by entering a query like `(∅ , x : Bool) ⊢ x : \$?`.)

We can now use this typing-context abstraction to write a rule for computing the type of a function. This rule says that in context `Γ` a function `λx: T. t` has type `T → S` if, in the extended context `(Γ, x: T)`, the body `t` has type `S`.

``````rule T-Abs {
(\$Γ, \$x : \$T) ⊢ \$t : \$S
---------------------------------
\$Γ ⊢ (λ \$x : \$T . \$t) : (\$T → \$S)
}
``````

At this point all the other rules must be extended with rules to pass the context around; all we need to do is add `\$Γ ⊢` to the start of each premise and conclusion, for example:

``````rule T-Zero {
\$Γ ⊢ 0 : Nat
}

rule T-IsZero {
\$Γ ⊢ \$t : Nat
-----------------------
\$Γ ⊢ (iszero \$t) : Bool
}
``````

Now we can run a query to see if we can figure out the type of an expression inside a function:

``````query: ∅ ⊢ (λn: Nat. (iszero n)) : \$?

——————————————————————— T-Var-1
(∅ , n : Nat) ⊢ n : Nat
————————————————————————————————— T-IsZero
(∅ , n : Nat) ⊢ (iszero n) : Bool
——————————————————————————————————————————— T-Abs
∅ ⊢ (λ n : Nat . (iszero n)) : (Nat → Bool)
``````

Indeed we can. Let’s try something more complex to make sure the context is passed down into sub-expressions:

``````query: ∅ ⊢ (λn: Nat. (if (iszero n) then false else true)) : \$?

——————————————————————— T-Var-1
(∅ , n : Nat) ⊢ n : Nat
————————————————————————————————— T-IsZero   ———————————————————————————— T-False   ——————————————————————————— T-True
(∅ , n : Nat) ⊢ (iszero n) : Bool            (∅ , n : Nat) ⊢ false : Bool           (∅ , n : Nat) ⊢ true : Bool
——————————————————————————————————————————————————————————————————————————————————————————————————————————————— T-If
(∅ , n : Nat) ⊢ (if (iszero n) then false else true) : Bool
————————————————————————————————————————————————————————————————————— T-Abs
∅ ⊢ (λ n : Nat . (if (iszero n) then false else true)) : (Nat → Bool)
``````

Implementing the various language extensions and subtyping rules in TAPL is excellent practice in expressing rules as executable logic programs, and you’ll soon discover you can get a very long way by using pairs of rules to recursively pattern-match over nested structures. A good example of this is the rules for records, a key-value pair structure that’s used repeatedly in the text. Some more advanced patterns can be found in my implementation of joins and meets, the rules for finding common supertypes and subtypes which are used in the subtyping relation.

So finally, what does this all have to do with Prolog? Well Prolog is probably the best-known logic programming language. One of our group, Simon Coffey, was using it in his implementation, and he gave me a lot of help in learning it and figuring out my own logic rules. Through his explanations, I realised that this language that had always looked bizarre and impenetrable to me was actually the thing I’d just spent months learning and implementing! The language I’d cooked up for doing TAPL was just a small subset of Prolog with different syntax.

Here’s the same rules written in Prolog. Instead of premises followed by a line then a conclusion, Prolog rules put the conclusion first, then the symbol `:-`, then the premises. Expressions in Prolog are not quite as free-form as in Infer; they must take the form `a(b, c, ...)`. Variables begin with uppercase letters, and everything else is an arbitrary symbol. Prolog also has lists, written ```[a, b, c, ...]```, or `[a | b]` where `a` is the first element and `b` is the rest of the list. See if you can match these rules to how they’re written above.

``````% types.pl

% T-True
has_type(_, true, bool).

% T-False
has_type(_, false, bool).

% T-If
has_type(Ctx, if(Cond, Then, Else), T) :-
has_type(Ctx, Cond, bool),
has_type(Ctx, Then, T),
has_type(Ctx, Else, T).

% T-Zero
has_type(_, 0, nat).

% T-IsZero
has_type(Ctx, iszero(T), bool) :- has_type(Ctx, T, nat).

% T-Var-1
has_type([[X, T] | _], X, T).

% T-Var-2
has_type([_ | Ctx], X, T) :- has_type(Ctx, X, T).

% T-Abs
has_type(Ctx, λ(X, T, Body), fn(T, S)) :-
has_type([[X, T] | Ctx], Body, S).
``````

You can download a Prolog implementation like SWI Prolog, load this file into it and run queries:

``````\$ swipl types.pl

?- has_type([], λ(n, nat, if(iszero(n), false, true)), T).
T = fn(nat, bool).
``````

Because I had most of the machinery necessary to run logic programs, I decided to stick a different parser on the front and bootstrap a Prolog implementation of my own. Because Infer has a module for printing the proof tree of any result, I could then use this to show traces of my Prolog code, which was really useful while learning. Here’s a Ruby snippet for proving the above statement:

``````types = Infer::Prolog.program(File.read('types.pl'))

expr = 'has_type([], λ(n, nat, if(iszero(n), false, true)), T).'
Infer::Prolog.execute_and_print(types, expr)
``````

And the result:

``````    ————————————————————————————
has_type([[n, nat]], n, nat)
—————————————————————————————————————      —————————————————————————————————      ————————————————————————————————
has_type([[n, nat]], iszero(n), bool)      has_type([[n, nat]], false, bool)      has_type([[n, nat]], true, bool)
——————————————————————————————————————————————————————————————————————————————————————————————————————————————————
has_type([[n, nat]], if(iszero(n), false, true), bool)
——————————————————————————————————————————————————————————————————
has_type([], λ(n, nat, if(iszero(n), false, true)), fn(nat, bool))

T = fn(nat, bool)
``````

I’ve barely scratched the surface of Prolog and logic programming here, but hopefully this gives you a flavour of how different it is, and how to solve simple problems with it. It’s a lot like pure functional programming as found in languages like Haskell, but without any distinction between function inputs and outputs. It’s a really good discipline to learn as it forces you to formalise your understanding of a problem and prove things about it. And, it goes to show how trying to study one topic can lead you to learn all sorts of other things by accident, just by seeing them in an unexpected context.