Construcción Formal de Programas en Teoría de Tipos. Introducción a Coq

Transcripción

1 Construcción Formal de Programas en Teoría de Tipos Introducción a Coq Grupo de Métodos Formales Instituto de Computación Facultad de Ingeniería Universidad de la República Escuela Río 2014, Río Cuarto, Argentina

2 Sean a y b N, b 0. Motivación Ejemplo: División Calculamos a div b y a mod b simultáneamente haciendo recursión en a: 0 divmodb = <0,0> (n+1) divmod b = let <q,r> = n divmod b in if r < b-1 then <q,r+1> else <q+1,0>

3 División: especificación y prueba Especificación: Para todos a,b N tq. b 0 existen q y r tq. a=b.q+r y r < b. Prueba de que el programa es correcto: por inducción en a: 0 divmodb = <0,0> (n+1) divmod b = let <q,r> = n divmod b in if r < b-1 then <q,r+1> else <q+1,0> 0 = b y 0 < b supongamos n = b.q+r y r < b luego, si r < b - 1 entonces n+1 = b.q+(r+1) y r+1<b sino n+1 = b.(q+1)+0 y 0<b

4 Coq El asistente de pruebas Coq es un entorno que permite trabajar formalmente con sentencias matemáticas. Permite la definición de: - objetos (enteros, listas, árboles, funciones, programas ) - fórmulas (usando predicados básicos, conectivos y cuantificadores) - pruebas (lemas, teoremas) El compilador de Coq automáticamente chequea la corrección de las definiciones (conjuntos/tipos bien formados, terminación de las funciones) y de las pruebas.

5 Coq El sistema Coq permite trabajar con: bibliotecas, notaciones avanzadas, desarrollos modulares... También provee un mecanismo de extracción de programas hacia lenguajes funcionales (Ocaml, Haskell). Aplicaciones de Coq incluyen (entre otras): - formalización de semánticas de lenguajes de programación (certificación del compilador de CompCert, certificación a nivel EAL7 de Java Card); - diseño de plataformas especiales para la verificación de software (Certycript); - formalización de matemáticas (el teorema de los 4 colores); Más información en: coq.inria.fr

6 Lenguaje Lógico Lógica como herramienta para especificar y probar corrección de programas

7 Cálculo de predicados Sintaxis Términos símbolos de variable pueden ser variables de individuo, predicado o función un símbolo de variable tiene asociado un dominio símbolos de constante símbolos de función Fórmulas variables de predicados (unarios, binarios, etc) conectivos:,,,, ~, cuantificadores:, Semántica Noción de verdad: existencia de una prueba (lógica constructivista)

8 Conectivos en Coq Prop es la familia de proposiciones Declaración de variables de proposición: Conectivos: Variable A B C: Prop,,, son primitivos (/\, \/,->, False) ~ y son definidos: ~α := (α ) α β := (α β) (β α)

9 Cálculo de predicados - orden Cálculo de predicados de primer orden: Cuantificación sobre variables de individuos únicamente : x nat. x=x Cálculo de predicados de orden superior: Cuantificación sobre variables de individuos, función y predicados P. P 0 ( x. P x P (S x)) x. P x f. g. ( x. f(x) = g(x) f = g)

10 Cálculo de predicados en Coq -Variables- Cada símbolo de variable o constante tiene asociado su dominio y Set es la clase de todos los dominios nat : Set Z : Set (nat es dominio) (Z es un dominio) 0 : nat (0 es un elemento del dominio nat) f : nat nat (f es una función unaria de naturales en naturales) g : nat nat nat (g es una función binaria entre naturales currificación )

11 Cálculo de predicados en Coq -Predicados- Un predicado se representa como una función proposicional sobre cierto dominio La aridad del predicado está dada por la cantidad de argumentos de la función P : nat Prop (P es un predicado unario sobre naturales) Q : nat (nat nat) Prop (Q es un predicado binario entre naturales y funciones de naturales en naturales)

12 Notación: Cálculo de predicados en Coq -Cuantificadores- ( x U) α se escribe en Coq forall x:u, α ( x U) α se escribe en Coq exists x:u, α Ejemplos: forall P: nat Prop, P 0 (forall x:nat, P x P (S x)) forall x:nat, P x forall f g: nat nat, (forall x:nat, f x = g x) f = g

13 Más ejemplos Considerando las declaraciones: 0 : nat S : nat nat Le : nat nat Prop Min : nat (nat nat) Prop Algunas fórmulas del cálculo de predicados: Le 0 (S 0) ~(Le (S 0) 0) exists x:nat, Min x S forall (f:nat nat)(m x : nat), Le m (f x) Min m f

