Deduktivní databáze a jejich implementace v relačním

prostředí

Karel Ježek

Obsah přednášky

• Motivace• Pojmy• Problémy• Experimentální systém• Rozšíření

Motivace

• Logická pravidla dovolují přirozené vyjadřování rekurze

• Logická pravidla umožňují integrovat znalosti do informačního systému

miluje(Piják, Pivo)prodává(Bar, Pivo, Cena)navštěvuje(Piják, Bar)

šťastný(X) :- navštěvuje(X, Bar),miluje(X, Pivo),prodává(Bar, Pivo, Cena).

•Hlava pravidla = levá strana•Tělo pravidla = pravá strana = konjunkce podcílů•Hlava a podcíle jsou atomy

Atom = predikát a jeho argumentyPredikát = jméno relace nebo aritmet. predikát (např. >)Argumenty jsou proměnné nebo konstanty

•Podcíle mohou být případně negovány

Sémantika pravidel

• Hlava je pravdivá pro ty své argumenty, pro které jsou pravdivé podcíle těla.

(neobsahuje-li tělo negace nebo aritmetická porovnání, získáme výsledek joinem podcílů a projekcí na proměnné hlavy)

Např.

šťastný = projekcepiják (navštěvuje join

miluje join prodává)

Vyhodnocování pravidel

1. Přiřazováním proměnných: Uvažuj všechna možná přiřazení hodnot k proměnným. Jsou-li všechny podcíle pravdivé, přidej hlavu do výsledné relace.

2. Přiřazováním n-tic: Uvažuj všechna přiřazení takových n-tic podcílům, že podcíle jsou pro ně pravdivé. Jsou-li proměnným přiřazeny konzistentní hodnoty, přidej hlavu do výsledku.

Př.: s(X, Y) :- r(X, Z), r(Z, Y), not r(X,Y). A Br = 1 2

2 3Ad1) Pro prvý podcíl je pravdivé

(1) X = 1, Z = 2(2) X = 2, Z = 3

V případě (1) je pro Y =3 pravdivý druhý podcíl. Jelikož (1, 3) není v r, je třetí podcíl také pravdivý. Proto (1, 3) patří do s.

Ad2) Začneme s pozitivními relacemi r(X, Z) r(Z, Y)(1, 2) (1, 2)(1, 2) (2, 3)(2, 3) (1, 2)(2, 3) (2, 3)

Pouze řádek druhý je kozistentní pro Z. Vyhovuje i třetímupodcíli, takže (1, 3) je jedinou n-ticí patřící do s.

Bezpečnost

• s(X) :- r(Y).

• s(X) :- not r(Y).

• s(X) :- r(Y), X >Y.

Ve všech případech je nekonečný výsledek i pro konečnou relaci r.

Pro smysluplnost vyhodnocení musí být splněny podmínky bezpečnosti

Jesliže proměnná X se vyskytuje:

1. v hlavě pravidla, nebo

2. v negovaném podcíli, nebo

3. v aritmetickém porovnání,

pak se musí současně vyskytovat i v pozitivním podcíli těla.

Datalog

• Kolekce pravidel je programem datalogu• Predikáty / relace dělíme na dvě třídy:

EDB = extenzionální databáze = relace uložené v DB

IDB = intenzionální databáze = relace definované jedním nebo více pravidly

• Predikát musí být z EDB nebo z IDB, ne z obou současně. IDB predikát může být v hlavě i v těle pravidla, EDB predikát může být jen v těle

Vyjadřovací síla základního Datalogu

• Datalog bez rekurze = relační algebra

• Datalog simuluje SQL select-from-where příkaz (bez agregace a grupování)

• Rekurzivní Datalog je schopen vyjadřovat dotazy nevyjádřitelné v SQL

• Stejně jako SQL však není úplný v Turingově smyslu

RekurzeStart IDB =

Aplikuj pravidla na IDB a EDB

Došlo ke změně IDB?

ano ne konec 

Vyhodnocování pevného boduDány

vzájemně rekurzivní predikáty p1, p2, …, pn

Hledáme

R1, R2, …, Rn všechny n-tice, pro které jsou p1 , …, pn

pravdivé.

Získáme je řešením

soustavy rovnic Ri = Ei (R1,R2, …,Rn) (i=1,2, …, n)

(Ei reprezentuje všechna rekurzivní pravidla pro pi )

rodič(Rodič, Dítě)

předek(A, B) :- rodič(A, B).

předek(A, B) :- předek(A, Z), rodič(Z, B).

