String-based Multi-adjoint Lattices for Tracing Fuzzy Logic Computations

String-based Multi-adjoint Lattices for

Tracing Fuzzy Logic Computations

Pedro J. Morcillo Ginés Moreno

Jaime Penabad Carlos Vázquez

Faculty of Computer Science Engineering

University of Castilla – La Mancha

02005, Albacete, SPAIN

XII Jornadas sobre Programación y Lenguajes PROLE’12 18-19/IX/2012 Almería, SPAIN – p. 1/32

String-based Multi-adjoint Lattices for Tracing Fuzzy Log ic Computations

Outline of the talk

Multi-Adjoint Lattices & Programs

The Fuzzy Logic System FLOPER

Fuzzy Computed Answers with Traces

Conclusions and Further Research



Multi-Adjoint Lattices

A tuple (L,≤,←1,&1, . . . ,←n,&n) is a multi-adjointlattice if it verifies the following claims:i) (L,≤) is a complete lattice, with ⊥ and ⊤ elements.ii) (&i,←i) is an adjoint pair in (L,≤), i.e.:

1) &i is increasing in both arguments and⊤&iv = v&i⊤ = v.

2) ←i is increasing in the first argument anddecreasing in the second one.

3) Adjoint property: x ≤ (y ←i z) ⇐⇒ (x&iz) ≤ y

The Cartesian product L = L1 × ⋅ ⋅ ⋅ × Ln of multi-adjointlattices is a multi-adjoint lattice too.




∙ℬ. Boolean values with the classical adjoint pair (&,←).

∙V . Real numbers in the unit interval with adjoint pairsfrom the fuzzy logics of Product, Gödel and Łukasiewicz :

&P(x, y) ≜ x ∗ y ←P (x, y) ≜ min(1, x/y)

&G(x, y) ≜ min(x, y) ←G (x, y) ≜

⎧

⎨

⎩

1 if y ≤ x

x otherwise

&L(x, y) ≜ max(0, x+ y − 1) ←L (x, y) ≜ min{x− y + 1, 1}

∙W . Natural numbers with the inverted ordering where“+” plays the role of a conjuntion (or t-norm) operator.




∙S . Strings or sequences of symbols belonging to a givenalphabet (ASCII) for which “append” acts as a conjunctor.

KEYPOINT. Establish a bijection between S andW !!![a1 . . . am] = (cod(a1) + 1)nm−1 + ⋅ ⋅ ⋅ + (cod(am) + 1)n0

< m >=< ⌊(m− 1)/n⌋ > .asc((m− 1)%n)

[sea] = (cod(s)− 1)1282 + (cod(e)− 1)128 + (cod(a)− 1) =

(115− 1)1282 + (101− 1)128 + (97− 1) = 1880672

[son] = . . . = 1881965

[season] = . . . = 3944056928109



Multi-Adjoint Logic Programming

Let ℒ be a PROLOG-like first order language, with:constants variables functionspredicates quantifiers: ∀,∃ BUT MORE connectives!!!

&1, &2, . . . , &k (conjunctions)

∨1, ∨2, . . . , ∨l (disjunctions)

←1, ←2, . . . , ←m (implications)

@1, @2, . . . , @n (aggregations)

Instead of naive {true, false}, use a multi–adjointlattice to model truth degrees ⟨L,⪯,←1,&1, . . . ,←n,&n⟩.⟨[0,1],⪯, ←Luka,&Luka, ←Prod,&Prod, ←Godel,&Godel⟩




SYNTAX: Assume some connective definitions like:&Godel(x1, x2) ≜ min(x1, x2) - - in brief &G

&Prod(x1, x2) ≜ x1 ∗ x2 - - in brief &P

∨Luka(x1, x2) ≜ min(1, x1 + x2) - - in brief ∨L

@aver(x1, x2) ≜ (x1 + x2)/2

A program is a set of “weighted” rules A ←i ℬ with �:

ℛ1 : p(X) ←P &G(q(X),@aver(r(X), s(X))) witℎ 0.9

ℛ2 : q(a) ← witℎ 0.8

ℛ3 : r(X) ← witℎ 0.7

ℛ4 : s(X) ← witℎ 0.5




STATE : Is a pair with form ⟨goal; substitution⟩

INPUT (goal): For instance, ⟨p(X); id⟩

OUTPUT (fuzzy computed answer): Is a (final) state ofthe form ⟨trutℎ_degree; substitution⟩

PROCEDURAL SEMANTICS:Operational phase: Admissible steps (→AS)Interpretive phase: Interpretive steps (→IS)

Given a program P, goal Q and substitution �, wedefine an STATE TRANSITION SYSTEM whosetransition relations are→AS and→IS




ADMISSIBLE STEP OF KIND →AS1

⟨Q[A];�⟩ →AS1 ⟨(Q[A/v&iℬ])�;��⟩ if

