Proving properties of constraint logic programs by eliminating existential variables
This presentation is the property of its rightful owner.
Sponsored Links
1 / 26

Proving Properties of Constraint Logic Programs by Eliminating Existential Variables PowerPoint PPT Presentation


  • 90 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Proving properties of constraint logic programs by eliminating existential variables

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


1 outline of the work

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


Proving properties of constraint logic programs by eliminating existential variables

2. Programs on lists of reals

  • Polynomialsp ::= a | X | p1 + p2 | a X where a  and X  Var

  • Constraintsc ::= p1 = p2 | p1 < p2 | p1 ≤ p2 | c1 c2

  • LR-programs

    head termsh ::= X | [ ] | [X|L] where X Var and L  VarL

    body termsb ::= p | L

    clausescl ::= 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) 


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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 = 


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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)


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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 = 


Proving properties of constraint logic programs by eliminating existential variables

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 = 


Proving properties of constraint logic programs by eliminating existential variables

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


Proving properties of constraint logic programs by eliminating existential variables

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


  • Login