proving properties of constraint logic programs by eliminating existential variables
Download
Skip this Video
Download Presentation
Proving Properties of Constraint Logic Programs by Eliminating Existential Variables

Loading in 2 Seconds...

play fullscreen
1 / 26

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


  • 136 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Proving Properties of Constraint Logic Programs by Eliminating Existential Variables' - jaeger


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

slide3
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) 

slide4
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)

slide5
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

slide6
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
slide7
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)

slide8
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)

slide9
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)

slide10
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)

slide11
7. The Unfold-Fold Strategy

A general Unfold/Fold strategy

Input: an lr-program P and a hierarchy 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 = 

slide12
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)

slide13
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
slide14
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

slide15
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

slide16
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

slide17
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)

slide18
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)
slide19
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

slide20
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

slide21
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

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

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

slide24
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
slide25
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
ad