Overlapping Rules and Logic Variables in Functional Logic Programs - - PowerPoint PPT Presentation

▶
overlapping rules and logic variables in functional logic
SMART_READER_LITE
LIVE PREVIEW

Overlapping Rules and Logic Variables in Functional Logic Programs - - PowerPoint PPT Presentation

Oct 26, 2022 257 likes •686 views

ICLP 2006 Overlapping Rules and Logic Variables in Functional Logic Programs Michael Hanus Christian-Albrechts-Universit at Kiel (joint work with Sergio Antoy, Portland State University) F UNCTIONAL L OGIC L ANGUAGES Approach to amalgamate

slide-1
SLIDE 1

ICLP 2006

Overlapping Rules and Logic Variables in Functional Logic Programs

Michael Hanus

Christian-Albrechts-Universit¨ at Kiel (joint work with Sergio Antoy, Portland State University)

slide-2
SLIDE 2

FUNCTIONAL LOGIC LANGUAGES

Approach to amalgamate ideas of declarative programming

  • efficient execution principles of functional languages

(determinism, laziness)

  • flexibility of logic languages (constraints, built-in search)
  • avoid non-declarative features of Prolog (arithmetic, I/O, cut)
  • combine best of both worlds in a single model

(higher-order functions, declarative I/O, concurrent constraints)

  • Advantages:

➜ optimal evaluation strategies [JACM’00,ALP’97] ➜ new design patterns [FLOPS’02] ➜ better abstractions for application programming (GUI programming [PADL ’00], web programming [PADL ’01, PPDP’06]) CAU Kiel Michael Hanus

2

slide-3
SLIDE 3

FUNCTIONAL LOGIC LANGUAGES

Approach to amalgamate ideas of declarative programming

  • efficient execution principles of functional languages

(determinism, laziness)

  • flexibility of logic languages (constraints, built-in search)
  • avoid non-declarative features of Prolog (arithmetic, I/O, cut)
  • combine best of both worlds in a single model

(higher-order functions, declarative I/O, concurrent constraints)

  • Advantages:

➜ optimal evaluation strategies [JACM’00,ALP’97] ➜ new design patterns [FLOPS’02] ➜ better abstractions for application programming (GUI programming [PADL ’00], web programming [PADL ’01, PPDP’06])

Minimal kernel language for FLP?

CAU Kiel Michael Hanus

2

slide-4
SLIDE 4

FUNCTIONAL LANGUAGES (E.G., HASKELL)

CAU Kiel Michael Hanus

3

slide-5
SLIDE 5

FUNCTIONAL LANGUAGES (E.G., HASKELL)

✓ ✒ ✏ ✑ [] ++ ys = ys (x:xs) ++ ys = x : xs ++ ys

CAU Kiel Michael Hanus

3

slide-6
SLIDE 6

FUNCTIONAL LANGUAGES (E.G., HASKELL)

+ logic variables (expressive power) ✓ ✒ ✏ ✑ [] ++ ys = ys (x:xs) ++ ys = x : xs ++ ys last xs | ys ++ [x] =:= xs = x where x,ys free

CAU Kiel Michael Hanus

3

slide-7
SLIDE 7

FUNCTIONAL LANGUAGES (E.G., HASKELL)

+ logic variables (expressive power) ✓ ✒ ✏ ✑ [] ++ ys = ys (x:xs) ++ ys = x : xs ++ ys last xs | ys ++ [x] =:= xs = x where x,ys free + overlapping rules (demand-driven search) ★ ✧ ✥ ✦ insert e [] = [e] insert e (x:xs) = e : x : xs

  • - overlapping

insert e (x:xs) = x : insert e xs

  • - rules

CAU Kiel Michael Hanus

3

slide-8
SLIDE 8

FUNCTIONAL LANGUAGES (E.G., HASKELL)

+ logic variables (expressive power) ✓ ✒ ✏ ✑ [] ++ ys = ys (x:xs) ++ ys = x : xs ++ ys last xs | ys ++ [x] =:= xs = x where x,ys free + overlapping rules (demand-driven search) ★ ✧ ✥ ✦ insert e [] = [e] insert e (x:xs) = e : x : xs

  • - overlapping

