Computational Logic

CLP Semantics and Fundamental Results

Constraint Domains

• Semantics parameterized by the constraint domain:
  CLP(${\cal X}$), where ${\cal X} \equiv (\Sigma, {\cal D}, {\cal L}, {\cal T})$
• Signature $\Sigma$: set of predicate and function symbols, together with their arity
• ${\cal L} \subseteq \Sigma$-formulae: constraints
• D is the set of actual elements in the domain

• $\Sigma$-structure ${\cal D}$: gives the meaning of predicate and function symbols (and hence, constraints).

• ${\cal T}$ a first-order theory (axiomatizes some properties of ${\cal D}$)
• $({\cal D, L}$) is a constraint domain
• Assumptions:
  • ${\cal L}$ built upon a first-order language
  • $= \in \Sigma$ is identity in ${\cal D}$
  • There are identically false and identically true constraints in ${\cal L}$
  • ${\cal L}$ is closed w.r.t. renaming, conjunction and existential quantification

Domains (I)

• $\Sigma = \{0, 1, +, *, =, <, \leq \}$, D = R, ${\cal D}$ interprets $\Sigma$ as usual, $\Re = ({\cal D, L})$
  • Arithmetic over the reals
  • Eg.: $x^2 + 2xy < \frac{y}{x} \wedge x > 0\; \; (\equiv xxx + xxy + xxy < y \wedge 0 < x)$
• Question: is $0$ needed? How can it be represented?

• Let us assume $\Sigma' = \{0, 1, +, =, <, \leq \}$, $\Re_{Lin} = ({\cal D}', {\cal L}')$
  • Linear arithmetic
  • Eg.: $3x - y < 3 \; \; (\equiv x + x + x < 1 + 1 + 1 + y)$

• Let us assume $\Sigma'' = \{0, 1, +, = \}$, $\Re_{LinEq} = ({\cal D}'', {\cal L}'')$
  • Linear equations
  • Eg.: $3x + y = 5 \wedge y = 2x$

Domains (II)

• $\Sigma = \{<$constant and function symbols$>, =\}$
• D = { finite trees }
• ${\cal D}$ interprets $\Sigma$ as tree constructors
• Each $f \in \Sigma$ with arity $n$ maps $n$ trees to a tree with root labeled $f$ and whose subtrees are the arguments of the mapping
• Constraints: syntactic tree equality
• ${\cal FT} = ({\cal D, L})$
  • Constraints over the Herbrand domain
  • Eg.: $g(h(Z), Y) = g(Y, h(a))$
• LP $\equiv$ CLP(${\cal FT}$)

Domains (III)

• $\Sigma = \{<$constants $>, \lambda, ., ::, = \}$
• D = { finite strings of constants }
• ${\cal D}$ interprets . as string concatenation, :: as string length
  • Equations over strings of constants
  • Eg.: $X.A.X = X.A$

  
  

  

  
  

• $\Sigma = \{0, 1, \neg, \wedge, = \}$
• D = $\{ true, false \}$
• ${\cal D}$ interprets symbols in $\Sigma$ as boolean functions
• ${\cal BOOL} = ({\cal D, L})$
  • Boolean constraints
  • Eg.: $\neg (x \wedge y) = 1$

CLP(${\cal X}$) Programs

• Recall that:
  • $\Sigma$ is a set of predicate and function symbols
  • ${\cal L} \subseteq \Sigma$-formulae are the constraints
• $\Pi$: set of predicate symbols definable by a program
• Atom: $p(t_1, t_2, \ldots, t_n)$, where $t_1, t_2, \ldots, t_n$ are terms and $p \in \Pi$
• Primitive constraint: $p(t_1, t_2, \ldots, t_n)$, where
  $t_1, t_2, \ldots, t_n$ are terms and $p \in \Sigma$ is a predicate symbol
• Every constraint is a (first-order) formula built from primitive constraints
• The class of constraints will vary (generally only a subset of formulas are considered constraints)
• A CLP program is a collection of rules of the form $a \leftarrow b_1, \ldots, b_n$ where $a$ is an atom and the $b_i$'s are atoms or constraints
• A fact is a rule $a \leftarrow c$ where $c$ is a constraint
• A goal (or query) $G$ is a conjunction of constraints and atoms