14 Construcción de pruebas en Coq Para comenzar: Queremos probar cierta fórmula objetivo (goal) Para ello, utilizaremos diferentes tácticas que transforman al objetivo original e introducen hipótesis adicionales

15 Desarrollo de pruebas lógicas Situación general: existen varios objetivos a probar, cada uno a partir de ciertas hipótesis: donde: Γ 1 Γ 2 Γ n 2 α 1 α 2... secuentes α n cada Γ i es un conjunto de fórmulas (hipótesis) de la forma: H0: γ 0, H1: γ 1,... Hk: γ k. α i es una fórmula cada α i debe ser probada a partir de Γ i

16 Tácticas = Reglas de inferencia Unatáctica transforma un secuente de la forma: Γ i en cero o más secuentes: α i Γ Γ Γ Γ i 1 α i 1 Γ i 2 α i 2... Γ i n α i n tales que probar los últimos es suficiente para construir una prueba del secuente original.

17 Prueba completa = Árbol α Goal inicial Γ 1 Γ 2 α 1 α 2 Subgoals Γ 11 α 11 Γ 12 α 12 Γ 1n α 1n Γ 21 α

18 Tácticas caso trivial Γ H: α α assumption Probado!

19 Tácticas Reglas de introducción introducción Γ α β intro H Γ H: α β variantes: intros, intros H 1...H n

20 Tácticas Cuantificador universal introducción Γ forall x:α, β intro x Γ x: α β el identificador x es opcional variantes: intros, intros x 1,...x n

21 Tácticas Reglas de eliminación eliminación Γ H: α β β apply H Γ H: α β α en general: Γ H: α 1 α 2... β β apply H Γ H:... α 1 Γ H:... α 2...

22 Tácticas Cuantificador universal eliminación Γ H: forall x:α, γ β apply H Probado! Si existe a:α tal que β= γ[x:=a]

23 introducción Tácticas Cuantificador existencial Γ exists x:u, α(x) exists t Γ α(t) eliminación Γ H: exists x:u, α(x) β elim H donde t:u (witness) Γ H: exists x:u, α(x) forall y: U, α(y) β donde y es una variable nueva que no ocurre en β

24 Ejemplo 1 Variable A B: Prop. Lemma L1: A -> B -> A. Proof. intros H1 H2. assumption. Qed.

25 Ejemplo 2 Variable U: Set. Variable P Q: U -> Prop. Lemma L2 : (forall x:u, P x -> Q x) -> (forall y:u, P y) -> forall z:u, Q z. Proof. intros H1 H2 z. apply H1. apply H2. Qed.

26 Lenguaje de Programación Cálculo de Construcciones

27 Cálculo λ simplemente tipado Sintaxis Términos Tipos e ::= x λx.e (e 1 e 2 ) c α ::= t α 1 α 2 x Var c Const t TConst Contextos Γ ::= x 1 :α 1... x n :α n (n 0)

28 Sistema de tipos Juicios de la forma: Γ - e: α la expresión e tiene tipo α bajo el contexto Γ Reglas: x:α Γ Γ - x:α ctx Γ, x:α - e: β Γ - λx.e: α β abs Γ - e 1 :α β Γ - e 2 : α Γ - (e 1 e 2 ): β app

29 Cálculo λ simplemente tipado en Coq Constantes de tipo: nat, bool, etc. Las abstracciones se escriben con: fun... =>... El tipo de las variables aparece en las abstracciones: fun x: nat => x : nat nat fun x: bool => x : bool bool fun (f:nat bool)(x:nat) => f x : bool fun (g:nat nat bool)(n:nat) => g n : nat bool

30 Polimorfismo paramétrico En los lenguajes funcionales (ML, Haskell) escribimos: λx. x : α α Variable de tipo!! En Coq, abstraemos el tipo. Los tipos de datos pertenecen a la clase Set: fun (X:Set)(x:X) => x : forall X:Set, X X Abstrayendo en la clase Set se obtiene polimorfismo paramétrico

31 Tipos dependientes Polimorfismo paramétrico = abstraer variables de tipo (de Set). En forma más general: podemos abstraer variables de cualquier tipo. Tipos dependientes Tipos dependientes: un tipo puede depender no solo de otro tipo, sino también de un objeto de cierto tipo.