předek = předek join rodič U rodič

Iterační řešení

•Naivní metoda

•Seminaivní metoda (při lineární rekurzi)

Naivní metoda

for i := 1 to n do Ri = ;

repeat

cond := true;

for i := 1 to n do Si := Ri;

for i := 1 to n do

begin

Ri := Ei(S1, S2, …, Sn);

if Ri Si then cond := false

end

until cond;

Seminaivní metoda

for i := 1 to n do Ri = ;for i := 1 to n do Di = ;repeatcond := true;

for i := 1 to n dobegin

Di := Ei(D1, D2, …, Dn) - Ri;Ri := Di Ri;

if Di then cond := falseend

until cond;

Příklad – strom předků

a

b c

f g

j k

předek1 = rodič(a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k).

předek2 = předek1 join rodič U rodič(a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k),(a, f), (a, g), (b, j), (b, k),(c, k),

předek3 = předek2 join rodič U rodič(a, b), (a, c), (b, f), (c, g), (f, j), (f, k), (g, k),(a, f), (a, g), (b, j), (b, k), (c, k),(a, j), (a, k).

předek(P,D) :- rodič (P,D).předek(P,D) :- rodič(P,X), předek(X,D). ?-předek(bohouš,X).

Není nutné vyhodnocovat celou relaci předekMetoda magických množin

kombinuje vyhodnocování zdola nahoru ashora dolů-zdobení programu (předávání informace shora)-vytvoření magického faktu (seménka)-konstrukce magických pravidel-konstrukce modifikovaných pravidel

m_seed_predek_bf(bohous).

m_predek_bf(A):-m_seed_predek_bf(A).

m_predek_bf(X):-m_predek_bf(P), rodic(P, X).

predek_bf(P, D):-m_predek_bf(P), rodic(P, D).

predek_bf(P, D):-m_predek_bf(P), rodic(P, X), m_predek_bf(X), predek_bf(X, D).

?-predek_bf(bohous, X).

b f

b j

b k

Problém s negací

• Negace v rekurzi způsobuje nejednoznačné výsledky nebo nekonečný výpočet

• Stratifikovaná negace

Graf G závislosti predikátů

o Vrcholy G jsou predikáty

o Hrana vede z q do p, je-li v IDB pravidlo

p :- …, q, … .

o Je-li q negováno, hrana je ohodnocena „~“

U U

Př.EDB: q = {1, 2}IDB: p(X) :- q(X), not p(X).

(1)p = Ø (2)p = {1, 2}(3)p = Ø (4)…

G: q p

~

Stratum IDB predikátu A je maximální počet ~ hran na cestědo A z EDB predikátu v grafu závislosti predikátů.

Datalogovský program je stratifikovaný, jestliže každý IDB predikát má konečné stratum

Je-li datalogovský program stratifikovaný, můžeme vyhodnotitIDB relace v pořadí od nejnižšího strata

Př.zdroj(1). nedosažitelnýhrana(1, 2).hrana(3, 4). ~hrana(4, 3).cil(2). dosažitelnýcil(3).dosazitelny(X) :- zdroj(X).dosazitelny(X) :- dosazitelny(Y), hrana(Y, X).nedosazitelny(X) :- cil(X), not dosazitelny(X).

1. Počítá dosažitelný={1, 2} stratum 02. Počítá nedosažitelný={3}

LDL, LDL++ (MCC Austin, UCLA)

• Verze 5.1 (1998)

• Otevřená architektura, integrace s SQL systémy, možnost propojení s externími SŘBD

• Podpora nemonotonních, nedeterministických a v omezené míře nestratifikovaných programů

Aditi (Melbourne)

• Verze Aditi2 (2001)

• Integrovaný systém orientovaný na diskové zpracování

• Víceuživatelský provoz (klient server architektura)

• Fakta uložena pouze v databázových relacích

Florid /LoPiX (Freiburg)

• Spojení logického a OO paradigma

• Vyhodnocuje zdola nahoru naivní metodou

• Jazyk

- F-logic (objekty)

- predikátový zápis

• LoPiX (2001) – zpracování XML dat

XSB (Leuven, Lisabon, Uppsala)

• Vyhodnocování shora dolů (základní)

• Vyhodnocování zdola nahoru (tabled resolution)

• Modulárně stratifikované programy

• Rozhraní pro C, Java, Perl, Oracle

• Generické predikáty (predikáty vyššího řádu)

• Verze 2.5 (březen 2002)

ConceptBase (Aachen)