Basic Operations on Constraints

• Constraint domains are expected to support some basic operations on constraints
  1. Consistency (or satisfiability) test: ${\cal D} \models \tilde{\exists}c$,
  2. Implication or entailment: ${\cal D} \models c_0 \rightarrow c_1$,
  3. Projection of a constraint $c_0$ onto variables $\tilde{x}$ to obtain a constraint $c_1$ such that ${\cal D} \models c_1 \leftrightarrow \exists_{-\tilde{x}} c_0$,
  4. Detection of uniqueness of variable value: ${\cal D} \models c(x, \tilde{z}) \wedge c(y, \tilde{w}) \rightarrow x = y$
• Actually, only the first one is really required
• In actual implementations, some of these operations--in particular the test of consistency--may be incomplete

• Examples:
  
  • $x*x < 0$ is inconsistent in $\Re$ (because $\neg\exists x \in \Re : x*x < 0$)
  • ${\cal D} \models (x \wedge y = 1) \rightarrow (x \vee y = 1)$ in ${\cal BOOL}$
  • In ${\cal FT}$, the projection of $x = f(y) \wedge y = f(z)$ on $\{x, z\}$ is $x = f(f(z))$
  • In ${\cal WE}$, ${\cal D} \models x.a.x = x.a \wedge y.b.y = y.b \rightarrow x = y$

• Prove the last assertion!

Properties of CLP Languages

• ${\cal T}$ axiomatizes some of the properties of ${\cal D}$
• For a given $\Sigma$, let $({\cal D}, {\cal L})$ be a constraint domain with signature $\Sigma$, and ${\cal T}$ a $\Sigma$-theory.
• ${\cal D}$ and ${\cal T}$ correspond on ${\cal L}$ if:
  • ${\cal D}$ is a model of ${\cal T}$, and
  • for every constraint $c \in {\cal L}$, ${\cal D} \models \tilde{\exists}c$ iff ${\cal T} \models \tilde{\exists}c$.
• ${\cal T}$ is satisfaction complete with respect to ${\cal L}$ if for every constraint $c \in {\cal L}$, either ${\cal T} \models \tilde{\exists}c$ or ${\cal T} \models \neg \tilde{\exists}c$.
• $({\cal D, L})$ is solution compact if

  
  

  $$\forall c \exists \{c_i\}_{i \in I} : {\cal D} \models \foral... ...\tilde{x}) \longleftrightarrow \bigvee_{i \in I} c_i(\tilde{x})$$
  
  

  i.e., any negated constraint in ${\cal L}$ can be expressed as a (in)finite disjunction of constraints

Solution Compactness

• Important to lift SLDNF results to CLP(${\cal X}$)
• We have to deal only with user predicates

• E.g.
  • $x \not\geq y$ in CLP($\Re$) is $x < y$
  • $x \not = y$ in CLP($\Re$) is $x < y \vee y < x$
  • $\Re_{Lin}$ with constraint $x \not = \pi$ is not s.c.

• How can we express $x \not = y$ in CLP(${\cal FT}$)?

Logical Semantics (I)

• Two common logical semantics exist.
• The first one interprets a rule
  
  $$p(\tilde{x}) \leftarrow b_1,\ldots,b_n$$
  
  
  as the logic formula
  
  $$\forall\tilde{x},\tilde{y} \; p(\tilde{x}) \vee \neg b_1 \vee \ldots \vee \neg b_n$$
  
  

Logical Semantics (II)

• The second one associates a logic formula to each predicate in $\Pi$
  
  • If the set of rules of $P$ with $p$ in the head is:
    $$\begin{eqnarray*} p(\tilde{x}) & \leftarrow & B_1 \\ p(\tilde{x}) & \leftarrow & B_2 \\ & \vdots & \\ p(\tilde{x}) & \leftarrow & B_n \end{eqnarray*}$$
    
    
    then the formula associated with $p$ is:
    $$\begin{eqnarray*} \forall \tilde{x}\; p(\tilde{x}) \; \leftrightarrow & & \ex... ...e{y}_2 B_2 \\ & \vdots & \\ & \vee & \exists\tilde{y}_n B_n \end{eqnarray*}$$
    
    

  • If $p$ does not occur in the head of a rule of $P$, the formula is: $\forall\tilde{x} \neg p(\tilde{x})$

  • The collection of all such formulas is the Clark completion of $P$ (denoted by $P^*$)