insert e (x:xs) = x : insert e xs

  • - rules

perm [] = [] perm (x:xs) = insert x (perm xs) perm [1,2,3] ❀ [1,2,3] | [1,3,2] | [2,1,3] | ... = functional logic languages Main result of this paper: only one of these extensions is sufficient!

CAU Kiel Michael Hanus

3

slide-9
SLIDE 9

TERM REWRITING SYSTEMS (TRS)

Formal model for functional logic languages:

CAU Kiel Michael Hanus

4

slide-10
SLIDE 10

TERM REWRITING SYSTEMS (TRS)

Formal model for functional logic languages: Datatypes (≈ admissible values): enumerate all data constructors ✓ ✒ ✏ ✑ data Bool = True | False data Nat = O | S Nat data List = [] | Nat : List

CAU Kiel Michael Hanus

4

slide-11
SLIDE 11

TERM REWRITING SYSTEMS (TRS)

Formal model for functional logic languages: Datatypes (≈ admissible values): enumerate all data constructors ✓ ✒ ✏ ✑ data Bool = True | False data Nat = O | S Nat data List = [] | Nat : List Rewrite rules: define operations on values f(t1, . . . , tn) → r defined

  • peration

patterns (linear data terms) expression ☛ ✡ ✟ ✠ add(O,y) → y positive(O) → False add(S(x),y) → S(add(x,y)) positive(S(x)) → True Extra variable: rule variable not occurring in left-hand side

CAU Kiel Michael Hanus

4

slide-12
SLIDE 12

CLASSES OF TERM REWRITING SYSTEMS

CAU Kiel Michael Hanus

5

slide-13
SLIDE 13

CLASSES OF TERM REWRITING SYSTEMS

Inductively sequential term rewriting systems:

➜ no overlapping left-hand sides in rules ➜ operations inductively defi ned on datatypes

✓ ✒ ✏ ✑ leq(O,x) → True cond(True,x) → x leq(S(x),O) → False leq(S(x),S(y)) → leq(x,y) seven → S(S(S(S(S(S(S(O)))))))

CAU Kiel Michael Hanus

5

slide-14
SLIDE 14

CLASSES OF TERM REWRITING SYSTEMS

Inductively sequential term rewriting systems:

➜ no overlapping left-hand sides in rules ➜ operations inductively defi ned on datatypes

✓ ✒ ✏ ✑ leq(O,x) → True cond(True,x) → x leq(S(x),O) → False leq(S(x),S(y)) → leq(x,y) seven → S(S(S(S(S(S(S(O))))))) ISX: inductively sequential TRS with extra variables ✞ ✝ ☎ ✆ smallnum → cond(leq(x,seven),x)

CAU Kiel Michael Hanus

5

slide-15
SLIDE 15

CLASSES OF TERM REWRITING SYSTEMS

Inductively sequential term rewriting systems:

➜ no overlapping left-hand sides in rules ➜ operations inductively defi ned on datatypes

✓ ✒ ✏ ✑ leq(O,x) → True cond(True,x) → x leq(S(x),O) → False leq(S(x),S(y)) → leq(x,y) seven → S(S(S(S(S(S(S(O))))))) ISX: inductively sequential TRS with extra variables ✞ ✝ ☎ ✆ smallnum → cond(leq(x,seven),x) OIS: overlapping inductively sequential TRS: allow rules with multiple right-hand sides: l → r1 ? · · · ? rk ✞ ✝ ☎ ✆ parent(x) → mother(x) ? father(x)

CAU Kiel Michael Hanus

5

slide-16
SLIDE 16

CLASSES OF TERM REWRITING SYSTEMS

Inductively sequential term rewriting systems:

➜ no overlapping left-hand sides in rules ➜ operations inductively defi ned on datatypes

✓ ✒ ✏ ✑ leq(O,x) → True cond(True,x) → x leq(S(x),O) → False leq(S(x),S(y)) → leq(x,y) seven → S(S(S(S(S(S(S(O))))))) ISX: inductively sequential TRS with extra variables ✞ ✝ ☎ ✆ smallnum → cond(leq(x,seven),x) OIS: overlapping inductively sequential TRS: allow rules with multiple right-hand sides: l → r1 ? · · · ? rk ✞ ✝ ☎ ✆ parent(x) → mother(x) ? father(x) Main result: OIS with rewriting ⇐ ⇒ ISX with narrowing