32 Array: Set nat Set (Array bool 3) Tipos dependientes Ejemplo zip: forall (A B:Set)(k:nat), (Array A k) (Array B k) Array (A*B) k

33 Lenguaje de Programación de Coq Es un lambda cálculo tipado con las siguientes características: es de orden superior permite definir funciones paramétricas tiene tipos dependientes permite definir tipos inductivos permite definir tipos coinductivos CC CCI CCI Cálculo de Construcciones (CC) Cálculo de Construcciones Inductivas = CC + tipos inductivos (CCI) Cálculo de Construcciones Inductivas y Coinductivos = CCI + tipos coinductivos (CCI )

34 Cálculo de Construcciones (Co)Inductivas Inducción y Recursión

35 Tipos Inductivos Inductive bool : Set := true : bool false : bool Inductive nat : Set := 0 : nat S : nat nat

36 Tipos Inductivos Paramétricos Parámetros: son los argumentos que estan fijos y son globales en toda una definición. Inductive list (A:Set) : Set := nil : list A cons : A list A list A

37 Familias Inductivas de Tipos Inductive array (A:Set) : nat Set := empty : array A 0 add : forall n:nat, A array A n array A (S n) Cómo podría definirse una familia inductiva para matrices? Inductive matrix (A:Set) : nat nat Set :=

38 Familias Mutuamente Inductivas Inductive with tree (A:Set) : Set := node: A forest A tree A forest (A:Set) : Set := empty_f : forest A add_tree: tree A forest A forest A

39 Predicados Inductivos Inductive Le : nat nat Prop := le0 : forall n:nat, Le 0 n les : forall n m:nat, Le n m Le (S n) (S m) Inductive Mem (A : Set) (a : A) : list A -> Prop := here : forall x : list A, Mem A a (cons A a x) there : forall x : list A, Mem A a x -> forall b : A, Mem A a (cons A b x) Qué especifica Mem?

40 Definiciones Inductivas - Significado Cuando escribimos: Inductive nat : Set := 0 : nat S : nat nat estamos haciendo muchas cosas estamos definiendo un conjunto y una manera de construir objetos en él. estamos diciendo que ésta es la única forma de construir los objetos del conjunto. estamos diciendo, además, que las dadas son formas distintas de construir objetos.

41 Consecuencias del significado de una Definición Inductiva (I) Análisis de casos: fun n:nat => match n with 0 true S m false end.

42 Recursión: Consecuencias del significado de una Definición Inductiva (II) Fixpoint F (n m:nat) {struct n}: nat := match n with 0 m S k S (F k m) end. Qué calcula F?

43 Consecuencias del significado de una Definición Inductiva (III) Análisis de casos: Γ Γ Γ case n n: nat P n P 0 forall x:nat, P (S x)

44 Inducción: Consecuencias del significado de una Definición Inductiva (IV) Γ Γ Γ n: nat elim n n:nat n:nat P n P 0 forall x:nat, P x P (S x)

45 Set Implict Arguments. Ejemplos Fixpoint append (A:Set) (l1 l2:list A) {struct l1} : list A := match l1 with nil => l2 cons x l1 => cons x (append l1 l2) end. Fixpoint filter (A:Set) (P:A->bool) (l:list A) {struct l} : (list A) := match l with nil => nil cons x l => match (P x) with true => cons x (filter P l ) false => filter P l end end. Lemma append_filter: forall (A:Set) (l1 l2 : list A) (P: A -> bool), filter P (append l1 l2) = append (filter P l1) (filter P l2). Cómo sería la prueba del lema?

46 Definiciones Coinductivas Listas infinitas: CoInductive Stream (A:Set) : Set := Cons : A Stream A Stream A. Funciones Corecursivas Pruebas Coinductivas

47 Ejemplos Set Implict Arguments. Definition head (A:Set)(s : Stream A) := match s with Cons a s => a end. Definition tail (A : Set)(s : Stream A) := match s with Cons a s => s end. CoFixpoint repeat (A:Set)(a:A) : Stream A := Cons a (repeat a). CoInductive EqSt (A: Set) : Stream A -> Stream A -> Prop := eqst : forall s1 s2: Stream A, head s1 = head s2 -> EqSt (tail s1) (tail s2) -> EqSt s1 s2.

48 Más ejemplos CoFixpoint iterate (A:Set)(f:A -> A)(a:A) : Stream A:= Cons a (iterate f (f a)). CoFixpoint map (A B:Set)(f:A -> B)(s:Stream A) : Stream B:= match s with Cons a tl => Cons (f a) (map f tl) end. Lemma map_iterate : forall (a:set)(f:a -> A)(x:A), EqSt (iterate f (f x)) (map f (iterate f x)).

