Logic Programming with Solution Preferences

1 / 25

# Logic Programming with Solution Preferences - PowerPoint PPT Presentation

Logic Programming with Solution Preferences Hai-Feng Guo University of Nebraska at Omaha, USA Preference Logic Programming (PLP) Proposed by Bharat Jayaraman (ICLP’95, POPL’96).

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

## PowerPoint Slideshow about 'Logic Programming with Solution Preferences' - ostinmannual

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

### Logic Programming with Solution Preferences

Hai-Feng Guo

University of Nebraska at Omaha, USA

Preference Logic Programming(PLP)
• Proposed by Bharat Jayaraman (ICLP’95, POPL’96).
• PLP is an extension of constraint logic programming for declaratively specifying optimization problems requiring comparison and selection among alternative solutions.
Optimization Problems
• A set of constraints
• Minimizing (or maximizing) an objective function
• Difficult to specify in the following cases
• compound objectives
• optimization over structural domains
Optimization using PLP
• Specification in PLP
• A set of constraints
• Solution preference rules
• Separate optimization from problem specification
• Declarativity and flexibility
A simple example: search for a lowest-cost path

path(X, X, 0, 0, []).

path(X, Y, C, D, [(X, Y)]) :- edge(X, Y, C, D).

path(X, Y, C, D, [(X, Z) | P]) :- edge(X, Z, C1, D1), path(Z, Y, C2, D2, P), D is D1 + D2, C is C1 + C2.

edge(a, b, 3, 4). … …

path(X,Y,C1, D1,_) <<< path(X,Y,C2, D2,_) :- C2 < C1.

path(X,Y,C1, D1,_) <<< path(X,Y,C2, D2,_) :- C1 = C2, D2 < D1.

Solution Preferences in Tabled Prolog
• Brief introduction of Tabled Prolog
• Mode-directed tabled predicates
• Support solution preferences
Tabled Prolog
• A tabled Prolog system
• terminates more often by computing fixed points
• avoids redundant computation by memoing the computed answers
• keeps the declarative and procedural semantics consistent for any definite Prolog programs with bounded-size terms.
:- table reach/2.

reach(X, Y) :- reach(X, Z), arc(Z, Y).

reach(X, Y) :- arc(X, Y).

arc(a, b).

arc(a, c).

arc(b, a).

:- reach(a, X).

:- table reach/3.

reach(X, Y, E) :- reach(X, Z, E1),

arc(Z, Y, E2),

append(E1, E2, E).

reach(X, Y, E) :- arc(X, Y, E).

arc(a, b, [(a, b)]).

arc(a, c, [(a, c)]).

arc(b, a, [(b, a)]).

:- reach(a, X, P).

Reachability

c

a

b

• When an answer to a tabled subgoal is generated, variant checking is used to check whether it has been already tabled.
• Observation: for collecting paths for the reachability problem, we need only one simple path for each pair of nodes. A second possible path for the same pair of nodes could be thought of as a variant answer.
Indexed / Non-indexed
• The arguments of each tabled predicate are divided into indexed and non-indexed ones.
• Only indexed arguments are used for variant checking for collecting tabled answers.
• Non-indexed arguments are treated as no difference.
Mode Declaration for Tabled Predicates

:- table p(a1, …, an).

• p/n is a predicate name, n > 0;
• each ai has one of the following forms:
• + denotes that this indexed argument is used for variant checking;
•  denotes that this non-indexed argument is not used for variant checking.
:- table reach(+, +, –).

reach(X, Y, E) :- reach(X, Z, E1),

arc(Z, Y, E2),

append(E1, E2, E).

reach(X, Y, E) :- arc(X, Y, E).

arc(a, b, [(a, b)]).

arc(a, c, [(a, c)]).

arc(b, a, [(b, a)]).

:- reach(a, X, P).

Reachability

c

a

b

A shortest path

:- table path(+,+,min,–).

path(X, X, 0, []).

path(X, Y, D, [e(X, Y)]) :- edge(X, Y, D).