(1) A is the selected atom in Q,(2) � = mgu({A′ = A}),(3) A′←i ℬ with v in P and ℬ is not empty.

EXAMPLE. Let p(a)←prod p(f(a)) with 0.7 be a rule

⟨(p(b)&Gp(X))&Gq(X); id⟩ →AS1

⟨(p(b)&G0.7&prodp(f(a)))&Gq(a); {X/a}⟩




ADMISSIBLE STEP OF KIND →AS2

⟨Q[A];�⟩ →AS2 ⟨(Q[A/v])�;��⟩ if

(1) A is the selected atom in Q,(2) � = mgu({A′ = A}), and(3) A′← with v in P.

EXAMPLE. Let p(a)← with 0.7 be a rule

⟨(p(b)&Gp(X))&Gq(X); id⟩ →AS2

⟨(p(b)&G0.7)&Gq(a); {X/a}⟩




INTERPRETIVE STEP→IS

⟨Q[@(r1, r2)];�⟩ →IS ⟨Q[@(r1,r2)/[[@]](r1,r2)];�⟩

where [[@]] is the truth function of connective @in the multi-adjoint lattice associated to P

EXAMPLE. Since the truth function associatedto &prod is the product operator, then

⟨(0.8&luka((0.7&prod0.9)&G0.7)); {X/a}⟩ →IS

⟨(0.8&luka(0.63&G0.7)); {X/a}⟩



Multi-Adjoint Logic Programming⟨p(X); id⟩ →AS1

ℛ1

⟨&P(0.9,&G(q(X1),@aver(r(X1), s(X1)))); {X/X1}⟩ →AS2ℛ2

⟨&P(0.9,&G(0.8,@aver(r(a), s(a)))); {X/a}⟩ →AS2ℛ3

⟨&P(0.9,&G(0.8,@aver(0.7, s(a)))); {X/a}⟩ →AS2ℛ4

⟨&P(0.9,&G(0.8,@aver(0.7, 0.5))); {X/a}⟩ →IS

⟨&P(0.9,&G(0.8, 0.6)); {X/a}⟩ →IS

⟨&P(0.9, 0.6); {X/a}⟩ →IS

⟨0.54; {X/a}⟩

So, for derivation D1 the f.c.a is ⟨0.54; {X/a}⟩




http://dectau.uclm.es/floper/

PROLOG has been largely used for four purposes.....

Implementing the tool (about 1000 clauses, DCG’s)

Compiling fuzzy programs (compiled code in Prolog):∙ HIGH LEVEL: transparent execution of goals∙ LOW LEVEL: drawing derivations and trees

Modeling multi-adjoint lattices (represent truth degrees)




Basic options for...∙ Loading a prolog file with extension “.pl”∙ Parsing a “.fpl” fuzzy program. The resulting Prolog

code is also asserted in the system∙ Saving the generated Prolog code into a “.pl” file∙ Listing both the fuzzy and Prolog code∙ Clean, Stop and Quit

Advanced options for...∙ Running a fuzzy program after introducing a goal∙ Drawing derivations and unfolding trees (varying its

depth and the level of detail of interpretive steps)∙ Loading/showing multi-adjoint lattices (“.pl” files)



The Fuzzy Logic System FLOPER. Option RUN

PROGRAM : p(X) ←P &G(q(X),@aver(r(X), s(X))) with 0.9q(a) with 0.8 r(X) with 0.7 s(_) with 0.5

———————————————»»»»»>p(X, TV0) : − q(X, TV1), r(Y, TV2), s(X, TV3),

agr_aver(TV2, TV3, TV4),

and_godel(TV1, TV4, TV5),

and_prod(0.9, TV5, TV0).

q(a, 0.8). r(X, 0.7). s(_, 0.5).

GOAL : p(X) —–»»»»»> ?− p(X, Truth_degree)

OUTPUT : [X = a, Truth_degree = 0.54]



The Fuzzy Logic System FLOPER. Option LAT∙ Prolog file modeling an infinite lattice of real numbers [0,1]

member(X) :- number(X),0=<X,X=<1. leq(X,Y) :- X=<Y.

bot(0). top(1).

and_luka(X,Y,Z) :- pri_add(X,Y,U1),pri_sub(U1,1,U2),pri_max(0,U2,Z).

and_godel(X,Y,Z) :- pri_min(X,Y,Z).

and_prod(X,Y,Z) :- pri_prod(X,Y,Z).

or_luka(X,Y,Z) :- pri_add(X,Y,U1),pri_min(U1,1,Z).

or_godel(X,Y,Z) :- pri_max(X,Y,Z).

or_prod(X,Y,Z) :- pri_prod(X,Y,U1),pri_add(X,Y,U2),pri_sub(U2,U1,Z).

