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

Related searches for Logic Programming with Solution Preferences

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

• 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.

• A set of constraints

• Minimizing (or maximizing) an objective function

• Difficult to specify in the following cases

• compound objectives

• optimization over structural domains

• 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

• 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.

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.

• 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.

:- 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.

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

Built-in Modes for Tabled Predicates

:- 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). … …

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

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.

• 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

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

).

• 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(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).

• 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.