Outline

• Dynamic Memory Management
• Quiz
• Logic and Logic Programs
• Horn Clauses
• Resolution, Unification, and Backtracking
• Prolog

Dynamic Memory Management

• Recall last Wednesday, we said Scheme uses the heap to store activation records.
• So what methods can we use to determine when an activation is no longer needed in a language like Scheme?
• We assume we are allocating on a heap, we keep a free space list, we coalesce contiguous free blocks, and we might compact the heap occasionally.
• One way to keep track of who is referencing an activation is to use a reference count. One problem with this is circular references.
• Another technique is to use a mark and sweep approach. First mark each record reachable from the global environment. Then iterate and mark each record reachable from those. Do until no change. Anything not referenced at end can be garbage collected.

More Garbage Collection

• One improvement to this is called stop and copy:
  • Split heap memory into two halves; only use one halve at a time.
  • To garbage collect have a mark phase as in mark and sweep, but copy marked items to unused half.
  • Then make that half active and garbage collect the whole previously used half.
• Another is called generational garbage collection:
  • Have several heaps which are garbage collected with different frequencies.
  • If an item is not garbage collected in a high frequency collected heap a couple times, it is moved to a more slowly garbage collected heap.

Quiz

Access chaining is used in activation records for which of the following?

1. To allow nested functions whose lifetime ends with that of the parent function.
2. To allow recursive function definitions.
3. To allow nested functions to persists even after the parent function has completed.

One Last Language Paradigm...

• So far this semester we have considered three language paradigms: procedural languages, object-oriented languages, and functional programming languages.
• We are now going to look at one more language paradigm: logic programming.
• Logic is tightly related to computer programs. For instance, AND, OR, NOT logic gates can be used to build up computer circuits. We have also briefly mentioned the formula-as-types interpretation. Finally, we have talked about how ML served as the base language for several automated theorem provers.
• We haven't really said what logic was though...
• So we will talk a little bit about this before we talk about logic programming and then Prolog.

Logic and Logic Programs

• The kind of logic used in logic programming is the first-order predicate calculus.
• When we work in first-order logic, we usual work in a particular language.
• Languages are assumed to come equipped with variables and for our purposes we will write these as: x,y,z,... or x₁, x₂,...
• A language is specified by specifying its:
  • Constants -- things like 0 or 1
  • Functions -- these may be of different arity: S(x) := x+1, Plus(x,y), Times(x,y), ...
  • Predicates -- P(x), Q(x,y), ... We imagine that predicates take inputs from some domain and return a true or false answer. For example equals(x,y) might take inputs which are natural numbers and returns true or false depending on whether x and y are equal.
• A term in the language is either a constant, a variable, or built from other terms using functions of the language.
• An atomic formula in the language is a predicate whose parameters have been filled in with terms.

More First-Order Logic

• A first-order formula is either an atomic formula or built out of first-order formulas using AND(∧), OR (∨), NOT (¬), IMPLIES (→), EXISTS (∃x), FORALL (∀x).
• For example, Even(x) := (∃y)( x = 2*y) is a first-order formula expressing x is an even number. Notice 2*y and x are terms, so x = 2*y is an atomic formula, so (∃y)( x = 2*y) is a formula.
• In the above, the variable x would be called a free variable and the variable y is called bound.
• Notice depending on the value of x, Even(x) may be either true or false.
• Typically in mathematics, we start with a set of formulas (axioms) which we think are always true and we see what others facts we are able to derive from these formulas.
• A formula derivable from our axioms is called a theorem.

Rules of Inference

• So given a set of true formulas, what are the legal inferences we can make?
• For example, if I know A is true, I can infer A ∨ B is true. Similarly, if I know A(t) holds, I can infer (∃y)A(y). Given A→B and B→ C, I can infer A→C.
• These are examples of valid rules of inference. There is a finite list of inferences I (all of which are also valid), such that given a list of axioms A, and any statement T that follows from A, we can start from formulas in A and only apply inferences in I to get new formulas, and eventually reach the formula T.
• A derivation of T from A using I would be called a proof.
• A logic programming language is a notational system for writing logic statements together with specified algorithms for implementing inference rules.

Horn Clauses

• A Horn clause is a statement of the form:
  a1 ∧ a2 ∧ ... an → b
b is called the head of the clause, and the rest of the clause is called the body. Each a_i in the body is called a premiss.
• Horn clauses are particularly simple formulas which are using for creating a computer language.
• A clause of the form →b is called a fact, and might just be written as b.
• As an example of how Horn clauses might be useful in terms of expressiveness, consider the following axioms for the natural numbers:
  1. natural(0).
  2. natural(x) → natural(successor(x)).
• To prove natural(successor(successor(0))), which in English we might view as saying "two is a natural number", we can use axiom (1) together with axiom (2) twice and modus ponens.

Prolog

• We would like to use Horn clauses as a basis of a programming language.
• Prolog, created by Alain Colmerauer and Phillipe Roussel in 1972, in fact does this.
• The motivating idea behind Prolog is that to write program we should make logical statements declaring what we know to be true about a problem, then we ask questions of our statements, and use theorem proving to answer these questions.
• In Prolog we write our Horn Clauses backwards, and rather than use ← we use :- instead. For example:

  loves(jane,X) :- flies(X).
  loves(X,bob) :- movieStarring(bob).
  

• Horn Clauses which have no premises are called facts and are written as predicates followed by a period. For example:

  sky(blue).
  chase(dogs, cats).
  

Resolution, and Unification

• There are two aspects to derivations involving Horn clauses that provide the basic algorithmic component of Prolog: resolution and unification.
• Given two Horn clauses:
  A :- A1, ..., An
B :- B1, ..., Bn
where B_i = A, a resolution inference on these two clauses yields:
  B :- B1, ... Bi-1, A1, ..., An, Bi+1, ... Bn.
• Unification was the process of pattern matching we used a couple slides back (and also did on the homework) to match natural(successor(x)) and natural(successor(successor(0))) by setting x =successor(0).
• Prolog tries to determine if something is true by scanning from the top down in the rules of a given Prolog program. If it finds the questions unifies with a fact, then it says its true. If it finds a rule that unifies with the question, then it tries to derive all of the premises of the rule. This is done by either checking if each premise unifies with a fact, or if a premise unifies with a rule -- in the latter case, it then uses resolution again. This process continues until all the premises are derived or no further derivation is possible. In the first case, the output is yes. In the second case, the output is no.
• It might be the case that more than one rule could be used in a resolution step. Prolog then tries resolving each rule in turn. If it succeeds with one then it stops; otherwise, it pretends not to have used that rule and tries the next. This process is called backtracking.

Prolog

• We started going over my Prolog tutorial:
  http://www.cs.sjsu.edu/faculty/pollett/15.1.99f/prolog.html.