CAU Kiel Michael Hanus

5

slide-17
SLIDE 17

EVALUATION: REWRITING VS. NARROWING

Functional evaluation: (lazy) rewriting add(S(O),S(O)) → S(add(O,S(O))) → S(S(O))

CAU Kiel Michael Hanus

6

slide-18
SLIDE 18

EVALUATION: REWRITING VS. NARROWING

Functional evaluation: (lazy) rewriting add(S(O),S(O)) → S(add(O,S(O))) → S(S(O)) Functional logic evaluation: narrowing: guess values + rewriting add(x,S(O)) =:= S(S(S(O))) ❀ {x → S(S(O))}

CAU Kiel Michael Hanus

6

slide-19
SLIDE 19

EVALUATION: REWRITING VS. NARROWING

Functional evaluation: (lazy) rewriting add(S(O),S(O)) → S(add(O,S(O))) → S(S(O)) Functional logic evaluation: narrowing: guess values + rewriting add(x,S(O)) =:= S(S(S(O))) ❀ {x → S(S(O))} Needed narrowing: demand-driven variable instantiation and rewriting leq(x,add(O,S(O))) ❀{x→O} True Sound, complete, optimal evaluation strategy [JACM’00]

CAU Kiel Michael Hanus

6

slide-20
SLIDE 20

ELIMINATING OVERLAPPING RULES

Transformation OE: OIS− →ISX: Replace overlapping rule f(tn) → r1 ? · · · ? rk by: f(tn) → f ′(y, xl) (where Var(tn) = {x1, . . . , xl}, y fresh, f ′ new) f ′(I1, xl) → r1 . . . f ′(Ik, xl) → rk data Ix = I1 | · · · | Ik (index type, e.g., natural numbers)

CAU Kiel Michael Hanus

7

slide-21
SLIDE 21

ELIMINATING OVERLAPPING RULES

Transformation OE: OIS− →ISX: Replace overlapping rule f(tn) → r1 ? · · · ? rk by: f(tn) → f ′(y, xl) (where Var(tn) = {x1, . . . , xl}, y fresh, f ′ new) f ′(I1, xl) → r1 . . . f ′(Ik, xl) → rk data Ix = I1 | · · · | Ik (index type, e.g., natural numbers) Example: parent(x) → mother(x) ? father(x) OE → data Iparent = I0 | I1 parent(x) → parent’(y,x) parent’(IO,x) → mother(x) parent’(I1,x) → father(x)

CAU Kiel Michael Hanus

7

slide-22
SLIDE 22

ELIMINATING OVERLAPPING RULES: RESULTS

Proposition: R ∈ OIS ⇒ OE(R) ∈ ISX

CAU Kiel Michael Hanus

8

slide-23
SLIDE 23

ELIMINATING OVERLAPPING RULES: RESULTS

Proposition: R ∈ OIS ⇒ OE(R) ∈ ISX Correctness w.r.t. results computed by needed narrowing: Theorem: R ∈ OIS, R′ = OE(R), t, s terms of R: Soundness: t

NN *

❀σ′ s w.r.t. R′ ⇒ ∃ t

NN *

❀σ s w.r.t. R with σ =Var(t) σ′ Completeness: t

NN *

❀σ s w.r.t. R ⇒ ∃ t

NN *

❀σ′ s w.r.t. R′ with σ =Var(t) σ′

CAU Kiel Michael Hanus

8

slide-24
SLIDE 24

ELIMINATING OVERLAPPING RULES: RESULTS

Proposition: R ∈ OIS ⇒ OE(R) ∈ ISX Correctness w.r.t. results computed by needed narrowing: Theorem: R ∈ OIS, R′ = OE(R), t, s terms of R: Soundness: t

NN *

❀σ′ s w.r.t. R′ ⇒ ∃ t

NN *

❀σ s w.r.t. R with σ =Var(t) σ′ Completeness: t

NN *

❀σ s w.r.t. R ⇒ ∃ t

NN *