• Multiuživatelský deduktivní manažer objektů (pro konceptuální modelování)

• Verze 5.23 (květen 2002)

• Vše je objektem

• Jazyk O-Telos podporuje

- logický formát,

- sémantické sítě,

- rámce.

• Rozhraní pro klientské programy v C, Java, Prolog

Překlad Datalogu do SQL v systému EDD

• Překlad faktů

• Překlad pravidel

• Rozšíření

- negativní literály

- agregáty

- přiřazovací příkazy

- neurčitost

Překlad faktů

jméno_faktu(c1, c2, …, cN).CREATE TABLE jméno_faktu(

ARG1 typ1,ARG2 typ2,ARGN typN

);

INSERT INTO jméno_faktu VALUES(c1,c2, …, cN) ;

Překlad faktů z databázových tabulekjméno_tabulky(atr1 typ1, atr2 typ2, …, atrN typN).

Překlad pravidel• Každé pravidlo je přeloženo na jeden příkaz

SELECT• Při více pravidlech pro jeden predikát je

výsledkem sjednocení příkazů SELECT

Překlad na příkaz SELECT1.Argumenty SELECT jsou jména

korespondující argumentům hlavy pravidla2.FROM část tvoří jména predikátů z těla

pravidla. Alias je použito při násobném výskytu predikátu v těle

3.WHERE část je konstruována cyklem:

FOR p IN prvý .. poslední predikát pravé strany pravidla LOOP IF p není predikát porovnání THEN

FOR a IN prvý .. poslední argument predikátu p LOOP IF a je proměnná THEN IF a se dříve vyskytnul jako argument q v pravé straně

THEN generuj do WHERE části podmínku spojení"p.jméno_sloupce = q.jméno _sloupce";

END IF; ELSE generuj do WHERE podmínku "p.jméno_sloupce =

a"; END IF;END LOOP;

ELSE -- p je porovnávací predikát IF oba argumenty predikátu p jsou proměnné THEN generuj do WHERE "argument_1 porovnání argument_2”; ELSE --proměnná je porovnávána s konstantou

generuj "argument porovnání konstanta"; END IF; END IF;END LOOP;

Překlad rekurze

• Vyhodnocování predikátů respektuje pořadí v grafu závislosti G

• Nerekurzivní predikát lze přeložit na pohled nebo na tabulku

• Rekurzivní predikát je reprezentován tabulkou

• Cyklický graf závislosti G je kondenzován na acyklický graf GT

• Pro uzel vzniklý kondenzací je generována smyčka v procedurálním rozšíření SQL

Př.rodic(a, b).rodic(a, c).rodic(b, f).rodic(c, g).rodic(f, j).rodic(f, k).rodic(g, k).predek(A, B) :- rodic(A, B).predek(A, B) :- predek(A, Z), rodic(Z, B).

CREATE TABLE rodic(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30));INSERT INTO rodic VALUES('a','b');INSERT INTO rodic VALUES('a','c');INSERT INTO rodic VALUES('b','f');INSERT INTO rodic VALUES('c','g');INSERT INTO rodic VALUES('f','j');INSERT INTO rodic VALUES('f','k');INSERT INTO rodic VALUES('g','k');CREATE TABLE predek(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30));INSERT INTO predekSELECT DISTINCT rodic0.ATTR_0,rodic0.ATTR_1FROM rodic rodic0;

DECLARE c NUMBER;BEGINLOOPc := 0;INSERT INTO predekSELECT DISTINCT predek0.ATTR_0,rodic0.ATTR_1FROM predek predek0,rodic rodic0WHERE predek0.ATTR_1=rodic0.ATTR_0AND (predek0.ATTR_0,rodic0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM predek);c := c + SQL%ROWCOUNT;COMMIT;IF c = 0 THEN EXIT; END IF;END LOOP;END;/

ATTR_0 ATTR_1------------------------------ ------a ba cb fc gf jf kg ka fa gb jb kc ka ja k

Překlad negativních literálů

Ovlivňuje konstrukci části WHERE

• Porovnávací predikát přeložený bez negace na tvar τ, je při negaci nahražen NOT τ

• Negace predikátu, který je definován v programu se přeloží na konstrukci

NOT EXISTS (SELECT …)

Př.v(1,2). v(1,3). v(1,4). v(3,5). v(4,6). v(5,7).ucpany(3).

hrana(A,B) :- v(A,B).hrana(A,B) :- v(B,A).

cesta(A,B) :- hrana(A,B).cesta(A,B) :- hrana(A,C),

