c  go  java  js  lua  py  vbs  rkt  scm  pro  

True and false can be represented as Prolog facts using the b predicate.

Note that facts are assumed to be true. Realize, though, that Prolog has no idea what the facts for b really mean.

The following Prolog program finds values for X and Y that will succeed, and then backtracks to find successive values until no more values can be found.

Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). b(0). b(1). go:- b(X), b(Y), prints(['X=',X,' Y=',Y,'\n']), fail. :- solve(go).
Here is the output of the Prolog code.
X=0 Y=0\n X=0 Y=1\n X=1 Y=0\n X=1 Y=1\n

The logical negation operator not can be expressed as the Prolog predicate not1 as the following facts.

Note that not1 is used since not is a reserved word in Prolog, as is and and or.

The logical conjunction operator and can be expressed as the Prolog predicate and2 as the following facts.

The logical disjunction operator or can be expressed as the Prolog predicate or2 as the following facts.

Let us start with the logical expression and extended truth table for logical equivalence.

The equivalence operator eqv (equals) can be expressed as the Prolog predicate eqv2 as follows.

Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). b(0). b(1). eqv2(0,0,1). eqv2(0,1,0). eqv2(1,0,0). eqv2(1,1,1). go:- prints(['X Y | X = Y\n']), prints(['------------\n']), b(X), b(Y), eqv2(X,Y,A), prints([X,' ',Y,' | ',X,' ',A,' ',Y,'\n']), fail. :- solve(go).
Here is the output of the Prolog code.
X Y | X = Y\n ------------\n 0 0 | 0 1 0\n 0 1 | 0 0 1\n 1 0 | 1 0 0\n 1 1 | 1 1 1\n
Note the following.

• Logical variables such as X, Y, and A, start with an upper-case letter, unlike atoms such as b, not1, and2, etc., that start with a lower-case letter.
• The logical variable A is used to represent the result of the eqv operator.
• The fail predicate causes backtracking to find the next solution.

Let us use the running example of a logical expression. Here is the expression and extended truth table.

Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). b(0). b(1). and2(0,0,0). and2(0,1,0). and2(1,0,0). and2(1,1,1). or2(0,0,0). or2(0,1,1). or2(1,0,1). or2(1,1,1). not1(0,1). not1(1,0). go:- prints(['X Y | (X & Y) | ((! X) & (! Y))\n']), prints(['-------------------------------\n']), b(X), b(Y), and2(X,Y,A), not1(X,C), not1(Y,E), and2(C,E,D), or2(A,D,B), prints([X,' ',Y,' | (',X,' ',A,' ',Y,') ',B,' ((',C,' ',X,') ',D,' (',E,' ',Y,'))\n']), fail. :- solve(go).
Here is the output of the Prolog code.
X Y | (X & Y) | ((! X) & (! Y))\n -------------------------------\n 0 0 | (0 0 0) 1 ((1 0) 1 (1 0))\n 0 1 | (0 0 1) 0 ((1 0) 0 (0 1))\n 1 0 | (1 0 0) 0 ((0 1) 0 (1 0))\n 1 1 | (1 1 1) 1 ((0 1) 0 (0 1))\n

In an imperative (destructive assignment) programming language the order of the assignments to variables is important.

In a declarative programming logic programming system the order may impact efficiency (and issues due to the depth first search computation strategy) but the order is much less important.

Below, the order of the predicates are reversed (from the above). The result is the same. Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). b(0). b(1). and2(0,0,0). and2(0,1,0). and2(1,0,0). and2(1,1,1). or2(0,0,0). or2(0,1,1). or2(1,0,1). or2(1,1,1). not1(0,1). not1(1,0). go:- prints(['X Y | (X & Y) | ((! X) & (! Y))\n']), prints(['-------------------------------\n']), b(X), b(Y), or2(A,D,B), and2(C,E,D), not1(Y,E), not1(X,C), and2(X,Y,A), prints([X,' ',Y,' | (',X,' ',A,' ',Y,') ',B,' ((',C,' ',X,') ',D,' (',E,' ',Y,'))\n']), fail. :- solve(go).
Here is the output of the Prolog code.
X Y | (X & Y) | ((! X) & (! Y))\n -------------------------------\n 0 0 | (0 0 0) 1 ((1 0) 1 (1 0))\n 0 1 | (0 0 1) 0 ((1 0) 0 (0 1))\n 1 0 | (1 0 0) 0 ((0 1) 0 (1 0))\n 1 1 | (1 1 1) 1 ((0 1) 0 (0 1))\n

Even the order of the values for X and Y can be changed, but note that this may change the order of X and Y in the resulting table. The calculated values are the same. Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). b(0). b(1). and2(0,0,0). and2(0,1,0). and2(1,0,0). and2(1,1,1). or2(0,0,0). or2(0,1,1). or2(1,0,1). or2(1,1,1). not1(0,1). not1(1,0). go:- prints(['X Y | (X & Y) | ((! X) & (! Y))\n']), prints(['-------------------------------\n']), or2(A,D,B), and2(C,E,D), not1(Y,E), not1(X,C), and2(X,Y,A), b(X), b(Y), prints([X,' ',Y,' | (',X,' ',A,' ',Y,') ',B,' ((',C,' ',X,') ',D,' (',E,' ',Y,'))\n']), fail. :- solve(go).
Here is the output of the Prolog code.
X Y | (X & Y) | ((! X) & (! Y))\n -------------------------------\n 1 0 | (1 0 0) 0 ((0 1) 0 (1 0))\n 0 1 | (0 0 1) 0 ((1 0) 0 (0 1))\n 0 0 | (0 0 0) 1 ((1 0) 1 (1 0))\n 1 1 | (1 1 1) 1 ((0 1) 0 (0 1))\n