Mugda - Abhängige Typen und Termination-Checking

Transkript

1 Mugda - Abhängige Typen und Termination-Checking Karl Mehltretter 1. Februar 2008

2 Dependent Types Martin-Löf Typentheorie Beweissysteme wie Coq, Lego (proofs as programs). Programmiersprachen: Agda, Epigram. conc :: (m n : Nat) -> Lst m -> Lst n -> Lst m + n

3 Termination-Checking length :: Lst -> Int length [] = 0 length (x:xs) = 1 + length xs syntaktisches Kriterium Verbesserung: z.b. size-change principle (Jones et al.) verwenden sized types (Abel, Barthe, Pareto... ): Information über Größe im Typsystem mitführen. xs hat Typ [a] i x:xs hat Typ [a] (i ++)

4 Diplomarbeit Agda 2 (U. Norrel) inductive families (P. Dybjer) dependent pattern matching (Th. Coquand)... braucht einen Termination-Checker. Programme (Beweise) sollen total sein. entscheidbares Type-Checking. Mugda weniger features... sized types coinduktive Typen (z.b. unendliche Listen), Produktivität.

5 Mugda Beispiel-Programme data Bool : Set tt : Bool ff : Bool data Nat : Set zero : Nat succ : Nat Nat fun add : Nat Nat Nat add x zero = x add x (succ y) = succ (add x y)

6 Listen und Vektoren data List (A : Set) : Set nil : List A cons : A List A List A data Vec (A : Set) : Nat Set nil : Vec A zero cons : (n : Nat ) A Vec A n Vec A (succ n) fun head : (A : Set) (n : Nat ) Vec A (succ n) A head B m (cons B m x xl) = x inaccessible pattern

7 Stream : coinduktiver Datentyp codata Stream : Set cons : Nat Stream Stream cofun zeroes : Stream zeroes = cons zero zeroes fun head : Stream Nat head (cons x xs) = x cofun unp : Stream unp = unp cofun unp : Stream unp = cons zero (tail unp )

8 Syntax für Typen und Terme: EXPR e, A, B ::= λ x. e (x : A) B e e 1... e n let x : e 1 = A 1 in e 2 Set x c D f l Patterns:... PAT p ::= x c p e

9 Problem: Terminierung fun foo : Nat Nat foo x = foo x let v : Vec Nat (foo zero ) = nil Nat zero Strukturelle Ordnung: x < c... x... wenn c induktiver Konstruktor D. Wahlstedt 2007: size-change principle + dependent types

10 Problem: Liste umdrehen... mutual fun rev : (A : Set) List A List A rev A (nil A) = nil A rev A (cons A x xs) = cons A (rev 1 A x xs) (rev 2 A x xs) fun rev 1 : (A : Set) A List A A rev 1 A a (nil A) = a rev 1 A a (cons A x xs) = rev 1 A x xs fun rev 2 : (A : Set) A List A List A rev 2 A a (nil A) = nil A rev 2 A a (cons A x xs) = rev A (cons A a (rev A (rev 2 A x xs)))