❀σ′ s w.r.t. R′ with σ =Var(t) σ′ ⇒ Implementations need not implement overlapping rules (done in several implementations but without formal justification)

CAU Kiel Michael Hanus

8

slide-25
SLIDE 25

ELIMINATING LOGIC VARIABLES

Transformation XE: ISX− →OIS− (extra variable elimination) OIS−: overlapping inductively sequential without extra variables Evaluation in OIS−: rewriting (not narrowing) Thus: programs transformed by XE ❀ implementation without handling of logic variables and substitutions

CAU Kiel Michael Hanus

9

slide-26
SLIDE 26

ELIMINATING LOGIC VARIABLES

Transformation XE: ISX− →OIS− (extra variable elimination) OIS−: overlapping inductively sequential without extra variables Evaluation in OIS−: rewriting (not narrowing) Thus: programs transformed by XE ❀ implementation without handling of logic variables and substitutions Basic idea of XE: replace extra variables in rules by value generators

CAU Kiel Michael Hanus

9

slide-27
SLIDE 27

VALUE GENERATORS

S: sort defined by datatype declaration data S = C1 t11 . . . t1a1 | . . . | Cn tn1 . . . tnan Value generator operation instOfS defined by (overlapping) rules instOfS → C1(instOft11,. . .,instOft1a1) ? . . . ? Cn(instOftn1,. . .,instOftnan)

CAU Kiel Michael Hanus

10

slide-28
SLIDE 28

VALUE GENERATORS

S: sort defined by datatype declaration data S = C1 t11 . . . t1a1 | . . . | Cn tn1 . . . tnan Value generator operation instOfS defined by (overlapping) rules instOfS → C1(instOft11,. . .,instOft1a1) ? . . . ? Cn(instOftn1,. . .,instOftnan) Example: data TreeNat = Leaf | Branch Nat TreeNat TreeNat instOfTreeNat → Leaf ? Branch(instOfNat,instOfTreeNat,instOfTreeNat) instOfTreeNat → O ? S(instOfNat)

CAU Kiel Michael Hanus

10

slide-29
SLIDE 29

VALUE GENERATORS

S: sort defined by datatype declaration data S = C1 t11 . . . t1a1 | . . . | Cn tn1 . . . tnan Value generator operation instOfS defined by (overlapping) rules instOfS → C1(instOft11,. . .,instOft1a1) ? . . . ? Cn(instOftn1,. . .,instOftnan) Example: data TreeNat = Leaf | Branch Nat TreeNat TreeNat instOfTreeNat → Leaf ? Branch(instOfNat,instOfTreeNat,instOfTreeNat) instOfTreeNat → O ? S(instOfNat) Lemma: ∀ ground constructor terms t of sort S: instOfS

∗

→ t

CAU Kiel Michael Hanus

10

slide-30
SLIDE 30

EXTRA VARIABLE ELIMINATION

Transformation XE: OIS− →OIS− replace each extra variable v of sort S in a rule by instOfS

CAU Kiel Michael Hanus

11

slide-31
SLIDE 31

EXTRA VARIABLE ELIMINATION

Transformation XE: OIS− →OIS− replace each extra variable v of sort S in a rule by instOfS Example: even → add(x,x) XE → even → add(instOfNat,instOfNat)

CAU Kiel Michael Hanus

11

slide-32
SLIDE 32

EXTRA VARIABLE ELIMINATION

Transformation XE: OIS− →OIS− replace each extra variable v of sort S in a rule by instOfS Example: even → add(x,x) XE → even → add(instOfNat,instOfNat) Lemma (Completeness of XE): t

∗

❀ u w.r.t. R ⇒ XE(t)

∗

→ v w.r.t. XE(R) (v: ground constructor instance of u)

CAU Kiel Michael Hanus

11

slide-33
SLIDE 33

EXTRA VARIABLE ELIMINATION

Transformation XE: OIS− →OIS− replace each extra variable v of sort S in a rule by instOfS Example: even → add(x,x) XE → even → add(instOfNat,instOfNat) Lemma (Completeness of XE): t

∗

❀ u w.r.t. R ⇒ XE(t)

∗

→ v w.r.t. XE(R) (v: ground constructor instance of u) XE is not sound: even → add(instOfNat,instOfNat)