agr_aver(X,Y,Z) :- pri_add(X,Y,U),pri_div(U,2,Z).

pri_add(X,Y,Z) :- Z is X+Y. pri_min(X,Y,Z) :- (X=<Y,Z=X;X>Y,Z=Y).

pri_sub(X,Y,Z) :- Z is X-Y. pri_max(X,Y,Z) :- (X=<Y,Z=Y;X>Y,Z=X).

pri_prod(X,Y,Z) :- Z is X * Y. pri_div(X,Y,Z) :- Z is X/Y.



The Fuzzy Logic System FLOPER. Option LAT∙ Prolog file modeling a finite lattice with partial ordering

⊤

� �

⊥

members([bottom,alpha,beta,top]).

top(top). bot(bottom).

leq(bottom,X). leq(alpha,alpha). leq(alpha,top).

leq(beta,beta). leq(beta,top). leq(X,top).

and_godel(X,Y,Z) :- pri_inf(X,Y,Z).

pri_inf(bottom,X,bottom):-!.

pri_inf(alpha,X,alpha):-leq(alpha,X),!.

pri_inf(beta,X,beta):-leq(beta,X),!.

pri_inf(top,X,X):-!.

pri_inf(X,Y,bottom).



The Fuzzy Logic System FLOPER. Option LAT

EXAMPLE: maintain the program and goal, but changethe lattice of truth degrees, redefining “average”:

Instead of: @aver(x1, x2) ≜ (x1 + x2)/2, in PROLOG:agr_aver(X, Y, Z) : −pri_add(X, Y, U), pri_div(U, 2, Z).

Use now: @aver(x1, x2) ≜ (∨G(x1, x2) + ∨L(x1, x2))/2agr_aver(X, Y, Z) : −or_godel(X, Y, Z1), or_luka(X, Y, Z2),

pri_add(Z1, Z2, Z3), pri_div(Z3, 2, Z).

Now, without changing the same program and goal,the solution for p(X) is not [Truth = 0.54, X = a] but[Truth = 0.72, X = a]



The Fuzzy Logic System FLOPER. Option TREE

p(X) ←P &G(q(X),@aver(r(X), s(X))) with 0.9—————————————————————–»»»»»»>rule(number(1),

head(atom(pred(p,1),[var(’X’)])),impl(prod),body(and(godel,2,

[atom(pred(q,1),[var(’X’)]),agr(aver,2,

[atom(pred(r,1),[var(’X’)]),atom(pred(s,1),[var(’X’)])

])])),td(0.9)).



The Fuzzy Logic System FLOPER. Option TREE

∙ Unfolding tree showing admissible stepsR0 <p(X),{}>

R1 <&prod(0.9,&godel(q(X1),@aver(r(X1),s(X1)))),{X/X1} >

R2 <&prod(0.9,&godel(0.8,@aver(r(a),s(a)))),{X/a,X1/a}>

R3 <&prod(0.9,&godel(0.8,@aver(0.7,s(a)))),{X/a,X1/a,X11/a}>

R4 <&prod(0.9,&godel(0.8,@aver(0.7,0.5))),{X/a,X1/a,X11/a}>result < 0.7200000000000001,{X/a,X1/a,X11/a}>

∙ Unfolding tree displaying interpretive steps tooR0 <p(X),{}>

R1 <&prod(0.9,&godel(q(X1),@aver(r(X1),s(X1)))),{X/X1} >

R2 <&prod(0.9,&godel(0.8,@aver(r(a),s(a)))),{X/a,X1/a}>

R3 <&prod(0.9,&godel(0.8,@aver(0.7,s(a)))),{X/a,X1/a,X11/a}>

R4 <&prod(0.9,&godel(0.8,@aver(0.7,0.5))),{X/a,X1/a,X11/a}>is <&prod(0.9,&godel(0.8,0.85)),{X/a,X1/a,X11/a}>

is <&prod(0.9,0.8),{X/a,X1/a,X11/a}>

is <0.7200000000000001,{X/a,X1/a,X11/a}>






Let the “proof weight” latticeW of [Rodríguez & Romero-08]that is, natural numbers with the inverted ordering andoperator “+” assigned to all connectives ( &P, &G, @aver)

ℛ1 : p(X) ←P &G(q(X),@aver(r(X), s(X))) witℎ 1

ℛ2 : q(a) ← witℎ 1

ℛ3 : r(X) ← witℎ 1

ℛ4 : s(X) ← witℎ 1

Fuzzy Computed Answer counting admissible steps» run.

[Truth_degree=4, X=a]




Consider a lattice where truth degrees are strings andappend is assigned to all connectives ( &P, &G, @aver)

p(X) ←P &G(q(X),@aver(r(X), s(X))) witℎ ′rule1.′

q(a) ← witℎ ′rule2.′

r(X) ← witℎ ′rule3.′

s(X) ← witℎ ′rule4.′

