1 / 21

Typinferenz (mit Bitvectoren)

Typinferenz (mit Bitvectoren). Prolog Aufbaukurs SS 2000 Heinrich-Heine-Universität Düsseldorf Christof Rumpf Gast: Wolfram Bernhardt. Typensignatur zu ‚Shieber 1‘. top >> category , featval . category >> verbal , np :: HEAD : head .

alden-pearson
Download Presentation

Typinferenz (mit Bitvectoren)

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Typinferenz(mit Bitvectoren) Prolog Aufbaukurs SS 2000 Heinrich-Heine-Universität Düsseldorf Christof Rumpf Gast: Wolfram Bernhardt

  2. Typensignatur zu ‚Shieber 1‘ top >> category, featval. category >> verbal, np ::HEAD:head. featval >> head, agr, gen, pers, num, vform. head >> vhead, nhead. verbal >> v, vp, s ::HEAD:vhead. np ::HEAD:nhead. nhead ::AGREEMENT:agr. agr ::GENDER:gen,PERSON:pers,NUMBER:num. gen >> masc, fem, neut. pers >> first, second, third. num >> sing, plur. vhead ::FORM:vform,SUBJECT:np. vform >> finite, base. Kilbury 1997,QType-Syntax Typinferenz

  3. Typhierarchie top category verbal np v vp s featval vform finite base num sing plur agr gen masc fem neut head vhead nhead pers first second third Typinferenz

  4. Typhierarchie (mit Bitvectoren) top(1111111111111111) category(1111) verbal(111) np(1000) v(1) vp(10) s(100) featval(1111111111110000) num(110000000) sing(10000000) plur(100000000) agr(10000000000000000) vform(1100000000000) finite(100000000000) base(1000000000000) gen(1110000) masc(10000) fem(100000) neut(1000000) head(11000000000) vhead(1000000000) nhead(10000000000) pers(1110000000000000) first(10000000000000) second(100000000000000) third(1000000000000000) Typinferenz

  5. Subtypen Ein Subtyp ist ein Typ, bei dem dieselben Bits gesetzt sind wie beim seinem Supertyp, dessen totaler Wert jedoch kleinergleich dem des Supertypen ist. Dies kann mit einem Subsumptionscheck (siehe spätere Folie) geprüft werden. subtype(ST,T):- bitset_subsumes(T,ST). Typinferenz

  6. Echte Subtypen % true_subtype(?SubType,?Type) % SubType is a true subtype of Type. true_subtype(T1,T2):- subtype(T1,T2), T1 \= T2. Typinferenz

  7. Minimale (Sub-)Typen Bei minimalen Subtypen ist genau ein Bit gesetzt; sein Zahlenwert beträgt also eine Potenz von 2. Falls keine Operation zum Zählen gesetzer Bits vorliegt, ist die Überprüfung auf diesem Wege kompliziert, so daß wie gehabt auf die Typensignatur zurückgegriffen werden sollte: minimal_subtype(MiniType,Type):- subtype(MiniType,Type), minimal(MiniType). minimal(T):- T >> [] :: _. Eine allgemeine Möglichkeit ist festzustellen, ob ein Typ true_subtyps hat. Wenn nicht, ist er ein minimaler Typen: minimal(T):- \+ true_subtype(_,T). Typinferenz

  8. Extension eines Typs Die Extension eines Typen ist direkt aus seinem Bitvector abzulesen. Jedes gesetzte Bit entspricht einem minimalen Typen. Z.B. Category (1111) np (1000) v (0001) vp (0010) s (0100) Durch Operationen wie z.B. Komplementberechnung können Bitvektoren entstehen, die keine Entsprechung in der Typsignatur haben. Dennoch kann mit ihnen gearbeitet werden, da sie auf jeden Fall eine eindeutige Extension haben: _Noname (100010001001) np (000000001000)v (000000000001)sing (000010000000)nhead (100000000000) Typinferenz

  9. GLB über Extension Nebenstehende Definition hat folgende Voraussetzungen: % glb(?T1,?T2,?T3) glb(T1,T2,T3):- extension(T1,E1), extension(T2,E2), intersection(E1,E2,E4), sort(E4,E3), extension(T3,E3). • extension/2 liegt als berechnete Faktenmenge vor. • Das zweite Argument von extension/2 ist alphabetisch sortiert. • Jeder Typ hat entweder keinen oder mindestens zwei unmittelbare Subtypen. Typinferenz

  10. GLB - Berechnung / Typ-Unifikation Ein Hauptvorteil der Repräsentation durch Bitvectoren ist eine einfache Berechnung der größten unteren Schranke zweier Typen (greatest lower bound) durch die schnell Bitoperation AND. Um die größte untere Schranke zweier Typen zu berechnen, werden ihre Bitvectoren mit logischem UND verknüpft: glb(T1,T2,T3):- T3 is T1 /\ T2. Beispiele: category (1111) /\ np(1000) = np(1000) featval(1111111111110000) /\ second(1000000000000000) = second(1000000000000000) Aufgrund dieser Repräsentation und Berechnung ist glb/3 immer deterministisch. Typinferenz

  11. Untere Schranken Da die größte untere Schranke zweier Typen leicht zu berechnen ist und alle anderen unteren Schranken Subtypen dieser sind, können sie so berechnet werden: lb(T1,T2,T3):- glb(T1,T2,GLB), subtype(T3,GLB). Typinferenz

  12. Typen-Generalisierung / LUB Die Generalisierung von Typen läßt sich entgegen der Intuition nicht über die Vereinigung (logisches ODER) realisieren. verbal(111) v(1) vp(10) s(100) v(1) \/ v(10) = ?(011) !!! statt verbal(111) Hier muß auf die bekannte Methode zurückgegriffen werden. Typinferenz

  13. extension/2 liegt als berechnete Faktenmenge vor. Das zweite Argument von extension/2 ist alphabetisch sortiert. Jeder Typ hat entweder keinen oder mindestens zwei unmittelbare Supertypen. LUB über Extension - nicht vollständig Nebenstehende Definition hat folgende Voraussetzungen: % lub(?T1,?T2,?T3) lub(T1,T2,T3):- extension(T1,E1), extension(T2,E2), union(E1,E2,E4), sort(E4,E3), extension(T3,E3). Typinferenz

  14. Komplementberechnung ohne Bitvektoren % complement(?Type,-Complement) % The Complement of Type relative to all other Types. complement(Type,Complement):- type(Type), complement(Type,top,Complement). % complement(?Type,+ContextType,-Complement) % The Complement of Type relative to ContextType. % ContextType is the LUB for the complement types. complement(Type,CT,Complement):- setof1(ST,subtype(ST,CT),Types), complement_in_context(Type,Types,Complement0), lubs(Complement0,Complement), Complement \= [], !. Typinferenz

  15. Komplement im Kontextohne Bitvektoren % complement_in_context(?Type,+Context,-Complement) % The Complement of Type relative to Context. Context is a % list of candidate types for the complement. Every type in % Context that has no lower bound with Type is in Complement. complement_in_context(_,[],[]):- !. complement_in_context(Type,[T|Ts],Complement):- lb(Type,T,_), !, complement_in_context(Type,Ts,Complement). complement_in_context(Type,[T|Ts],[T|Complement]):- complement_in_context(Type,Ts,Complement). Typinferenz

  16. Komplement mit Bitvectoren I Die Komplementberechnung über Bitvektoren bietet zwei Vorteile: - einfach und schnell - Ergebnis ist ein weiterer Bitvektor anstatt einer Menge complement(BVType,Complement):- type(Type), bitvector_for_type(top,BVTOP), complement_in_context(BVType,BVTOP,Complement). Die Berechnung des Komplements in einem Kontext erfolgt über ein logisches NOT und ein AND: complement_in_context(T, CT, COMP) :- COMP is ( (\(T)) /\ CT). Typinferenz

  17. Komplement mit Bitvectoren II category(1111) verbal(111) np(1000) v(1) vp(10) s(100) Auf diese Weise können Bitvektoren entstehen, die keine Entsprechung im Typenverband haben complement_in_context(T, CT, COMP) :- COMP is ( (\(T)) /\ CT). Berechnet werden soll das Komplement von v(1) in Kontext von category(1111): COMP is ( (\(1)) /\ 1111) ==> COMP is ( (...110) /\ 1111) ==> COMP is 1110 Typinferenz

  18. Komplement mit Bitvectoren II category(1111) verbal(111) np(1000) v(1) vp(10) s(100) Auf diese Weise können Bitvektoren entstehen, die keine Entsprechung im Typenverband haben complement_in_context(T, CT, COMP) :- COMP is ( (\(T)) /\ CT). Berechnet werden soll das Komplement von v(1) in Kontext von category(1111): COMP is ( (\(1)) /\ 1111) ==> COMP is ( (...110) /\ 1111) ==> COMP is 1110 Typinferenz

  19. Problem: Identische Bitvektoren Unäre Vererbung: a(111) b(111) BCPO-Verletzung a(11) d(11) c(1) b(10) In bestimmten Fällen kann es dazu kommen, daß im Typenverband mehreren Typen derselbe Bitvektor zugewiesen wird. Diese Typen sind dann nicht mehr voneinander zu unterscheiden (z.B. bei Subtyp-Berechnung). Typinferenz

  20. Literatur • Hassan Ait-Kaci & Robert Boyer & Patrick Lincoln & Roger Nasr (1989): Efficient Implementation of Lattice Operations, ACM Transactions on Programming Languages and Systems, pg. 115-146 • Christof Rumpf & Christian Fischbach & Wolfram Bernhardt (2000): QType Manual (to appear) • Wolfram Bernhardt (2000): ???, master thesis (to appear) Typinferenz

  21. Aufgaben zu Bitvektoren: • Aufgabe 1: • Schreibe das Prädikatbuild_bitvectors/0, das aus einem gegebenen Typenverband (z.B. shieber1) die Faktenmengebitvector_to_type/2erzeugt. • Aufgabe 2: • a) Schreibe das Prädikatvector2set(+Bv, -Tl),das einem beliebigen Bitvektor die Liste der überdeckten Typen zuordnet. • b) Versuchevector2set/2deklarativ zu machen: vector2set(?Bv, ?Tl) • Hilfe: Möglicherweise benötigst Du die Operationen shift-left/2 und shift-right/2, um Bitketten zu verschieben: ‘>>‘ verschiebt nach rechts (Division durch 2), • ‘<<‘ verschiebt nach links (Multiplikation mit 2). • 1 << 4 = 16 (1 viermal nach links geschoben) • Aufgabe 3: • Überlege, wie Problem mit identischen Bitvectoren vermieden und bekämpft werden können. Typinferenz

More Related