Logika i teoria typów Ko-rekursja i ko-indukcja

Transkrypt

1 Logika i teoria typów Ko-rekursja i ko-indukcja Wykład maja 2016 Strumienie Jaki sens ma równanie Stream = int Stream? Można je potraktować podobnie jak równanie int = 1 int, i rozważać typ rekurencyjny (indukcyjny) Stream = µp. int p. Ale to jest najmniejsze rozwiązanie równania: typ pusty. Najmniejszy punkt stały µ = µp. σ(p): - Kres górny (suma) ciągu aproksymacji skończonych. - Najmniejszy prefixpoint : σ(r) R f : σ(r) R µ R Elim f : µ R Na przykład: 1 R R f : 1 R R nat R Elim f : nat R Najmniejszy punkt stały µ = µp. σ(p): - Kres górny (suma) ciągu aproksymacji skończonych. - Najmniejszy prefixpoint : σ(r) R f : σ(r) R µ R Elim f : µ R Największy punkt stały ν = νp. σ(p): - Kres dolny (przecięcie) ciągu aproksymacji nieskończonych. - Największy postfixpoint : R σ(r) f : R σ(r) R ν Intro f : R ν Największy postfixpoint R σ(r) f : R σ(r) R ν Intro f : R ν Na przykład: R nat R f : R nat R R Stream Intro f : R Stream Co to znaczy? - Jeśli R nat R, to każdy element R jest strumieniem. - Funkcja R nat R wyznacza funkcję R Stream. Destruktory dla strumieni: hd : Stream nat i tl : Stream Stream. W Coqu destruktory nie są pierwotne. Definiujemy je przez dopasowanie: CoInductive Stream : Set := Cons : nat -> Stream -> Stream. Definition hd (s : Stream) := match s with Cons a t => a end. Definition tl (s : Stream) := match s with Cons a t => t end. Coq < Check hd. Coq < Check tl. hd : Stream -> nat tl : Stream -> Stream Przykład Coquanda Może być więcej niż jeden konstruktor. (Nie ma uniwersalnych destruktorów.) Proces typu P może wczytać liczbę i wypisać liczbę. in : (nat P) P; out : nat P P. Na przykład coś takiego: in(λn 1. out(0, in(λn 2. out(n 1, out(1, in(λn 3... Można definiować procesy ko-rekurencyjnie: p = in(λn. out(n + 1, p))

2 Przykład: definicje korekurencyjne: Predykaty koindukcyjne CoFixpoint samezera : Stream := Cons 0 samezera. CoFixpoint parzysteod : nat -> Stream := fun n :nat => Cons n (parzysteod (n+2)). Definition wszystkieparzyste := parzysteod 0. Coq < Eval simpl in hd (tl (wszystkieparzyste)). = 2 : nat Równość strumieni (czerwona): s = t, wtedy i tylko wtedy, gdy: hd(s) = hd(t) oraz tl(s) = tl(t) To jest bisymulacja. Predykat koindukcyjny: strumień składa się tylko z liczb parzystych. CoInductive Sameparzyste : Stream -> Prop := krok : forall x : Stream, even (hd x) -> Sameparzyste (tl x) -> Sameparzyste x. Dowód przez koindukcję: (zakładamy, że zeroparz : even(0)) CoFixpoint samezera : Stream := Cons 0 samezera. CoFixpoint Zeraparzyste : Sameparzyste samezera := krok samezera zeroparz Zeraparzyste. Coq < Zeraparzyste is corecursively defined Sens moralny CoInductive Sameparzyste : Stream -> Prop := krok : forall x : Stream, even (hd x) -> Sameparzyste (tl x) -> Sameparzyste x. CoFixpoint Zeraparzyste : Sameparzyste samezera := krok samezera zeroparz Zeraparzyste. Predykat Sameparzyste to w istocie największy punkt stały operacji s even s. W tym dowodzie korzystamy z reguły R even R R Sameparzyste dla relacji R = {samezera} Kolokwialny dowód przez ko-indukcję Kolokwialny dowód przez ko-indukcję Chcemy udowodnić, że każdy strumień z rodziny R składa się wyłącznie z liczb parzystych. Weźmy dowolny strumień s R. Sprawdzamy, że hd(s) jest liczbą parzystą. Sprawdzamy, że tl(s) też należy do rodziny R. Z założenia koindukcyjnego wnioskujemy, że tl(s) składa się z samych liczb parzystych. A zatem s też składa się tylko z liczb parzystych. Twierdzenie udowodnione. Chcemy udowodnić, że strumień samezera składa się wyłącznie z liczb parzystych. Weźmy więc ten strumień. Sprawdzamy, że hd(samezera) = 0 jest liczbą parzystą. Sprawdzamy, że tl(s) to też samezera. Z założenia koindukcyjnego wnioskujemy, że strumień samezera składa się z samych liczb parzystych. A zatem strumień samezera składa się tylko z liczb parzystych. Twierdzenie udowodnione. Bałamutny dowód przez ko-indukcję Definicje produktywne Chcemy udowodnić, że strumień samezera składa się wyłącznie z liczb parzystych. Korzystaliśmy z założenia koindukcyjnego, że strumień tl(samezera) = samezera składa się z samych liczb parzystych. Ale w takim razie teza wynika bezpośrednio z założenia koindukcyjnego! Twierdzenie udowodnione!? Nie, ten dowód nie jest produktywny Dowód przez koindukcję, to definicja nieskończonego obiektu zbudowanego z konstruktorów właściwych dla dowodzonego predykatu koindukcyjnego (w tym przypadku krok). Definicja nieskończonego obiektu (np. strumienia) jest produktywna, jeśli definiowany obiekt redukuje się do postaci kanonicznej (z konstruktorem) i wszystkie jego składowe też. Te definicje nie są produktywne: CoFixpoint Bad : CoFixpoint Dab : Stream := Bad. Stream := tl (Cons 0 Dab)

3 Nieproduktywna definicja funkcji F : Stream Stream CoFixpoint F : Stream -> Stream := fun s : Stream => Cons ((hd s)+(hd(tl s))) (F(F(tl(tl(s))))) Czyli po ludzku: F (a :: b :: t) = (a + b :: F 2 (t)). Co jest na drugim miejscu w strumieniu F (0 :: 1 :: 2 :: 3...)? Liczymy: F (0 :: 1 :: 2 :: 3...) = 1 :: F (F (2 :: 3...)) = 1 :: F (2 + 3 :: F 2 (4...)) = 1 :: F (2 + 3 :: F (4 + 5 :: F 2 (6...)) Nie można ewaluować F (2 + 3 :: F 2 (4...)), bo argument nie jest postaci a :: b :: t. Jak zagwarantować produktywność Definicje korekurencyjne w Coqu muszą być strzeżone (guarded). Wywołania rekurencyjne są dozwolone tylko bezpośrednio pod konstruktorem czołowym. Definicja: CoFixpoint F : Stream -> Stream := fun s : Stream => Cons ((hd s)+(hd(tl s))) (F(F(tl(tl(s))))) jest niestrzeżona, bo F występuje pod F. Gdzie drwa rąbią... Ta definicja jest, owszem, produktywna: F (a :: t) = (a + 1 :: F 2 (t)). Ale Coq jej też nie lubi: CoFixpoint F : Stream -> Stream := fun s : Stream => Cons ((hd s)+1) (F(F(tl(s)))). Coq < Error: Recursive definition of F is ill-formed. In environment F : Stream -> Stream s : Stream Nested recursive occurrences. Recursive definition is: "fun s : Stream => Cons (hd s + 1) (F (F (tl s)))". Gdzie drwa rąbią... Ta definicja jest też produktywna i też nie działa: CoFixpoint wszystkieparzyste : Stream := Cons 0 (map (fun x:nat => x+2) wszystkieparzyste). Coq < Error: Recursive definition of wszystkieparzyste is ill-formed. In environment wszystkieparzyste : Stream Unguarded recursive call in "cofix map (f : nat -> nat) (s : Stream) : Stream := Cons (f (hd s)) (map f (tl s))". Recursive definition is: "Cons 0 (map (fun x : nat => x + 2) wszystkieparzyste)". Type constructors Higher-order polymorphism Example: Why is (λzy. y(zi)(zk))(λx. xx) untypable in F? Because types we can assign to I and K differ too much: I : p. p p K : p. p (q p). There is no common pattern for these two types... unless we write it this way: I, K : p. p α(p). Here, α is a type constructor: if p : Type then α(p) : Type. We say that the kind of α is Type Type. Zamiast Type piszemy gwiazdkę. System F ω Kinds: The constant is a kind; If 1 and 2 are kinds then 1 2 is a kind. Constructors: Constructor variables of any kind; Applications ϕ 1 2 ψ 1 : 2 ; Abstractions λα 1 φ 2 : 1 2 ; Function types τ σ : ; Polymorphic types α τ :. Constructor reduction: (λα σ)τ β σ[α := τ]. Type assignment F ω VAR Γ x : σ when Γ(x) = σ APP ABS INST GEN Γ M : σ τ Γ N : σ Γ (M N) : τ Γ(x : σ) M : τ Γ (λx M) : σ τ Γ M : α σ Γ M : nf (σ[α := τ]) Γ M : σ Γ M : α σ α FV(Γ)

4 Example Example Let α :, ϕ : ( ) ( ). Then: K : p (p q p) 2 : α ( p (p α(p)) p (p α(α(p)))) 2 : [ α ( p (p α(p)) p (p (α(α(p))))] [ α ( p (p α(p)) p (p (α(α(α(α(p)))))))] Therefore 22K : p (p q q q q p) Let 1 = λfu. fu and 1 = λvg. gv. The term (λx. z(x1)(x1 ))(λy. yyy) is strongly normalizable, but untypable in F ω 2 : ϕ([ α ( p (p α(p)) p (p ϕ(α)(p)] [ α ( p (p α(p)) p (p (ϕ(ϕ(α))(p))))] Therefore 222K : p (p q q q q p) Properties of F ω Dependent types Every typable term is strongly normalizing. Type-checking and typability problems are undecidable. The inhabitation problem is undecidable. Dependent types System λp Principal idea: Type array[n] depends on n : int. It is created by a type constructor (type family) array : int. Curry-Howard: Constructor P : τ is a predicate on τ. Adding all numbers in an array: Parameterized by n: sum n : array[n] int sum : (n : int) array[n] int sum : n:int. array[n] int Kategorie syntaktyczne: Termy, np. λx z :q. α(z) λy p q v p. x(yv); Typy i konstruktory, np. λx τ. αx p Rodzaje, np. τ σ. Nie ma absolutnej definicji termu, konstruktora, ani rodzaju. Wszystko zależy od otoczenia. Np. to, czy αx jest legalnym typem czy nie, zależy od rodzaju zmiennej α i typu zmiennej x. Surowa składnia ( raw terms ) Alternatywna notacja κ ::= (Πx :φ κ); φ ::= α ( x :φ φ) (φm) (λx :φ φ); M ::= x (MM) (λx :φ M); (x : τ ) κ zamiast Πx:τ. κ; τ κ, gdy x nie jest wolne w κ; (x : τ ) σ zamiast x:τ. σ; τ σ, gdy x nie jest wolne w σ. Γ ::= Γ, (x : φ) Γ, (α : κ).

5 Wiązanie zmiennych Alfa-konwersja FV( ) =, FV(α) = {α}, FV(x) = {x}, FV(EE ) = FV(E) FV(E ), FV( x :φ E) = FV(φ) (FV(E) {x}), gdzie {λ, Π, }. (Zakładamy alfa-konwersję) Niech x : p oraz P : p. Który z tych osądów jest poprawny? Γ (λx:px. x) : x:px. Px? Γ (λx:px. x) : y:px. Px? Po przemianowaniu zmiennych: Γ (λy:px. y) : y:px. Px (czyli Px Px). Ćwiczenie Beta-redukcja Podstawienie E[x := M], gdzie M to surowy term, definiujemy jak zwykle. Nie ma typu x:px. Px, czyli typu y:px. Py. Bo wtedy P : P x. Beta-redukcja: (λx :τ. M)N β M[x := N]; (λx :τ. φ)n β φ[x := N]. Trzy rodzaje osądów Poprawne otoczenie Kind formation judgements of the form Γ κ :, ( κ is a kind in the environment Γ ) Kinding judgements of the form Γ ϕ : κ, ( ϕ is a constructor of kind κ in Γ. ) Typing judgements of the form Γ M : τ, ( M is a term of type τ in Γ. ) Do tego mamy pięć rodzajów reguł. Otoczenie Γ jest ciągiem deklaracji, a nie zbiorem. Poprawne otoczenie: takie, które występuje w jakimś wyprowadzalnym osądzie. Nie każdy ciąg deklaracji jest poprawnym otoczeniem, np. ciąg {α : p, x : p} nie jest, bo najpierw trzeba zadeklarować p :. Można udowodnić taki fakt: Γ jest poprawne wtedy i tylko wtedy, gdy Γ :. Metazmienne w regułach System λp: reguły κ rodzaj; τ, σ typy; ϕ konstruktor; M term obiektowy; x zmienna obiektowa; α zmienna konstruktorowa (typowa).

6 Formowanie rodzajów Rodzajowanie : Γ, x : τ κ : Γ Πx :τ κ : Γ κ : (α Dom(Γ)) Γ, α : κ α : κ Wszystkie rodzaje są postaci Πx 1 : τ 1... x n : τ n., czyli postaci (x 1 : τ 1 ) (x n : τ n ). Ale tu mogą być zależności: (x 1 : τ 1 ) (x 2 : τ 2 (x 1 )) (x 3 : τ 3 (x 1, x 2 )) (x n : τ n (x 1,..., x n 1 )). Γ, x : τ σ : Γ ( x :τ σ) : Γ ϕ : (Πx :τ κ) Γ M : τ Γ (ϕm) : κ[x := M] Γ, x : τ ϕ : κ Γ (λx :τ ϕ) : (Πx :τ κ) Typowanie Osłabianie (generyczne) Γ τ : (x Dom(Γ)) Γ, x : τ x : τ Γ M : ( x :τ σ) Γ N : τ Γ (MN) : σ[x := N] Γ, x : τ M : σ Γ (λx :τ M) : ( x :τ σ) Γ τ : Γ ls : ps Γ, x : τ ls : ps Γ κ : Γ ls : ps Γ, α : κ ls : ps (x Dom(Γ)) (α Dom(Γ)) Konwersja Przykłady Γ ϕ : κ Γ κ : (κ = β κ ) Γ ϕ : κ Γ M : σ Γ σ : (σ = β σ ) Γ M : σ Uwaga: Sprawdzanie typu jest nieelementarne! (Bo taka jest konwersja = β.) Niech Γ = {τ :, α : τ, β : τ }. Term λx z:τ. αz βz λy z:τ. αz λz τ. xz(yz) ma w Γ typ ( x :τ. αx βx) ( x :τ. αx) x :τ. βx. Term λf τ τ λy x:τ. αx α(fx) λx τ λz αx. y(fx)(yxz) ma typ f :τ τ. ( x :τ. αx α(fx)) x :τ. αx α(f 2 (x)). Term λy τ λf Πx:τ α(x) λg α(y) τ. f (g(fy)) ma typ y τ f Πx:τ α(x) g α(y) τ. α(g(f (y))). Wzajemne uwikłanie Poprawność Rodzaje nie występują w termach, konstruktorach i typach, ale: W termach i rodzajach mogą występować konstruktory i typy; W rodzajach, konstruktorach i typach mogą występować termy. Na przykład w rodzaju (x : τ ) α(λx β(y) x) jest term λx β(y) x, a w nim typ β(y). Lemma Jeśli Γ ϕ : κ, to Γ κ :, a jeśli Γ M : τ to Γ τ :. Theorem Jeśli Γ M : σ oraz M β M, to Γ M : σ. Jeśli Γ ϕ : κ oraz ϕ β ϕ, to Γ ϕ : κ. Jeśli Γ κ : oraz κ β κ, to Γ κ :.

7 Wycieranie zależności Wycieranie zależności Wycieranie zależności z konstruktorów i typów: α = α; ( x : τ )σ = τ σ; ϕm = ϕ. Wynikiem jest zawsze typ prosty. Wycieranie zależności z termów: x = x; MN = M N; λx:τ.m = λx:τ.m. Wycieranie zależności z otoczenia: Γ = {(x : τ ) (x : τ ) Γ}. Wycieranie zależności Wycieranie zależności (term : typ) Wycieranie zależności z rodzajów (na razie niepotrzebne): = 0; Π(x : τ )κ = τ κ; Wynikiem jest typ prosty. Fakt: Jeśli Γ M : τ, to Γ M : τ Na przykład: Term λx z:τ. αz βz λy z:τ. αz λz τ. xz(yz) ma typ ( x :τ. αx βx) ( x :τ. αx) x :τ. βx. Jego wytarciem jest S = λx τ α β λy τ α λz τ. xz(yz) typu (τ α β) (τ α) τ β Wycieranie typów System λp à la Curry Wycieranie typów x = x; λx:τ.m = λx M ; MN = M N. Def: Beztypowy term M jest typowalny w λp, gdy istnieją takie Γ, N, τ, że Γ λp N : τ oraz N = M. Fakt: Term M jest typowalny w λp, wtedy i tylko wtedy, gdy jest typowalny w typach prostych. Lemat: M = M. Dowód: Jeśli Γ λp N : τ, to Γ N : τ w typach prostych w stylu Churcha. Zatem Γ N : τ czyli Γ N : τ. Sprawdzanie typu à la Curry Problem inhabitacji dla λp Fakt 1: Term M jest typowalny w λp, wtedy i tylko wtedy, gdy jest typowalny w typach prostych. Fakt: Następujący problem jest nierozstrzygalny: Dane Γ i τ. Czy istnieje taki term N, że Γ λp N : τ? Fakt 2: Następujący problem jest nierozstrzygalny: Dany beztypowy term M oraz Γ i τ. Czy istnieje taki term N, że Γ λp N : τ oraz N = M? Dowód: W systemie λp mieści się intuicjonistyczna logika pierwszego rzędu (dla i, ale to wystarczy).

8 Silna normalizacja Translacja Termy λp przerabiamy na termy Churcha w typach prostych. Twierdzenie: System λp ma własność silnej normalizacji. Dowód: Zrobimy redukcję do typów prostych. Na razie mamy wycieranie zależności. Jeśli Γ M : τ, to Γ M : τ ale to za mało. Zamiast M zrobimy M. x = x; (MN) = M N ; (λx:τ. M) = (λz 0 λx τ. M )τ. O co tu chodzi? Przy tej translacji nie gubią się redeksy wewnątrz typu τ. Translacja Translacja Konstruktory i typy też przerabiamy na termy: α = x α, gdzie x α jest nową zmienną; (ϕm) = ϕ M ; (λx:τ. ϕ) = (λz 0 λx τ. ϕ )τ ; ( x:τ. σ) = yτ (λx τ. σ ), gdzie y : 0 (τ 0) 0 jest nową zmienną. Dla dowolnego Γ definiujemy: Γ + = {x : τ (x : τ ) Γ} {x α : κ (α : κ) Γ} {y ρ : 0 (ρ 0) 0 ρ typ prosty}. Fakt 1: Jeśli Γ ϕ : κ, to Γ + ϕ : κ w typach prostych. Fakt 2: Jeśli Γ M : τ, to Γ + M : τ w typach prostych. Silna normalizacja Fakt 3: If M 1 β M 2 then M 1 + β M 2. Fakt 4: Jeśli ϕ 1 β ϕ 2 to ϕ 1 + β ϕ 2. Twierdzenie: System λp ma własność silnej normalizacji. Dowód: Nieskończona redukcja w λp M 0 β M 1 β M 2 β tłumaczy się na nieskończoną redukcję w λ : M 0 + β M 1 + β M 2 + β