Pushing Efficient Evaluation of HEX Programs by Modular - - PowerPoint PPT Presentation

▶
pushing efficient evaluation of hex programs by modular
SMART_READER_LITE
LIVE PREVIEW

Pushing Efficient Evaluation of HEX Programs by Modular - - PowerPoint PPT Presentation

Oct 23, 2023 103 likes •608 views

Pushing Efficient Evaluation of HEX Programs by Modular Decomposition Thomas Eiter Michael Fink Giovambattista Ianni Thomas Krennwallner Peter Schller KBS Group Institut fr Informationssysteme, Technische Universitt Wien

slide-1
SLIDE 1

Pushing Efficient Evaluation of HEX Programs by Modular Decomposition

Thomas Eiter Michael Fink Giovambattista Ianni Thomas Krennwallner Peter Schüller

KBS Group – Institut für Informationssysteme, Technische Universität Wien Dipartimento di Matematica, Università della Calabria

LPNMR – May 18, 2011

supported by: Austrian Science Fund (FWF) project P20841 and Vienna Science and Technology Fund (WWTF) project ICT08-020

slide-2
SLIDE 2

Outline

◮ Answer Set Programming ‘on one slide’ ◮ HEX basics ◮ Old HEX evaluation Example ◮ Improved HEX evaluation Example ◮ Formalism Improvements ◮ Implementation Improvements ◮ Benchmark Results

1 / 15

slide-3
SLIDE 3

Answer Set Programming [Gelfond and Lifschitz, 1991]

Atoms of the form p(t1, . . . , tk). Rules of the form α1 ∨ · · · ∨ αk ← β1, . . . , βn, not βn+1, . . . , not βm. Program P is a set of rules. Herbrand base HBP is the set of all ground atoms using constants of P. Interpretation I ⊆ HBP.

I | = grnd(P) iff I satisfies all ground rules. I | = rule body iff positive atoms are in I and negative atoms are not. I | = rule iff some αi ∈ I, or I does not satisfy the rule body.

FLP reduct [Faber et al., 2011] of P wrt. I:

fPI is the set of ground rules of P where I satisfies the rule body. I is an answer set iff I is a minimal model of fPI.

2 / 15

slide-4
SLIDE 4

HEX Syntax and Semantics [Eiter et al., 2005]

Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

External Atom:

◮ &g[x](y) ◮ with input list x = x1, . . . , xn and output list y = y1, . . . , ym

3 / 15

slide-5
SLIDE 5

HEX Syntax and Semantics [Eiter et al., 2005]

Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

External Atom:

◮ &g[x](y) ◮ with input list x = x1, . . . , xn and output list y = y1, . . . , ym ◮ I |

= &g[x](y)

iff oracle function f&g(I, x, y) is true

◮ intuitively: f&g is true iff y is an output of &g for input I and x

3 / 15

slide-6
SLIDE 6

HEX Example

EDB: {choose(a, c, d), choose(b, e, f)} Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

External Atom:

◮ &cost[p](money) is true if p/1 is true for a or f , ◮ &cost[p](time) is true if p/1 is true for b, c, d, or e, ◮ &cost[p](X) is false for all other X-es.

3 / 15

slide-7
SLIDE 7

HEX Example

EDB: {choose(a, c, d), choose(b, e, f)} Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

External Atom:

◮ &cost[p](money) is true if p/1 is true for a or f , ◮ &cost[p](time) is true if p/1 is true for b, c, d, or e, ◮ &cost[p](X) is false for all other X-es.

In our example . . .

{plan(a)} | = &cost[plan](money) {plan(a)} | = &cost[plan](time) {plan(b)} | = &cost[plan](money) {plan(b)} | = &cost[plan](time)

3 / 15

slide-8
SLIDE 8

HEX Example

EDB: {choose(a, c, d), choose(b, e, f)} Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

Answer Set Candidates (Guesses, without EDB):

◮ {plan(a), &cost[plan](money), need(p, money),

use(c), &cost[use](time), need(u, time)}

◮ {plan(a), &cost[plan](money), need(p, money),

use(d), &cost[use](time), need(u, time)}

◮ {plan(b), &cost[plan](time), need(p, time),

use(e), &cost[use](time), need(u, time)}

◮ {plan(b), &cost[plan](time), need(p, time),

use(f), &cost[use](money), need(u, money)}

3 / 15

slide-9
SLIDE 9

HEX Example (Answer Sets)

EDB: {choose(a, c, d), choose(b, e, f)} Example Program (IDB):

           r1: plan(a) ∨ plan(b) ← r2: need(p,C) ← &cost[plan](C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y) r4: need(u,C) ← &cost[use](C) c5: ← need(_ ,money)           

Answer Set Candidates (Guesses, without EDB):