11 ... aber mit Vektoren klappts mutual fun rev : (n : Nat) (A : Set) Vec A n Vec A n rev zero A (nil A) = nil A rev succ n A (cons A n x xs) = cons A n (rev 1 n A x xs) (rev 2 n A x xs) fun rev 1 : (n : Nat) (A : Set) A Vec A n A rev 1 zero A a (nil A) = a rev 1 succ n A a (cons A n x xs) = rev 1 n A x xs fun rev 2 : (n : Nat) (A : Set) A Vec A n Vec A n rev 2 zero A a (nil A) = nil A rev 2 succ n A a (cons A n x xs) = rev (succ n) A (cons A n a (rev n A (rev 2 n A x xs))

12 Sized types Genauere Typen wie Vec statt List helfen bei Terminierung Filtern von Vektoren : Existentielle Typen fun filter : (A : Set) (p : A Bool) (n : Nat ) Vec A n (m : Nat.( Leq m n, Vec A m)) oft reicht upper bound. Automatisches Subtyping für Size: fun filter : (A : Set) (p : A Bool) (i : Size) List A i List A i Nat reicht nicht aus für ein Objekt vom Typ Stream Füge den speziellen Typ Size zu Mugda hinzu!

13 Erweiterung von Mugda... s = EXPR e, A, B ::=... Size Size Typ s e Nachfolger Limit PAT p ::=... s p für Terminierung: i < (s i) (Admissibility!)

14 Sized data types sized data List (A : Set) : Size Set nil : (i : Size) List A (s i) cons : (i : Size) A List A i List A (s i) sized data Nat : Size Set zero : (i : Size) Nat (s i) succ : (i : Size) Nat i Nat (s i) sized codata Stream : Size Set cons : (i : Size) Nat Stream i Stream (s i)...

15 Subtyping List i ist Subtyp von List (s i) und List. Stream (s i) und Stream sind Subtypen von Stream i. ersetze Gleichheit von Typen durch Subtyping.

16 Beispiel: Division fun minus : (i : Size) Nat i Nat Nat i minus s i (zero i) y = zero i minus i x (zero ) = x minus s i (succ i x) (succ y) = minus i x y fun div : (i : Size) Nat i Nat Nat i div s i (zero i) y = zero i div s i (succ i x) (zero ) = zero i div s i (succ i x) (succ y) = succ i (div i (minus i x y) (succ y))

17 Streams cofun zeroes : (i : Size) Stream i zeroes (s i) = cons i zero (zeroes i) cofun unp : (i : Size) Stream i unp i = unp i Produktivität über Size statt syntaktischem Guardedness-Test.

18 Admissibility - Nicht zulässiger Typ bei rekursiven Funktionen: mutual fun loop : (i : Size) Nat i (Nat Maybe (Nat i)) Bool loop s i (zero i)f = loop_case (s i) (zero i) f (f (zero i)) loop s i (succ i n)f = loop i n (shift i f ) fun loop_case : (i : Size) (Nat Maybe (Nat i))... let inc : Nat Maybe Nat = λ n. just Nat (succ n) let diverge : Bool = loop (zero ) inc

19 Admissibility bei rekursiven Funktionen: fun bad 1 : (i : Size) Bool bad 1 (s i) = bad 1 i fun bad 2 : (i : Size) Nat i Bool bad 2 s s i (zero (s i)) = bad 2 (s i) (zero i) bad 2 s i (succ i x) = bad 2 i x; Unvollständiges Size pattern! (s p) darf nicht vorkommen.

20 Zusamenfassung Mugda verbindet size-change principle und sized types. Produktivität mittels sized types statt guardedness. wurde implementiert (mit Type-Checking etc.) Todo: Klauseln sollen alle Fälle abdecken. Alles beweisen... Verbessere Admissiblity, Higher-Order Subtyping...

21 Backup

22 Gleichheit data Eq (A : Set) : A A Set refl : (a : A) Eq A a a let proof : (x : Nat ) Eq Nat (add x zero ) x = λ y. refl Nat y

23 Listen, Bäume data List (+ A : Set) : Set nil : List A cons : A List A List A data Tree (+ A : Set) : Set node : A List (Tree A) Tree A

24 Syntax DECL δ ::= data D τ : A γ codata D τ : A γ let l : A = e mutual µ mutual ν τ ::= (x : A) τ (+ x : A) τ CLAUSE κ ::= f p = e γ ::= c : A µ ::= fun f : A κ ν ::= cofun f : A κ

25 Semantik - Values, Closures VAL v ::= v v Lam x e ρ Pi x v e ρ a AVAL a ::= k N Set c f D ENV ρ ::= ρ, x = v

26 Auswertung : EXPR ENV VAL (λ x. e) ρ = Lam x e ρ ((x : A) B) ρ = Pi x v A B ρ mit v A = A ρ (let x : A = e 1 in e 2 ) ρ = e ρ,x=v 1 mit v 2 1 = e ρ 1 (e e 1... e n ) ρ = app v v 1... v n mit v = e ρ, v i = e ρ i Set ρ = Set c ρ = c f ρ = f l ρ = e mit Σ l = (e, v t ) x ρ = lkup ρ x app : VAL VAL VAL...

27 Bidirektionales Type-Checking Ist e vom Typ A? ist Typ: k; ρ 1 ; ρ 2 A Type N ENV ENV EXPR hat Typ: k; ρ 1 ; ρ 2 e v N ENV ENV EXPR VAL inferiere Typ: k; ρ 1 ; ρ 2 e v : N ENV ENV EXPR VAL

28 Gleichheit von Values Modus-Wechsel CHK-INF k; ρ 1; ρ 2 e v 2 N; k v 2 v 1 k; ρ 1 ; ρ 2 e v 1 Gleichheit (mit begrenztem Ausrollen von corekursiven Definitionen) F ::= {L, R, N} f ; k v 1 v 2 F N VAL VAL f ; k v 1 v 2 F N VAL VAL Bisimilarität als codata Prädikat definierbar. observational equality (McBride)

29 Type-Checking von Deklarationen Datentyp-Deklaration: strikte Positivität etc. Funktions-Deklaration : jede Klausel einzeln checken etc.

30 Terminierung ORDER = {?,, < } x < c... x... wenn c induktiver Konstruktor fun add : Nat Nat Nat add x zero = x add x (succ y) = succ (add x y) add (?? < ) add add (?? < ) add = add ( )? add? < size-change principle: Jede idempotente Matrix muss ein < auf Diagonale haben. D. Wahlstedt 2007: size-change principle + dependent types

31 Erweiterung von Mugda s = EXPR e, A, B ::=... Size Size Typ s e Nachfolger Limit PAT p ::=... s p VAL v ::=... Size s v Terminierung: i < (s i) (Admissibility!)

32 Subtyping List i ist Subtyp von List (s i) und List. Stream (s i) und Stream sind Subtypen von Stream i. ersetze Regel: CHK-INF k; ρ 1; ρ 2 e v 2 N; k; v 2 v 1 k; ρ 1 ; ρ 2 e v 1

33 Streams cofun zeroes : (i : Size) Stream i zeroes (s i) = cons i zero (zeroes i) cofun unp : (i : Size) Stream i unp i = unp i cofun fib : Nat Nat (i : Size) Stream i fib x y (s i) = cons i x (fib y (add x y) i) let fib : Stream = fib (succ zero ) (succ zero ) fun head : Stream Nat head (cons x xs) = x fun tail : Stream Stream tail (cons x xs) = xs

34 Admissibility - fun fun loop : (i : Size) Nat i (Nat Maybe (Nat i)) Bool fun f mit Typ t = (a 1 : A 1 )... (a n : A n ) R. Für jedes (a j : A j ) der Form (i : Size): Für k > j, entweder i kommt nicht in A k vor oder A k ist ein sized inductive type der Größe i. Der Ergebniss-Typ R ist monoton in i. Ausserdem: Ein Pattern der Form s p kommt nicht in den Klauseln vor.... dann ist f admissible.

35 Admissibility - cofun cofun zeroes : (i : Size) Stream i zeroes (s i) = cons i zero (zeroes i) cofun f mit Typ t = (a 1 : A 1 )... (a n : A n ) R. Für jedes (a j : A j ) der Form (i : Size): Fuer k > j, i kommt nicht in A k vor. Der Ergebniss-Typ R ist ein ist ein sized coinductive type der Größe i.... dann ist f admissible.

36 Admissibility - cofun Folgende Haskell-Definition: fib :: [Int] fib = (1 : ( 1 : zipwith (+) fib (tail fib))) Nicht produktiv in Mugda. fun fib : (i : Size) Stream i fib (s s i) = cons (s i) 1 (cons i 1 (zipwith add (fib i) (tail i (fib (s i))))) aber nicht admissble: tail : (i : Size) Stream (s i) Stream i

37 Implementierung sized data Nat : Size -> Set { zero : (i: Size ) -> Nat ($ i); succ : (i : Size ) -> Nat i -> Nat ($ i) } fun addwith : ((k : Size ) -> Nat k -> Nat k ) -> (i : Size ) -> (j : Size ) -> Nat i -> Nat j -> Nat # { addwith f.($ i) j (zero i) y = y; addwith f.($ i) j (succ i x) y = succ # (addwith f j i (f j y) (f i x)) }