• These two semantics differ on the treatment of the negation

Logical Semantics (III)

• A valuation is a mapping from variables to $D$, and the natural extension which maps terms to $D$ and formulas to closed ${\cal L}^*$-formulas.
• A ${\cal D}$-interpretation of a formula is an interpretation of the formula with the same domain as ${\cal D}$ and the same interpretation for the symbols in $\Sigma$ as ${\cal D}$.
• It can be represented as a subset of $B_{{\cal D}}$ where
  
  $$B_{{\cal D}} =\{p(\tilde{d}) \mid p \in \Pi, \tilde{d} \in D^k\}$$
  
  

• A ${\cal D}$-model of a closed formula is a ${\cal D}$-interpretation which is a model of the formula.
• The usual logical semantics is based on the ${\cal D}$-models of $P$ and the models of $P^*$, ${\cal T}$.
• The least ${\cal D}$-model of a formula $Q$ is denoted by $lm(Q, {\cal D})$.
• A solution to a query $G$ is a valuation $v$ such that $v(G) \subseteq lm(P, {\cal D})$.

Fixpoint Semantics

• Based on one-step consequence operator $T^{\cal D}_P$ (also called ``immediate consequence operator'').

• Take as semantics $lfp(T^{\cal D}_P)$, where:
  $$\begin{eqnarray*} T^{\cal D}_{P}(I) = \{ p(\tilde{d}) & \vert & p(\tilde{x}) ... ...\cal D} \models v(c), v(\tilde{x}) = \tilde{d}, v(b_i) = a_i \} \end{eqnarray*}$$
  
  

• Theorems:
  1. $T^{\cal D}_P \uparrow \omega = lfp(T^{\cal D}_P)$
  2. $lm(P, {\cal D}) = lfp(T^{\cal D}_P)$

Top-Down Operational Semantics (I)

• General framework for operational semantics
• Formalized as a transition system on states
• State: a 3-tuple $\langle A, C, S \rangle$, or $fail$, where
  
  • $A$ is a multiset of atoms and constraints,
  • $C \bigcup S$ multiset of constraints,
  • $C$, active constraints (awake)
  • $S$, passive constraints (asleep)
• Computation and Selection rules depend on A
• Transition system: parameterized by a predicate $consistent$ and a function $infer$:
  
  • $consistent(C)$ checks the consistency of a constraint store
  • Usually ``$consistent(C)$ iff ${\cal D} \models \tilde{\exists}c$'', but sometimes ``if ${\cal D} \models \tilde{\exists}c$ then $consistent(C)$''
  • $infer(C, S)$ computes a new set of active and passive constraints

Top-Down Operational Semantics (II)

• Transition $r$: computation step; rewriting using user predicates
  $\langle A \bigcup a, C, S \rangle \rightarrow_r \langle A \bigcup B, C, S\bigcup (a = h) \rangle$
  if $h \leftarrow B \in P$, and $a$ and $h$ have the same predicate symbol, or
  $\langle A \bigcup a, C, S \rangle \rightarrow_r fail$
  if there is no rule $h \leftarrow B$ of $P$ such that $a$ and $h$ have the same predicate symbol ($a = h$ is a set of argument-wise equations) if $a$ is a predicate symbol selected by the computation rule

• Transition $c$: selects constraints
  $\langle A \bigcup c, C, S \rangle \rightarrow_c \langle A, C, S \bigcup c \rangle$
  if $c$ is a constraint selected by the computation rule
• Transition $i$: infers new constraints
  $\langle A, C, S \rangle \rightarrow_i \langle A, C', S' \rangle \mbox{ if } (C', S') = infer(C, S)$
  
  • In particular, may turn passive constraints into active ones