◮ {plan(a), &cost[plan](money), need(p, money),

use(c), &cost[use](time), need(u, time)}

◮ {plan(a), &cost[plan](money), need(p, money),

use(d), &cost[use](time), need(u, time)}

◮ {plan(b), &cost[plan](time), need(p, time),

⇐ Answer Set use(e), &cost[use](time), need(u, time)}

◮ {plan(b), &cost[plan](time), need(p, time),

use(f), &cost[use](money), need(u, money)}

3 / 15

slide-10
SLIDE 10

HEX evaluation (old strategy)

(1) calculate models of largest possible program part which does not depend on (not yet calculated) external atoms (2) calculate external atoms that depend on (1) (3) replace external atoms by result of (2) and goto (1)

4 / 15

slide-11
SLIDE 11

HEX evaluation (old strategy)

(1) calculate models of largest possible program part which does not depend on (not yet calculated) external atoms (2) calculate external atoms that depend on (1) (3) replace external atoms by result of (2) and goto (1) r1: plan(a) ∨ plan(b). r2: need(p,C) ←

&cost[plan](C). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). r4: need(u,C) ← &cost[use](C). c5: ← need(_ ,money). r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). derives: plan/1, use/1 u1 r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) derives: need/2 u2 c5: ← need(_,money) derives nothing u3

4 / 15

slide-12
SLIDE 12

HEX model building (old strategy)

r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). “Evaluation Graph” r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) c5: ← need(_,money) “Model Graph”

5 / 15

slide-13
SLIDE 13

HEX model building (old strategy)

r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). “Evaluation Graph” r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) c5: ← need(_,money) m1

O:−

= {plan(a), use(c)} m2

O:−

= {plan(a), use(d)} m3

O:−

= {plan(b), use(e)} m4

O:−

= {plan(b), use(f)} “Model Graph” m5

I:1

= m1 m6

I:2

= m2 m7

I:3

= m3 m8

I:4

= m4

5 / 15

slide-14
SLIDE 14

HEX model building (old strategy)

r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). “Evaluation Graph” r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) c5: ← need(_,money) m1

O:−

= {plan(a), use(c)} m2

O:−

= {plan(a), use(d)} m3

O:−

= {plan(b), use(e)} m4

O:−

= {plan(b), use(f)} “Model Graph” m5

I:1

= m1 m6

I:2

= m2 m7

I:3

= m3 m8

I:4

= m4 m9

O:5

= {need(p,money),need(u,time)} m10

O:6

= {need(p,money),need(u,time)} m11

O:7

= {need(p,time),need(u,time)} m12

O:8

= {need(p,time),need(u,money)} m13

I:9

= m9 m14

I:10

= m10 m15

I:11

= m11 m16

I:12

= m12

5 / 15

slide-15
SLIDE 15

HEX model building (old strategy)

r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). “Evaluation Graph” r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) c5: ← need(_,money) m1

O:−

= {plan(a), use(c)} m2

O:−

= {plan(a), use(d)} m3

O:−

= {plan(b), use(e)} m4

O:−

= {plan(b), use(f)} “Model Graph” m5

I:1

= m1 m6

I:2

= m2 m7

I:3

= m3 m8

I:4

= m4 m9

O:5

= {need(p,money),need(u,time)} m10

O:6

= {need(p,money),need(u,time)} m11

O:7

= {need(p,time),need(u,time)} m12

O:8

= {need(p,time),need(u,money)} m13

I:9

= m9 m14

I:10

= m10 m15

I:11

= m11 m16

I:12

= m12 m17

O:15

= ∅

5 / 15

slide-16
SLIDE 16

HEX model building (old strategy)

r1: plan(a) ∨ plan(b). r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). “Evaluation Graph” r2: need(p,C) ← &cost[plan](C) r4: need(u,C) ← &cost[use](C) c5: ← need(_,money) m1

O:−

= {plan(a), use(c)} m2

O:−

= {plan(a), use(d)} m3

O:−

= {plan(b), use(e)} m4

O:−

= {plan(b), use(f)} “Model Graph” m5

I:1

= m1 m6

I:2

= m2 m7

I:3

= m3 m8

I:4

= m4 m9

O:5

= {need(p,money),need(u,time)} m10

O:6

= {need(p,money),need(u,time)} m11

O:7

= {need(p,time),need(u,time)} m12

O:8

= {need(p,time),need(u,money)} m13

I:9

= m9 m14

I:10

= m10 m15

I:11

= m11 m16

I:12

= m12 m17

O:15

= ∅

5 / 15

slide-17
SLIDE 17

Observations

◮ We always compute the largest possible fragment.

⇒ multiplication of independent guesses ⇒ redundant evaluation of external atoms

◮ Constraints are considered once all dependencies are fulfilled

⇒ some models are eliminated later than possible