cesta(C,B),not ucpany(C).

?-cesta(1,X).

INSERT INTO cestaSELECT DISTINCT hrana0.ATTR_0,hrana0.ATTR_1

FROM hrana hrana0;DECLARE c NUMBER;BEGIN LOOPc := 0;INSERT INTO cestaSELECT DISTINCT hrana0.ATTR_0,cesta0.ATTR_1FROM hrana hrana0,cesta cesta0WHERE hrana0.ATTR_1=cesta0.ATTR_0AND NOT EXISTS (SELECT * FROM ucpany WHERE ATTR_0=hrana0.ATTR_1)AND (hrana0.ATTR_0,cesta0.ATTR_1) NOT IN

(SELECT ATTR_0,ATTR_1 FROM cesta);c := c + SQL%ROWCOUNT;COMMIT;IF c = 0 THEN EXIT; END IF;END LOOP; END;/

1 ATTR_1--------------- 1 1 1 2 1 3 1 4 1 6

12

3 5 7

4 6

Překlad agregátů• Využití agregačních funkcí SQL• Agregáty se mohou vyskytovat jen v hlavách

pravidel

p(, agreg(Y)) :- …, q(…, Y, …), … .

SELECT …, agreg(q0.attr_k) FROM …, q q0 … WHERE …

GROUP BY atributy reprezentované .

Př.owns(a, b, 0.6).owns(a, c, 0.4).owns(b, c, 0.6).owns(b, d, 0.3).owns(c, d, 0.4).

controlsvia(X, X, Y, N) :- owns(X, Y, N).controlsvia(X, Y, Z, N) :- controls(X, Y), owns(Y, Z, N).

controlsum(X, Y, sum(N) ) :- controlsvia(X, _, Y, N).

controls(X, Y) :- controlsum(X, Y, N), N > 0.5.

CREATE TABLE owns(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 NUMBER);

INSERT INTO owns VALUES('a','b',0.6);INSERT INTO owns VALUES('a','c',0.4);INSERT INTO owns VALUES('b','c',0.6);INSERT INTO owns VALUES('b','d',0.3);INSERT INTO owns VALUES('c','d',0.4);CREATE TABLE controlsvia(ATTR_0 VARCHAR2(30),ATTR_1 VARCHAR2(30),ATTR_2 VARCHAR2(30),ATTR_3 NUMBER);INSERT INTO controlsviaSELECT DISTINCT owns0.ATTR_0,owns0.ATTR_0,owns0.ATTR_1,

owns0.ATTR_2FROM owns owns0;CREATE TABLE controls(ATTR_0 VARCHAR2(30),ATTR_1

VARCHAR2(30));CREATE TABLE controlsum(ATTR_0 VARCHAR2(30),ATTR_1

VARCHAR2(30),ATTR_2 NUMBER);

DECLARE c NUMBER;BEGIN LOOP c := 0;INSERT INTO controlsviaSELECT DISTINCT controls0.ATTR_0,controls0.ATTR_1,

owns0.ATTR_1,owns0.ATTR_2FROM controls controls0,owns owns0WHERE controls0.ATTR_1=owns0.ATTR_0AND (controls0.ATTR_0,controls0.ATTR_1,owns0.ATTR_1,

owns0.ATTR_2) NOT IN (SELECT ATTR_0,ATTR_1,ATTR_2,ATTR_3

FROM controlsvia);c := c + SQL%ROWCOUNT;INSERT INTO controlsSELECT DISTINCT controlsum0.ATTR_0,controlsum0.ATTR_1FROM controlsum controlsum0WHERE controlsum0.ATTR_2>0.5AND (controlsum0.ATTR_0,controlsum0.ATTR_1) NOT IN (SELECT ATTR_0,ATTR_1 FROM controls);c := c + SQL%ROWCOUNT;

UPDATE controlsumSET(ATTR_2)=(SELECT DISTINCT SUM(controlsvia0.ATTR_3)FROM controlsvia controlsvia0WHERE controlsvia0.ATTR_0=controlsum.ATTR_0AND controlsvia0.ATTR_2=controlsum.ATTR_1)WHERE (ATTR_2) NOT IN (SELECT DISTINCT

SUM(controlsvia0.ATTR_3)FROM controlsvia controlsvia0WHERE controlsvia0.ATTR_0=controlsum.ATTR_0AND controlsvia0.ATTR_2=controlsum.ATTR_1);c := c + SQL%ROWCOUNT;