path(X, Y, D, [e(X, Z) | P]) :- edge(X, Z, D1), path(Z, Y, D2, P), D is D1 + D2.

edge(a,b,4). edge(b,a,3). edge(b,c,2). … …

Syntax
• A Prolog program with solution preferences consists of three parts:
• Constraints/rules to the general problem;
• Specify which predicate to be optimized with a mode declaration;
• Optimization criteria using a set of preference clauses in a form of:

T1 <<< T2 :- B1, B2, …, Bn. (n≥0)

A lowest-cost path

path(X, X, 0, 0, []).

path(X, Y, C, D, [e(X, Y)]) :- edge(X, Y, C, D).

path(X, Y, C, D, [e(X, Z) | P]) :- edge(X, Z, C1, D1), path(Z, Y, C2, D2, P), D is D1 + D2, C is C1 + C2.

:- table path(+,+,<<<,<<<, –).

path(X,Y,C1, D1,_) <<< path(X,Y,C2, D2,_) :- C2 < C1.

Path(X,Y,C1, D1,_) <<< path(X,Y,C2, D2,_) :- C1 = C2, D2 < D1.

Challenge
• How the defined solution preferences take effects automatically on pruning suboptimal answers and their dependents during the computation?
• The solution preferences --- Prolog programming level
• The answer collection --- the system level
A naïve transformation

pathNew(X, X, 0, 0, []).

pathNew(X, Y, C, D, [(X,Y)]) :- edge(X, Y, C, D).

pathNew(X, Y, C, D, [(X, Z)|P]) :-

edge(X, Z, C1, D1), path(Z, Y, C2, D2, P),

C is C1 + C2, D is D1 + D2.

:- table path(+, +, last, -, -).

path(X, Y, C1, D1, _) <<< path(X, Y, C2, D2, _) :-

C2 < C1.

path(X, Y, C1, D1, _) <<< path(X, Y, C2, D2, _) :-

C1 = C2, D2 < D1.

path(X, Y, C, D, P) :-

pathNew(X, Y, C, D, P),

( path(X, Y, C1, D1, P1) ->

path(X, Y, C1, D1, P1) <<< path(X, Y, C, D, P)

; true

).

Limitation
• The answer set over <<< has a total order relation:
• Every two answers are comparable in terms of <<<;
• Contradictory preferences are not allowed in the program;
• It is assumed that there is only a single optimal answer.
updateTable/1

updateTable(Ans) :-

compareToTabled(TabAns, Ans, Flist, AnsFlag),

AnsFlag == 0.

compareToTabled([], _, [], Flag) :-

(var(Flag) -> Flag = 0; true).

compareToTabled([T | Ttail], Ans, [F | Ftail], Flag) :-

(T <<< Ans -> F = 1; F = 0),

(Ans <<< T -> Flag = 1; true),

compareToTabled(Ttail, Ans, Ftail, Flag).

updateTable(Ans)
• It is invoked when a new answer Ans to a tabled subgoal is obtained;
• It determines whether Ans is less preferred than any current tabled answer; if so, Ans is discarded;
• It also determines whether Ans is better preferred than any current tabled answer; if so, those tabled answers are removed from the table.
Embedding Preferences via an Interface Predicate

path(X, X, 0, 0, []) :-

updateTable(path(X,X,0,0,[])).

path(X, Y, C, D, [(X,Y)]) :-

edge(X, Y, C, D), updateTable(path(X,Y,C,D,[(X,Y)])).

path(X, Y, C, D, [(X, Z)|P]) :-

edge(X, Z, C1, D1), path(Z, Y, C2, D2, P),

C is C1 + C2, D is D1 + D2,

updateTable(path(X,Y,C,D,[(X,Z)|P]).

:- table path(+, +, <<<, <<<, -).

path(X, Y, C1, D1, _) <<< path(X, Y, C2, D2, _) :-

C2 < C1.

path(X, Y, C1, D1, _) <<< path(X, Y, C2, D2, _) :-

C1 = C2, D2 < D1.

Flexibility