49 Relación entre Pruebas y Programas Isomorfismo de Curry-Howard

50 Construcción de pruebas en Coq Qué estamos haciendo cuando probamos un teorema en Coq? Construimos un objeto, que es la prueba del teorema En qué lenguaje está escrita esa prueba? En Cálculo Lambda!!!! Cada enunciado lógico se corresponde con un tipo Cada prueba es un objeto del tipo correspondiente

51 Isomorfismo de Curry-Howard Identificación de proposiciones con tipos P : Prop pensamos a P como el tipo cuyos objetos son las pruebas de P Identificación de pruebas con objetos a : P significa que a es una prueba de P

52 Isomorfismo en Coq Cuando constuimos una prueba de un enunciado en Coq, estamos construyendo un término λ del tipo correspondiente al enunciado. La situación general es de la forma: Γ 1 Γ n? 1 : α 1? n : α n Tácticas: constructoras de términos

53 Construcción de pruebas en Coq Γ H: α?: α assumption: corresponde a la prueba H:α Γ intro H:?: α β corresponde a la prueba [H:α]? 1 donde? 1 será la prueba de β corresp. a: Γ H: α? 1 : β Γ H: α β?: β apply H: corresponde a la prueba (H? 1 ) donde? 1 será la prueba de α corresp. a: Γ H:α β? 1 : α

54 Verificación de Programas Funcionales

55 Especificación de programas i Input. ψ(i) o Output. ϕ(i,o) donde Input y Output son tipos de datos, ψ es una proposición que expresa cierta condición que debe cumplir el valor de entrada (precondición) y ϕ es la proposición que expresa la relación que debe cumplirse entre el valor de entrada y el valor de salida (poscondición) Ejemplo: Para todos a,b N tq. b 0 existen q y r tq. a=b.q+r y r < b. ( a,b N ) b 0 (q,r) N N. a=b.q+r r < b

56 Extracción de programas Si la prueba del existencial i Input. ψ(i) { o Output ϕ(i,o) } es constructiva, el programa que calcula el resultado a partir de la entrada se encuentra necesariamente embebido en la prueba. Qué diferencia el programa de la prueba? La prueba es el programa más la información lógica necesaria para demostrar la especificación Para obtener el programa hay que extraer de la prueba la información computacional y olvidar la información lógica

57 Extracción de programas Información computacional : objetos que viven en Set Información lógica : objetos que viven en Prop Mecanismo de extracción : Recorre el término de prueba recuperando los datos que viven en Set, olvidando los que viven en Prop y manteniendo la estructura. Originalmente se extrae hacia Fw, un lenguaje de programación no dependiente. Las dependencias en los objetos computacionales se olvidan. [Paulin-Mohring 89]

58 Extracción de programas Dada una prueba p : i Input. ψ(i) { o Output ϕ(i,o) } el contenido computacional de p será una función f p : Input Output Para ello deberá ocurrir que : Input : Set Output : Set ψ(i), ϕ(i,o) : Prop Observar que los sorts de los tipos que intervienen en la especificación indican al procedimiento de extracción qué recorrer y qué olvidar durante la recorrida

59 Verificación de programas Es el proceso inverso al de extracción P: Spec : Spec fp Programa Programa Spec : Spec P:Spec

60 Verificación de programas Dado el programa y la especificación hay que probar que el programa cumple con la especificación: justificar la terminación del programa probar los objetivos ligados con la especificación particular.

61 Sean a y b N, b 0. Ejemplo: División Calculamos a div b y a mod b simultáneamente haciendo recursión en a: 0 divmod b = (0,0) (n+1) divmod b = let (q,r) = n divmod b in if r < b-1 then (q,r+1) else (q+1,0)

62 División: extracción, verificación Especificación: Para todos a,b N tq. b 0 existen q y r tq. a=b.q+r y r < b. Prueba de que el programa es correcto: por inducción en a: 0 divmod b = <0,0> (n+1) divmod b = let (q,r) := n divmod b in if r < b-1 then (q,r+1) else (q+1,0) 0 = b y 0 < b supongamos n = b.q+r y r < b. luego, si r < b - 1 entonces n+1 = b.q+(r+1) y r+1 < b sino n+1 = b.(q+1)+0 y 0 < b

63 Muchas gracias! Más información en: - coq.inria.fr - fing.edu.uy/inco/grupos/mf/tppsf