INSERT INTO controlsumSELECT DISTINCT controlsvia0.ATTR_0,controlsvia0.ATTR_2,

SUM(controlsvia0.ATTR_3)FROM controlsvia controlsvia0WHERE (controlsvia0.ATTR_0,controlsvia0.ATTR_2) NOT IN

(SELECT ATTR_0,ATTR_1 FROM controlsum)GROUP BY controlsvia0.ATTR_0,controlsvia0.ATTR_2;c := c + SQL%ROWCOUNT;COMMIT;IF c = 0 THEN EXIT; END IF;END LOOP;END;/

Tabulka controls

ATTR_0 ATTR_1-----------------------------------a bb ca cb da d

Přiřazovací příkaz

• Užitečnost imperativní konstrukce

• Nemožnost vyhodnocování predikátů zdola nahoru

• Nemožnost vyjadřování pomocí SELECT

Př.time1(5). time1(17).time2(9). time2(20).

…

hour_diff(H1, H2, Hd) :- H1 <= H2, Hd := H2 - H1.hour_diff(H1,H2,Hd) :- H1 > H2, H2a := H2 + 24, Hd := H2a - H1.diff(X) :- time1(A), time2(B), hour_diff(A,B,X).

diff

time hour_diff

Typy pravidel a predikátů

A•Je-li pravidlo faktem nebo jeho tělo neobsahuje přiřazení ani B-literál, pak toto pravidlo je typu A.•Jsou-li typu A všechna pravidla definující predikát p, pak p je predikátem typu A.

Překlad A predikátů je prováděn dříve uvedeným způsobem.

B

• Pokud pravá strana pravidla obsahuje pouze

1. porovnávací predikáty, nebo

2. přiřazování (imperativní konstrukci) nebo

3. B-literál,

pak pravidlo je typu B. Jsou-li typu B všechna pravidla pro predikát p, pak p je typu B.

B predikáty jsou vyhodnocovány shora dolů. Každý B-predikát je přeložen na PL/SQL podprogram.

C

• Obsahuje-li tělo pravidla

1. Alespoň jeden B-literál nebo přiřazení a

