1 / 26

Proving Properties of Constraint Logic Programs by Eliminating Existential Variables

Proving Properties of Constraint Logic Programs by Eliminating Existential Variables. Alberto Pettorossi (Università di Roma “Tor Vergata”), Maurizio Proietti (IASI-CNR, Roma), Valerio Senni (Università di Roma “Tor Vergata”). CILC2006 – DIB – Università di Bari. 26-27 June 2006.

jaeger
Télécharger la présentation

Proving Properties of Constraint Logic Programs by Eliminating Existential Variables

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Proving Propertiesof Constraint Logic Programsby Eliminating Existential Variables Alberto Pettorossi (Università di Roma “Tor Vergata”), Maurizio Proietti (IASI-CNR, Roma), Valerio Senni (Università di Roma “Tor Vergata”) CILC2006 – DIB – Università di Bari 26-27 June 2006

  2. 1. Outline of the work • Goal: proving first order properties of Costraint Logic Programs (CLPs) • Focus: CLPs on the domain of lists and real numbers • Technique: existential quantifiers elimination by means of program transformation

  3. 2. Programs on lists of reals • Polynomials p ::= a | X | p1 + p2 | a X where a  and X  Var • Constraints c ::= p1 = p2 | p1 < p2 | p1 ≤ p2 | c1 c2 • LR-programs head terms h ::= X | [ ] | [X|L] where X Var and L  VarL body terms b ::= p | L clauses cl ::= r1(h1,…,hn) c | r1 (h1,…,hn) c r2 (b1,…,bn) | r1 (h1,…,hn) c r2 (b1,…,bn) Goal: given a program P and a property , verify whether or not M(P) 

  4. 3. Proof by transformation • start from the pair < P, prop > • transform the statement prop into a (stratified, finite) set of definitions D1…Dn • add each of the D1…Dn to the inital program P obtaining at each step a new lr-program without existential variables • If the transformation process terminates, then the definition of prop is propositional (by definition of lr-programs)

  5. 4. An example • Initial program P member (X,[Y|L]) X=Y member (X,[Y|L]) member (X,L) • Property : L U X ( X  L  X ≤ U ) we want to show that any list of reals has an upper bound • Two steps : • First we transform the statement prop into a set of definitions D1…Dn • By applying the Unfold/Fold rules we transform D1…Dn P into a new program T such that the definition of prop ispropositional

  6. r q p 5. Clause-Form Transformation : L U X ( X  L  X ≤ U ) prop  L U X ( X  L  X > U ) D4: prop  p D3: p  list (L)  q (L) D2: q (L)  list (L)  r (L,U) D1: r (L,U) X > U  list(L) member (X,L) Step 1. • not lr-clauses • with existential • variables

  7. 6. Unfold-Fold Transformation Step 2. The unfold/fold transformation is aimed at transforming the clauses obtained after the Step 1 into lr-clauses. D4 : prop  p D3 : p  p1 p1 p1 D2 : q ([])  q ([X|T]) q1(X,T) q1 (X,[Y|T]) X > Y q1 (X , L) q1 (X,[Y|T]) X ≤ Y q1 (Y , L) D1 : r ([X|T],U) X > Ulist (L) r ([X|T],U) r (T,U) • by repeated applications of the • unfold, • fold and • constraint replacement rules • we obtain the final program T T For each initial predicate we have obtained a new definition, made of lr-clauses. Possibly with the use of some auxiliary predicate (p1, q1)

  8. 6. Unfold-Fold Transformation Step 2. The unfold/fold transformation is aimed at transforming the clauses obtained after the Step 1 into lr-clauses. D4 : prop  p D3 : p  p1 p1 p1 D2 : q ([])  q ([X|T]) q1(X,T) q1 (X,[Y|T]) X > Y q1 (X , L) q1 (X,[Y|T]) X ≤ Y q1 (Y , L) D1 : r ([X|T],U) X > Ulist (L) r ([X|T],U) r (T,U) • by repeated applications of the • unfold, • fold and • constraint replacement rules • we obtain the final program T T For each initial predicate we have obtained a new definition, made of lr-clauses. Possibly with the use of some auxiliary predicate (p1, q1)

  9. 6. Unfold-Fold Transformation Step 2. The unfold/fold transformation is aimed at transforming the clauses obtained after the Step 1 into lr-clauses. D4 : prop  p D3 : p  p1 p1 p1 D2 : q ([])  q ([X|T]) q1(X,T) q1 (X,[Y|T]) X > Y q1 (X , L) q1 (X,[Y|T]) X ≤ Y q1 (Y , L) D1 : r ([X|T],U) X > Ulist (L) r ([X|T],U) r (T,U) • by repeated applications of the • unfold, • fold and • constraint replacement rules • we obtain the final program T T For each initial predicate we have obtained a new definition, made of lr-clauses. Possibly with the use of some auxiliary predicate (p1, q1)

  10. 6. Unfold-Fold Transformation Step 2. The unfold/fold transformation is aimed at transforming the clauses obtained after the Step 1 into lr-clauses. D4 : prop  p D3 : p  p1 p1 p1 D2 : q ([])  q ([X|T]) q1(X,T) q1 (X,[Y|T]) X > Y q1 (X , L) q1 (X,[Y|T]) X ≤ Y q1 (Y , L) D1 : r ([X|T],U) X > Ulist (L) r ([X|T],U) r (T,U) prop  • by repeated applications of the • unfold, • fold and • constraint replacement rules • we obtain the final program T T For each initial predicate we have obtained a new definition, made of lr-clauses. Possibly with the use of some auxiliary predicate (p1, q1)

  11. 7. The Unfold-Fold Strategy A general Unfold/Fold strategy Input: an lr-program P and a hierarchy <D1,...,Dn> of clauses Output: an lr-program T for all D1,...,Dn : Di unfold+ replace-constraints* no yes i > n T define-fold* the final program yes no i := i + 1 NewDefs = 

  12. 8. The Unfold-Fold Strategy at work start from clause D1 : r (L,U) X > U  list(L) member (X,L) Unfold : r ([X|T],U)  X > U  list(T) r ([X|T],U) Y > U  list(T) member (Y,T) Fold : 1. r ([X|T],U) X > U list(T) 2. r ([X|T],U)  r (T,U)

  13. 8. The Unfold-Fold Strategy at work start from clause D1 : r (L,U) X > U  list(L) member (X,L) Unfold : r ([X|T],U)  X > U  list(T) r ([X|T],U) Y > U  list(T) member (Y,T) Fold : 1. r ([X|T],U) X > U list(T) 2. r ([X|T],U)  r (T,U) We go on with the following definitions D2, D3, and D4 • lr-clauses • without existential • variables

  14. 9. Introduction of new Definitions clause D2 : q (L)  list (L)  r (L,U) Unfold : q ([ ])  q ([X|T])  X ≤ U list (T)  r (T,U) we cannot fold

  15. 9. Introduction of new Definitions clause D2 : q (L)  list (L)  r (L,U) Unfold : q ([ ])  q ([X|T])  X ≤ U list (T)  r (T,U) Define : q1(X,T)  X ≤ U list (T)  r (T,U) Fold : 3. q ([ ])  4. q ([X|T])  q1(X,T) Continue to apply the transformation rules to the new definition Unfold : q1(X,[ ])  q1(X,[Y|T])  X ≤ U Y ≤ U list (T)  r (T,U) we cannot fold

  16. need for new definitions 9. Introduction of new Definitions clause D2 : q (L)  list (L)  r (L,U) Unfold : q ([ ])  q ([X|T])  X ≤ U list (T)  r (T,U) Define : q1(X,T)  X ≤ U list (T)  r (T,U) Fold : 3. q ([ ])  4. q ([X|T])  q1(X,T) Continue to apply the transformation rules to the new definition Unfold : q1(X,[ ])  q1(X,[Y|T])  X ≤ U Y ≤ U list (T)  r (T,U) we cannot fold reduce the occurrences of existential variables

  17. U  U U  X Y X > Y  X ≤ U X ≤ Y  Y ≤ U X Y X ≤ U Y ≤ U X Y 10. Constraint Replacement  : q1 (X,[Y|T])  X ≤ U Y ≤ U list (T)  r (T,U)

  18. U  U U  X Y X > Y  X ≤ U X ≤ Y  Y ≤ U X Y X ≤ U Y ≤ U X Y 10. Constraint Replacement •  : q1 (X,[Y|T])  X ≤ U Y ≤ U list (T)  r (T,U) • We substitute the clause  for   and   • : q1 (X,[Y|T])  X > Y  X ≤ U list (T)  r (T,U) •  : q1 (X,[Y|T])  X ≤ Y  Y ≤ U list (T)  r (T,U)

  19. U  U U  X Y X > Y  X ≤ U X ≤ Y  Y ≤ U X Y X ≤ U Y ≤ U X Y 10. Constraint Replacement •  : q1 (X,[Y|T])  X ≤ U Y ≤ U list (T)  r (T,U) • We substitute the clause  for   and   • : q1 (X,[Y|T])  X > Y  X ≤ U list (T)  r (T,U) •  : q1 (X,[Y|T])  X ≤ Y  Y ≤ U list (T)  r (T,U) • after folding we obtain : • 5. q1 (X,[Y|T]) X > Y  q1 (X,T) • 6. q1 (X,[Y|T]) X ≤ Y  q1 (Y,T) which allow for folding

  20. 11. Last part of the Trasformation clause D3 : p  list (L)  q (L) Unfold : p  list(T) q1 (X,T) Define : p1list(T) q1 (X,T) Fold : 7. p  p1 Unfold : p1 X > Y list(T) q1 (X,T) p1X ≤ Y list(T) q1 (Y,T) Constraint Replace : p1 list(T) q1 (Y,T) Fold : 8. p1 p1 project these constraints out

  21. 12. Final Program At the end of the transformation we obtain the following program: 1. r ([X|T],U) X > U list(T) 2. r ([X|T],U)  r (T,U) 3. q ([ ])  4. q ([X|T])  newp1(X,T) 5. q1 (X,[Y|T]) X > Y  q1 (X,T) 6. q1 (X,[Y|T]) X ≤ Y  q1 (Y,T) 7. p  p1 8. p1 p1 9. prop p T : By simple inspection of the program T we can decide that the property prop is true

  22. 13. Termination A brief note on termination: for all D1,...,Dn : Di unfold+ replace-constraints* no yes i > n T define-fold* the final program yes no i := i + 1 NewDefs = 

  23. 13. Termination A brief note on termination: The only source for nontermination is the possible introduction of infinitely many new definitions for all D1,...,Dn : Di unfold+ replace-constraints* no yes i > n T define-fold* the final program yes no i := i + 1 NewDefs = 

  24. 14. Experimental results We have run some experiments on the MAP system that implements the Unfold/Fold transformation strategy. • constraints handling: clp(r) module of SICStus prolog (implementing a variant of the Fourier-Motzkin algorithm for existential variables elimination) • theorems in the theory of linear orders, lists, and sum

  25. 15. Future work • identify some theories of interest for which this strategy succeeds • experiment on different data structures (e.g. trees) and domains with a linear order and closed under projection • investigate phenomena that lead to nontermination • generalization techniques that allow for folding

More Related