◮ We calculate all models at one unit, then go to the next unit.

⇒ if we need only one model, we calculate unnecessary models ⇒ Many improvements possible!

6 / 15

slide-18
SLIDE 18

New Strategy Evaluation Graph

r1: plan(a) ∨ plan(b). derives: plan/1 r2: need(p,C) ←&cost[plan](C). c5: ← need(_,money). derives: need(p,C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). derives: use/1 r4: need(u,C) ←&cost[use](C). c5: ← need(_,money). derives: need(u,C) u1 u2 u3 u4 Principles:

◮ Acyclic Evaluation Graph ◮ Evaluation Units derive disjoint atoms

⇒ constraints can be in multiple units, rules cannot be

◮ Rule dependencies fulfilled everywhere ◮ Negative constraint dependencies fulfilled everywhere ◮ Positive constraint dependencies fulfilled at least once

7 / 15

slide-19
SLIDE 19

New Strategy Model Building

r1: plan(a) ∨ plan(b). derives: plan/1 r2: need(p,C) ←&cost[plan](C). c5: ← need(_,money). derives: need(p,C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). derives: use/1 r4: need(u,C) ←&cost[use](C). c5: ← need(_,money). derives: need(u,C) u1 u2 u3 u4 Input and Output models at Evaluation Units:

◮ input models ⇐ joining output models of predecessor units ◮ output models ⇐ evaluating program fragment on input models ◮ Principle: same ancestor at common ancestor units

8 / 15

slide-20
SLIDE 20

New Strategy Model Building

r1: plan(a) ∨ plan(b). derives: plan/1 r2: need(p,C) ←&cost[plan](C). c5: ← need(_,money). derives: need(p,C) r3: use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). derives: use/1 r4: need(u,C) ←&cost[use](C). c5: ← need(_,money). derives: need(u,C) u1 u2 u3 u4 Input and Output models at Evaluation Units:

◮ input models ⇐ joining output models of predecessor units ◮ output models ⇐ evaluating program fragment on input models ◮ Principle: same ancestor at common ancestor units

Central Theorem: I = union of connected output models at every unit iff I = answer set of the program

8 / 15

slide-21
SLIDE 21

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 need input need output u1 u2 u3 u4

9 / 15

slide-22
SLIDE 22

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 need input need output need output need input need output u1 u2 u3 u4

9 / 15

slide-23
SLIDE 23

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 need output need input need output need output need input need output u1 u2 u3 u4

9 / 15

slide-24
SLIDE 24

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m3

I:1

= m1 need output need output need input need output u1 u2 u3 u4

9 / 15

slide-25
SLIDE 25

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m3

I:1

= m1

no output model to m3 need output need input need output

u1 u2 u3 u4

9 / 15

slide-26
SLIDE 26

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m3

I:1

= m1 need input need output need output need input need output u1 u2 u3 u4

9 / 15

slide-27
SLIDE 27

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} need output m3

I:1

= m1 need input need output need output need input need output u1 u2 u3 u4

9 / 15

slide-28
SLIDE 28

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 need output need output need input need output u1 u2 u3 u4

9 / 15

slide-29
SLIDE 29

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} need output need input need output u1 u2 u3 u4

9 / 15

slide-30
SLIDE 30

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} need input need output need input need output u1 u2 u3 u4

9 / 15

slide-31
SLIDE 31

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 need output need input need output u1 u2 u3 u4

9 / 15

slide-32
SLIDE 32

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m12

I:5,10

= {need(p, time), use(e)} need output u1 u2 u3 u4

9 / 15

slide-33
SLIDE 33

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m12

I:5,10

= {need(p, time), use(e)} m14

O:12

= {need(u, time)} u1 u2 u3 u4

9 / 15

slide-34
SLIDE 34

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m12

I:5,10

= {need(p, time), use(e)} m14

O:12

= {need(u, time)} need output u1 u2 u3 u4

9 / 15

slide-35
SLIDE 35

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m12

I:5,10

= {need(p, time), use(e)} m14

O:12

= {need(u, time)} no more output models to m12 u1 u2 u3 u4

9 / 15

slide-36
SLIDE 36

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} need output m12

I:5,10

= {need(p, time), use(e)} m14

O:12

= {need(u, time)} need input need output u1 u2 u3 u4

9 / 15

slide-37
SLIDE 37

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} need output u1 u2 u3 u4

9 / 15

slide-38
SLIDE 38

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} no more output models to m13 u1 u2 u3 u4

9 / 15

slide-39
SLIDE 39

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} need input u1 u2 u3 u4

9 / 15

slide-40
SLIDE 40

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} . . . no more input models u1 u2 u3 u4

9 / 15

slide-41
SLIDE 41

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m7

I:2

= m2 m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} all models enumerated u1 u2 u3 u4