2. Alespoň jeden z (A-literál, C-literál, CA-literál,

pak pravidlo je typu C. Jsou-li všechna pravidla pro predikát p typu C, je p typu C.

C predikáty lze vyhodnotit zdola nahoru pomocí kurzoru.

CA

• Je-li predikát p definován pravidly typu A i C, pak p je typu CA.

• Kombinace BA, CB, CBA nejsou přípustné

• Překladem CA predikátů je mix SELECT příkazů a příkazů procedurální nadstavby jazyka SQL.

CREATE PROCEDURE hour_diff(ATTR_0 IN OUT NUMBER, ATTR_1 IN OUT NUMBER, ATTR_2 IN OUT NUMBER, c_volani IN NUMBER, Pravda OUT NUMBER)AS H2a NUMBER;BEGIN Pravda := 0; IF c_volani=1 THEN IF ATTR_0 <= ATTR_1 THEN ATTR_2 := ATTR_1 - ATTR_0; Pravda := 1; END IF; ELSIF c_volani=2 THEN IF ATTR_0 > ATTR_1 THEN H2a := ATTR_1 + 24; ATTR_2 := H2a - ATTR_0; Pravda := 1; END IF; END IF; END;

CREATE TABLE diff(ATTR_0 NUMBER);CREATE TABLE diff_pom(ATTR_0 NUMBER);DECLARE i_1 NUMBER; pravda_1 NUMBER; X NUMBER; A NUMBER; B NUMBER; CURSOR cur1 IS SELECT time10.ATTR_0 Attr_0, time20.ATTR_0 Attr_1 FROM time1 time10, time2 time20;BEGIN… hour_diff(A, B, X, i_1, pravda_1);…END;/ INSERT INTO diff SELECT DISTINCT * FROM diff_pom;

Procedura PL/SQL úspěšně dokončena.  4 řádek vytvořeno. SQL> select * from diff;  ATTR_0------------- 3 4 15 16

Zavedení neurčitosti

• Fuzzy logika

• Faktor věrohodnosti CF

• Syntax pravidel a faktů– jméno_faktu(<Args>) CF hodnota.– hlava_pravidla((<Args>) :-

tělo_pravidla CF hodnota.

Gödelova logika•CF(p Λ q ) = min(CF(p), CF(q))

•CF(p V q) = max(CF(p), CF(q))

•CF(not p) = (if CF(p) = 0 then 1 else 0)

Łukasiewiczova logika•CF(p Λ q ) = max(0, CF(p) + CF(q) - 1)

•CF(p V q) = min(1, CF(p) + CF(q))

•CF(not p) = (1 - CF(p))

Produktová logika•CF(p Λ q ) = CF(p) * CF(q)

•CF(p V q) = CF(p) + CF(q) - CF(p) * CF(q)

•CF(not p) = (if CF(p) = 0 then 1 else 0)

l(<Args>) :- r1(<Args1>), r2(<Args2>) CF x.

Gödelcreate view l(<Args>, CF) as

select r1. <Args11>, r2. <Args21>, GodelovaKonjunkce(r1.CF, r2.CF)*x

from r1, r2where r1. <Args12> = r2. <Args22>;

function GodelovaKonjunkce(X1 real, X2 real) return real isbegin if X1 < X2 then return X1; else return X2; end if;end;

<Args11> argumenty r1 vyskytující se v hlavě pravidla<Args21> “ r2 “ “<Args12> “ r1 účastnící se v join s r2<Args22> “ r2 “ r1

l(<Args>) :- r1(<Args1>), r2(<Args2>) CF x.

Łukasiewiczcreate view l(<Args>, CF) as

select r1. <Args11>, r2. <Args21>, LukasKonjunkce(r1.CF, r2.CF)*x

from r1, r2where r1. <Args12> = r2. <Args22>and LukasKonjunkce(r1.CF, r2.CF) > 0;

function LukasKonjunkce(X1 real, X2 real) return real is

begin return (X1 + X2 – 1);end;

Produktfunction ProduktKonjunkce(X1 real, X2 real) return real is

begin return (X1 * X2 );end

l(<Args>) :- r1(<Args1>) CF x.

l(<Args>) :- r2(<Args2>) CF y.

Gödel

create view l_tmp(<Args>, CF) as

select r1. <Args>, r1.CF * x from r1

union

select r2. <Args>, r2.CF * y from r2;

create view l(<Args>, CF) as

select l_tmp. <Args>, max(l_tmp.CF) from l_tmp

group by l_tmp. <Args>;

Łukasiewicz

create view l_tmp(<Args>, CF) as

select r1. <Args>, r1.CF * x from r1

union

select r2. <Args>, r2.CF * y from r2;

create view l(<Args>, CF) as

select l_tmp. <Args>, LukasDisjunkce(sum(l_tmp.CF)) from l_tmp

group by l_tmp. <Args>;

function LukasDisjunkce(X real) return real is

begin if 1.0 > X then return X; else return 1.0;

end if;

end;

l(<Args>) :- r1(<Args1>), not r2(<Args2>) CF x.

Gödel / Produkt

create view l(<Args>, CF) asselect r1. <Args11>, r1.CF * x from r1

where not exists (select * from r2where r2. <Args2> = r1. <Args12>;

<Args11> = <Args1> ∩ <Args><Args12> = <Args1> ∩ <Args2> 

l(<Args>) :- r1(<Args1>), not r2(<Args2>) CF x.

Łukasiewiczcreate view l(<Args>, CF) as

select r1. <Args11>, r1.CF * x from r1where not exists (select * from r2

where r2. <Args2> = r1. <Args12>; unionselect r1.<Args11>, LukasNegace(r1.CF, r2.CF)*x from r1,r2 where r1.<Args12> = r2.<Args2>

and LukasNegace(r1.CF, r2.CF) > 0;

function LukasNegace(X1 real, X2 real) return real isbegin return (X1 – X2);end;

Metoda magických množin ve fuzzy logice

• ? CF pravidel vznikajících z originálních a lišících se různými volnými / vázanými argumenty

• ? CF magických pravidel

• ? Vyhodnocování magických pravidel

• ? Vyhodnocování modifikovaných pravidel

•CF magických pravidel má hodnotu 1

•Magická pravidla se vyhodnocují dvouhodnotovou

logikou

•CF modifikovaných pravidel je určen příslušnými

originálními pravidly

•Modifikovaná pravidla se vyhodnocují fuzzy

logikou

Modelová aplikace

• Poskytování bankovního úvěru

• Data PKDD99

- 6 tabulek

- > 1 000 000 záznamů

- 80 MB

• Hlediska

- splácení minulých úvěrů

- stabilita regionu

- věk klienta

•Originální program- 62 pravidel- 16 pravidel s CF- run-time nezjistitelný

•Magický program- 125 pravidel- 500 KB dat- run-time 1min.