COMPUTING SCIENCE 370
Programming Languages

Prolog -- Programming in Logic

Highest-Level Language

Characteristics of the ultimate highest-level language:

• Non-procedural: "what", not "how".
• Execute the specification.    [Example ]
• Program execution as theorem proving.
• Database language with automated search and the ability to follow general rules.

Predicate Calculus

• Objects are represented by terms.

  • constant symbol, e.g., monday, camrose, bill
  • variable symbol, e.g., X, Day, City, Person
  • compound term -- a function symbol with an ordered set of terms as arguments, e.g.,
      wife( bill )    [Bill's wife]
      distance( point1, X )    [distance between a particular point and some other point]

• Relationships are expressed with predicate symbols.

  • atomic proposition or predication -- a predicate symbol with an ordered set of terms as arguments, e.g.,
      human( mary )    [Mary is human.]
      owns( X, Y )    [X owns Y.]
      likes( bill, Y )    [Bill likes Y.]

    Note: Predicate calculus distinguishes between function symbols (functors used to construct terms) and predicate symbols (functors used to construct propositions), but Prolog does not. Most versions of Prolog require that there be no space between the functor and the opening parenthesis, but allow spaces between the parentheses, the arguments, and the comma(s).

  • compound proposition -- atomic propositions joined by logical connectives, with variables quantified
    • logical connectives
      • negation: ~a [not a]
      • conjunction: a ^ b [a and b]
      • disjunction: a V b [a or b]
      • implication: a -> b [a implies b]
      • equivalence: a = b [a is equivalent to b; normally shown with a three-line equals sign]
    • quantifiers
      • universal: Ax.P [for all x, P is true; normally shown with an upside-down A]
      • existential: Ex.P [there exists x such that P is true; normally shown with a backwards E]

    Note: "Meaning" is a correspondence drawn between axioms and reality.

• A variety of proof techniques is available.
  E.g., modus ponens

  A -> B
  A
  ---------
  B
  

Automated Theorem Proving

• The Resolution Principle [J.A. Robinson, 1965]

  PROBLEM: Given a large set of available proof techniques, how can a machine be programmed to select a relevant technique correctly and efficiently?

  SOLUTION: A single principle -- the resolution principle -- was proposed which is both

  • sufficient for the proofs of all theorems in first-order predicate logic, and
  • easy to automate.

  REQUIREMENT: All sentences of predicate logic must be converted to a standardized form -- a set of clauses in conjunctive normal form (CNF).

  Conjunctive normal form

  A conjunction of statements, each of which is a literal or a disjunction of literals.

  Literal

  A statement that contains no connectives other than negation.

• There is an algorithm for converting statements into conjunctive normal form:

  1. Eliminate implications.
     a -> b ==> ~a V b

  2. Reduce the scope of negation.
     ~(~p) ==> p
     ~(a ^ b) ==> ~a V ~b
     ~(a V b) ==> ~a ^ ~b
     ~Ax.P(x) ==> Ex.~P(x)
     ~Ex.P(x) ==> Ax.~P(x)

  3. Standardize variables.
     Ax.P(x) V Ax.Q(x) ==> Ax.P(x) V Ay.Q(y)

  4. Eliminate existential quantifiers by use of Skolem constants and functions.
     Ex.P(x) ==> P(S1)
     Ax Ey.P(y, x) ==> Ax.P(S2(x), x)

  5. Move all universal quantifiers to the left, expanding their scope without changing their relative order (prenex normal form)
     Ax.P(x) V Ay.Q(y) ==> Ax Ay.[P(x) V Q(y)]

  6. Drop universal quantifiers. (Variables are now "assumed" universal.)
     Ax Ay.[P(x) V Q(y)] ==> P(x) V Q(y)

  7. Convert to a conjunction of disjunctions (CNF).
     a V (b ^ c) ==> (a V b) ^ (a V c)
     (a ^ b) V c ==> (a V c) ^ (b V c)

  Clausal form: Given a statement in CNF, convert it to clausal form:

  8. Call each conjunct a separate clause. (Conjunctions are "understood".)
     p ^ [q V r] ==>
     p
     q V r

  9. Standardize variables between separate clauses.
     f(x)
     g(y) V h(x, y)
          ==>
     f(_v1)
     g(_v2) V h(_v3, _v2)

• Resolution: A rule of inference which relates formulae in clausal form in a mechanical way to generate a new clause that is a consequence of the original set of support ("given" clauses).

  • Uses refutation by negation (proof by contradiction): To prove p -> q, assume p and assume the negation of q, then deduce any contradiction.

    E.g., PREMISES:

    ~(p ^ n)
    ~q -> n
         PROVE: p -> q

    1.	~p V ~n	Premise written as a clause.
    2.	q V n	Premise written as a clause.
    3.	p	Clauses obtained by negating the conclusion p -> q
    4.	~q
    5.	~p V q	Steps 1 and 2 and resolution.
    6.	q	Steps 3 and 5 and resolution.
    7.	Contradiction	Steps 4 and 6 and resolution.