Fuzzy Computed Answer detailing admissible steps» run.

[Truth_degree=’rule1.rule2.rule3 rule4.’,X=a]




∙ Multi-adjoint lattices as CARTESIAN PRODUCTS:member(info(X,Y)):-number(X),0=<X,X=<1,string(Y). bot(info(0,_)).

leq(info(X1,_),info(X2,_)) :- X1 =< X2. top(info(1,_)).

and_prod(info(X1,X2),info(Y1,Y2),info(Z1,Z2)) :- pri_prod(X1,Y1,Z1),

pri_app(X2,Y2,Label),pri_app(Label,’&PROD.’,Z2).

pri_app(X,Y,Z) :- name(X,L1),name(Y,L2),append(L1,L2,L3),name(Z,L3).

p(X)←P &G(q(X),@aver(r(X), s(X))) with info(0.9,′ rule1.′)...

∙ [X=a, Truth_degree=info(0.72, rule1.rule2.rule3.rule4.@AVER. &GODEL. &PROD. )]




∙ More on multi-adjoint lattices as Cartesian products:“attaching” now appropriate labels to primitive operators

pri_prod(X,Y,Z,’#PROD.’):-Z is X * Y.

and_prod(info(X1,X2),info(Y1,Y2),info(Z1,Z2)):-

pri_prod(X1,Y1,Z1,DatPROD),pri_app(X2,Y2,Dat1),

pri_app(Dat1,’&PROD.’,Dat2),pri_app(Dat2,DatPROD,Z2).

∙ [X=a, Truth_degree=info(0.72, rule1.rule2.rule3.rule4.@AVER. |GODEL. #MAX. |LUKA. #ADD.#MIN. @aver.#ADD.#DIV. &GODEL. #MIN. &PROD. #PROD. )]



⟨p(X); id⟩ →AS1ℛ1

⟨&P(info(0.9, ‘RULE1.′),&G(q(X1),@aver2(r(X1), s(X1)))); {X/X1}⟩ →AS2ℛ2

⟨&P(info(0.9, ‘RULE1.′),&G(info(0.8, ‘RULE2.′),@aver2(r(a), s(a))))); {X/a}⟩ →AS2ℛ3

⟨&P(info(0.9, ‘RULE1.′),&G(info(0.8, ‘RULE2.′),

@aver2(info(0.7, ‘RULE3.′), s(a))))); {X/a}⟩ →AS2ℛ4

⟨&P(info(0.9, ‘RULE1.′),&G(info(0.8, ‘RULE2.′),

@aver2(info(0.7, ‘RULE3.′), info(0.5, ‘RULE4.′)))); {X/a}⟩ →IS

⟨&P(info(0.9,‘RULE1.’),&G(info(0.8, ‘RULE2.′), info(0.85, ∗))); {X/a}⟩ →IS

⟨&P(info(0.9, ‘RULE1.′), info(0.8, ‘RULE2.RULE3...′)); {X/a}⟩ →IS

⟨info(0.72, ‘RULE1.RULE2.RULE3.RULE4.@AVER2.∣GODEL.#MAX.∣LUKA.....′); {X/a}⟩.

———————————————————————————————————————–∗ ‘RULE3.RULE4.@AVER2.∣GODEL.#MAX.∣LUKA.#ADD.#MIN.@AVER.#ADD.#DIV.′








http://dectau.uclm.es/FuzzyXPath/

Management of XML documents by using flexiblevariants of standard XPath/XQuery languages

MALP implementation using FLOPER & SWI-Prolog:member(tv(N,L)) :- number(N),0=<N,N=<1,

(L=[];L=[_|_]).

and_prod(tv(X1,X2),tv(Y1,Y2),tv(Z1,Z2)) :-Z1 is X1*Y1, append(X2,Y2,Z2).






Fuzzy Logic Programming LANGUAGE:The Multi-Adjoint Logic Programming approach

FLOPER provides advanced options with “fuzzy taste”:

Compilation to Prolog code [RUN]: simplicity,transparency, complete evaluation of goals...Low level representation [TREE]: traces, derivations,detailed computation steps (interpretive)...Multi-adjoint lattices [LAT]: modeled in Prolog,rich/flexible behaviour of computations...f.c.a’s with traces: [RUN] with appropriate [LAT]mimics [TREE] without extra computational effort




However, more efforts are needed for.....

Increasing expressivity: new computation rules, testingformal properties of fuzzy connectives, connection withother fuzzy languages, graphical interface, etc

Including transformation techniques: optimization byFold/Unfold, specialization by Partial Evaluation,thresholded tabulation, etc

Ongoing application: we are currently implementingwith FLOPER fuzzy variants of XPath/XQuery for theflexible manipulation of XML documents


Education

String-based Multi-adjoint Lattices for Tracing Fuzzy Logic Computations