• Transition $s$: checks satisfiability
  
  
  $$\langle A, C, S \rangle \rightarrow_s \left\{ \begin{array}{... ...\ fail & {\rm if} \; \neg consistent(C) \end{array} \right.$$
  
  

Top-Down Operational Semantics (III)

• Initial state: $\langle G, \emptyset, \emptyset \rangle$
• Derivation: $\langle A_1, C_1, S_1 \rangle \rightarrow \ldots \rightarrow \langle A_i, C_i, S_i \rangle \rightarrow \ldots$
• Final state: $E \rightarrow E$
• Successful derivation: final state $\langle \emptyset, C, S \rangle$
• A derivation flounders if finite and the final state is $\langle A, C, S \rangle$ with $A \neq \emptyset$
• A derivation is failed if it is finite and the final state is fail

• Answer: $\exists_{-\tilde{x}} C \wedge S$, where $\tilde{x}$ are the variables in the initial goal
• A derivation is fair if it is failed or, for every $i$ and every $a \in A_i$, $a$ is rewritten in a later transition
• A computation rule is fair if it gives rise only to fair derivations

Top-Down Operational Semantics (IV)

• Computation tree for goal $G$ and program $P$:
  • Nodes labeled with states
  • Edges labeled with $\rightarrow_r$, $\rightarrow_c$, $\rightarrow_i$ or $\rightarrow_s$
  • Root labeled by $\langle G, \emptyset, \emptyset \rangle$
  • All sons of a given node have the same label
  • Only one son with transitions $\rightarrow_c$, $\rightarrow_i$ or $\rightarrow_s$
  • A son per program clause with transition $\rightarrow_r$

Computation Tree: Example

• Consider the program
  $p(X+3, X) \leftarrow X < 3. \\ p(X+3, X) \leftarrow X > 3, p(X, Y).$
  and the goal $\leftarrow p(5, X)$
• A possible computation tree is:
  
  
  

• Dotted rectangle: previous state was final as well

Types of CLP(${\cal X}$) Systems

• Quick-checking CLP(${\cal X}$) system: its operational semantics can be described by $\rightarrow_{ris} \equiv \rightarrow_r \rightarrow_i \rightarrow_s$ and $\rightarrow_{cis} \equiv \rightarrow_c \rightarrow_i \rightarrow_s$
• I.e., always selects either an atom or a constraint, infers and checks consistency
• Progressive CLP system: for all $\langle A, C, S \rangle$ with $A \neq \emptyset$, every derivation from that state either fails or contains a $\rightarrow_r$ or $\rightarrow_c$ transition
• Ideal CLP system:
  • Quick-checking
  • Progressive
  • $infer(C, S)=(C \cup S, \emptyset)$
  • $consistent(C)$ holds iff ${\cal D} \models \tilde{\exists}c$

Soundness and Completeness Results

• Success set: the set of queries plus constraints which have a successful derivation in the program:
  $SS(P)=\{p(\tilde{x}) \leftarrow c \mid \langle p(\tilde{x}), \emptyset, \empty... ...rangle, {\cal D} \models c \leftrightarrow \exists_{-\tilde{x}} c' \wedge c''\}$

• Consider a program $P$ in the CLP language determined by a 4-tuple $(\Sigma, {\cal D}, {\cal L}, {\cal T})$ and executing on an ideal CLP system. Then:
  1. $[SS(P)]_{{\cal D}} = lm(P, D)$, where
     
     $$[SS(P)]_{{\cal D}} = \{ v(a) \mid (a \leftarrow c) \in SS(P), {\cal D} \models v(c) \}$$
     
     

  2. $SS(P) = lfp(S^{\cal D}_P)$
  3. (Soundness) if the goal $G$ has a successful derivation with answer constraint $c$, then $P, {\cal T} \models c \rightarrow G$
  4. (Completeness) if $P, {\cal T} \models c \rightarrow G$ then there are derivations for the goal $G$ with answer constraints $c_1, \ldots, c_n$ such that ${\cal T} \models c \rightarrow \bigvee_{i=1}^{n} c_i$
  5. Assume ${\cal T}$ is satisfaction complete w.r.t. ${\cal L}$. Then the goal $G$ is finitely failed for $P$ iff $P^*, {\cal T}\models \neg G$.

Negation in CLP(${\cal X}$)

• Most LP results can be lifted to CLP(${\cal X}$)
• In particular, negation as failure (à la SLDNF) is still valid using:
  • Satisfiability instead of unification
  • Variable elimination instead of groundness
• Added bonus: if the system is solution compact, then negated constraints can be expressed in terms of primitive constraints
• Less chances of a floundered / incorrect computation