+

→ add(O,S(O)) → S(O)

CAU Kiel Michael Hanus

11

slide-34
SLIDE 34

EXTRA VARIABLE ELIMINATION

Transformation XE: OIS− →OIS− replace each extra variable v of sort S in a rule by instOfS Example: even → add(x,x) XE → even → add(instOfNat,instOfNat) Lemma (Completeness of XE): t

∗

❀ u w.r.t. R ⇒ XE(t)

∗

→ v w.r.t. XE(R) (v: ground constructor instance of u) XE is not sound: even → add(instOfNat,instOfNat)

+

→ add(O,S(O)) → S(O) Solution: identical reductions for extra variable generators

CAU Kiel Michael Hanus

11

slide-35
SLIDE 35

ADMISSIBLE DERIVATIONS

Admissible derivation: apply to occurrences of instOf (originating from same extra variable) identical reduction steps

CAU Kiel Michael Hanus

12

slide-36
SLIDE 36

ADMISSIBLE DERIVATIONS

Admissible derivation: apply to occurrences of instOf (originating from same extra variable) identical reduction steps Implementation: use let bindings available in many languages Example: even → add(x,x) XEP → even → let x = instOfNat in add(x,x)

CAU Kiel Michael Hanus

12

slide-37
SLIDE 37

ADMISSIBLE DERIVATIONS

Admissible derivation: apply to occurrences of instOf (originating from same extra variable) identical reduction steps Implementation: use let bindings available in many languages Example: even → add(x,x) XEP → even → let x = instOfNat in add(x,x) Formalization (details in paper) by transformation XEP: term/substitution pairs where substitution contains instOf operations

CAU Kiel Michael Hanus

12

slide-38
SLIDE 38

ADMISSIBLE DERIVATIONS

Admissible derivation: apply to occurrences of instOf (originating from same extra variable) identical reduction steps Implementation: use let bindings available in many languages Example: even → add(x,x) XEP → even → let x = instOfNat in add(x,x) Formalization (details in paper) by transformation XEP: term/substitution pairs where substitution contains instOf operations Theorem: transformation XEP is sound and complete

CAU Kiel Michael Hanus

12

slide-39
SLIDE 39

ELIMINATING EXTRA VARIABLES: INITIAL GOALS

Transformation XEP shows: logic variables can be eliminated if overlapping rules are supported

CAU Kiel Michael Hanus

13

slide-40
SLIDE 40

ELIMINATING EXTRA VARIABLES: INITIAL GOALS

Transformation XEP shows: logic variables can be eliminated if overlapping rules are supported Initial goals with logic variables: t with Var(t) = {x1, . . . , xn} ❀ start computation with initial term (t, x1, . . . , xn): Result (e, b1, . . . , bn): e ≈ computed value b1, . . . , bn ≈ computed answer

CAU Kiel Michael Hanus

13

slide-41
SLIDE 41

CONCLUSIONS

Two transformations on functional logic programs:

  • 1. eliminate overlapping rules by extra variables

➜ any functional logic program can be mapped into ISX ➜ ISX ≈ core language for functional logic programming ➜ practice: ISX already used as core in some implementations

  • 2. eliminate extra variables by new operations (overlapping rules)

➜ correctness requires admissible derivations ➜ implement admissible derivations by sharing / let expressions CAU Kiel Michael Hanus

14

slide-42
SLIDE 42

CONCLUSIONS

Two transformations on functional logic programs:

  • 1. eliminate overlapping rules by extra variables

➜ any functional logic program can be mapped into ISX ➜ ISX ≈ core language for functional logic programming ➜ practice: ISX already used as core in some implementations

  • 2. eliminate extra variables by new operations (overlapping rules)

➜ correctness requires admissible derivations ➜ implement admissible derivations by sharing / let expressions

Results useful for

➜ better understanding of functional logic programming features ➜ simpler core languages (support overlapping rules or extra variables) ➜ simpler implementations ➜ simplify tool support (e.g., current tracers, profi lers, slicers, partial evaluators: core language with overlapping rules and extra variables) ➜ better understanding of the role of logic variables CAU Kiel Michael Hanus

14