9 / 15

slide-42
SLIDE 42

New Strategy Model Building

plan(a) ∨ plan(b). need(p,C) ← &cost[plan](C). ← need(_,money). use(X) ∨ use(Y) ← plan(P), choose(P,X,Y). need(u,C) ← &cost[use](C). ← need(_,money). u1 u2 u3 u4 m1

O:−

= {plan(a)} m2

O:−

= {plan(b)} m3

I:1

= m1 m4

I:2

= m2 m5

O:4

={need(p,time)} m6

I:1

= m1 m7

I:2

= m2 m8

O:6

= {use(c)} m9

O:6

= {use(d)} m10

O:7

= {use(e)} m11

O:7

= {use(f)} m12

I:5,10

= {need(p, time), use(e)} m13

I:5,11

= {need(p, time), use(f)} m14

O:12

= {need(u, time)} u1 u2 u3 u4

9 / 15

slide-43
SLIDE 43

Evaluation Algorithm Improvements

Acyclic Directed Evaluation Graph

⇒ independent program fragments evaluated independently ⇒ fewer redundant evaluations ⇒ parallel evaluation possible

Constraints can be shared between units

⇒ early model elimination

10 / 15

slide-44
SLIDE 44

Implementation Improvements

◮ Model generation as streaming mode

⇒ time-efficient first model computation ⇒ space-efficient model enumeration (output answer set → delete part of graph) ⇒ ground and nonground query answering (new) for HEX

◮ 64bit integer representation for any entity (space/time-efficiency) ◮ compressed bitset data structures for interpretations ◮ multiple backends: dlv and clingo (new) integrated

11 / 15

slide-45
SLIDE 45

Benchmarks – Reviewer Selection HEX

1 10 100 700 1 10 20 30 40

Evaluation time / secs (logscale) Number of conference tracks T

dlvhex1 (with H1) dlvhex2 with H1 dlvhex2 with H2

12 / 15

slide-46
SLIDE 46

Benchmarks – MCS

1 10 100 600 D

  • 7
  • 7
  • 3
  • 3

D

  • 7
  • 7
  • 4
  • 4

D

  • 7
  • 7
  • 5
  • 5

H

  • 9
  • 9
  • 3
  • 3

H

  • 9
  • 9
  • 4
  • 4

R

  • 7
  • 7
  • 4
  • 4

R

  • 7
  • 7
  • 5
  • 5

R

  • 7
  • 8
  • 5
  • 5

R

  • 7
  • 9
  • 5
  • 5

R

  • 8
  • 7
  • 5
  • 5

R

  • 8
  • 8
  • 5
  • 5

Z

  • 7
  • 7
  • 3
  • 3

Z

  • 7
  • 7
  • 4
  • 4

Z

  • 7
  • 7
  • 5
  • 5

Evaluation time / secs (logscale) Benchmark Instance Groups

dlvhex1 dlvhex2

13 / 15

slide-47
SLIDE 47

Benchmarks – Reviewer Selection ASP

100 200 300 400 10 20 30 40 50

Evaluation time / secs Number of papers at conference track P

dlv clasp+gringo dlvhex 2.x using dlv dlvhex 2.x using clasp+gringo

14 / 15

slide-48
SLIDE 48

Benchmarks – Reviewer Selection ASP

500 1000 1500 2000 2500 3000 10 20 30 40 50

Memory usage / MB Number of papers at conference track P

dlv clasp+gringo dlvhex 2.x using dlv dlvhex 2.x using clasp+gringo

14 / 15

slide-49
SLIDE 49

Conclusion

New HEX evaluation framework

⇒ simple optimizer heuristics; exponential speedup

for certain instances

⇒ potential for various future optimization strategies

(parallelization vs. memory usage vs. . . . ?) New Implementation (nearly a full rewrite)

⇒ try it and tell us about your experiences/problems

(not yet released, but branch is fully functional)

⇒ Instructions for building and detailed experimental results:

click Experiments on the dlvhex homepage http://www.kr.tuwien.ac.at/research/systems/dlvhex/

15 / 15

slide-50
SLIDE 50

References I

◮ Thomas Eiter, Giovambattista Ianni, Roman Schindlauer, and Hans

  • Tompits. A Uniform Integration of Higher-Order Reasoning and External

Evaluations in Answer-Set Programming. In IJCAI-05, pages 90–96, 2005.

◮ Wolfgang Faber, Nicola Leone, and Gerald Pfeifer. Semantics and

complexity of recursive aggregates in answer set programming. Artificial Intelligence, 175(1):278–298, January 2011.

◮ M. Gelfond and V. Lifschitz. Classical Negation in Logic Programs and

Disjunctive Databases. Next Generation Computing, 9(3–4):365–386, 1991.