tppsfverificación de programas funcionales - 1 7. verificación de programas funcionales

TPPSF Verificación de programas funcionales - 1

7. Verificación de

programas funcionales


Especificación de programas

iInput. (i) oOutput. (i,o)

donde Input y Output son tipos de datos y es la proposición que expresa la relación que debe cumplirse entre el valor de entrada y el valor de salida

En general: i1Input1... i nInputn. (i1... in) oOutput. (i1,...,in,o)

Ejemplo:

Para todos a,b N tq. b0 existen q y r tq. a=b.q+r y r < b.

(a,b N ) b0 (q,r) NN. a=b.q+r r < b


Especificaciones en Coq

En Coq:

(i1:Input1)... (i n:Inputn) (i1... in) {o:Output | (i1,...,in,o) }

Ejemplos:– (a,b:nat) b0 { qr: N*N | Cases qr of

(q,r) => a=b.q+r r < b

end }

– ¿Especificación de la función que ordena una lista? (l:list) { l’: list | (sorted l’) (perm l l’) }


Extracción de programas

Si la prueba del existencial

iInput. (i) {oOutput | (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



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.

• Se extrae hacia Fw, un lenguaje de programación no dependiente.

• Las dependencias en los objetos computacionales se olvidan. [Paulin-Mohring 89]



Dada una prueba

P : iInput. (i) { oOutput | (i,o) }

el contenido computacional de P será una función

fP: 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


Existenciales en Coq con contenido computacional

Inductive sig [A:Set, P:A Prop ] : Set

:= exist : (x:A) (P x) (sig A P).

Inductive sig2 [A:Set, P,Q:A Prop ] : Set

:= exist2 : (x:A) (P x) (Q x) (sig2 A P Q).

Inductive sigS [A:Set, P:A Set ] : Set

:= existS : (x:A) (P x) (sigS A P).

Inductive sigS2 [A:Set, P,Q:A Set ] : Set

:= existS: (x:A) (P x) (Q x) (sigS2 A P Q).

{ x : T | (x) }

{ x : T | (x) & (x) }

{ x : T & (x) }

{ x : T & (x) & (x) }


Existenciales en Coq sin contenido computacional

Inductive ex [A:Set, P:A Prop ] : Prop

:= ex_intro : (x:A) (P x) (ex A P).(EX x : T | (x) )

Inductive ex2 [A:Set, P,Q:A Prop ] : Prop

:= ex2_intro : (x:A) (P x) (Q x) (ex2 A P).

(EX x : T | (x) & (x) )


Sumas en Coq

Inductive sumbool [A, B: Prop ] : Set

:= left : A (sumbool A B)

| right : B (sumbool A B)

{ }+{ }

Inductive sumor [A:Set, B: Prop ] : Set

:= left : A (sumor A B)

| right : B (sumor A B)

+{ }

Inductive or [A, B: Prop ] : Prop

:= or_introl : A (or A B)

| or_intror : B (or A B)


Mecanismo de extracción en Coq

• Extracción del programa Fw

Extract lema_de_corrección

• Extracción a un lenguaje de programación (Ocaml, CamlLight, Haskell):

Require Extraction

Write lenguaje File “nombrefile” [ id1 ... Idn ]

Extract Constant idcoq idleng

Extract Inductive typecoq typeleng [c1ml... cnleng ]

Link parameterIdcoq := parameterValuecoq


Mecanismo de extracción (síntesis)

• Metodología para obtener programas correctos:– especificar en Coq el programa como un lema– extraer el programa de la prueba del lema

• Desventaja de esta metodología:– la estructura del programa está oculta en el término de

prueba hasta el final del proceso– dificultad de lectura del programa final– dificultad para optimizar el programa

Quisiéramos verificar programasverificar programas más que sintentizarlos


Verificación de programas

Es el proceso inverso al de extracción

P: Spec

Programa

Programa Spec

P:Spec

fP


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.

• La síntesis de esta información no es automática (a excepción de casos sencillos).

• Para simpilficar el proceso de verificación los programas pueden tener anotaciones lógicas, que son directivas que guían la síntesis.


Ejemplo: División

Sean a y b N, b0.

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-1then <q,r+1>else <q+1,0>


División: especificación

• Especificación: Para todos a,b N tq. b0 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>

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

0 = b.0 + 0 y 0 < b


Verificación de programas en Coq - Tácticas -

• Realizer term– term puede ser una constante de Coq o un programa

escrito en el lenguaje Real

• Program

• Program_all


Pruebas de Terminación

• Si el programa no es recursivo el programa termina de forma trivial.

• Si el programa es recursivo hay que justificar:– que los llamados recursivos decrecen según

cierto orden R– que la relación R es bien fundada (o sea que no

existen cadenas descendentes infinitas).

• En general, el programa debe tener como anotación la relación R con la cual hay que comparar los llamados recursivos


Pruebas de buena fundación

Ciertos órdenes pueden obtenerse de a través de operadores de composición de relaciones que garantizan que si las relaciones iniciales son bien fundadas, el resultado de la composición también lo es [Paulson86].

Ejemplo típico de orden bien fundado: < NxN


Operadores de buena fundación

Subrelación :

Si R AxA es bien fundada y R´ R

entonces R´ es bien fundada

Imagen Inversa:

Sean– f : A B – R BxB bien fundada

Definimos– R* AxA como x R*y ssi f (x) R f(y)

entonces R* es bien fundada



Clausura transitiva

Si R AxA es bien fundada, entonces R+ AxA tal que

x R+y ssi ( xRy zA tq. xRz zR+y )

es bien fundada

Suma disjunta

Si RA AxA es bien fundada y RB BxB es bien fundada entonces RA+B (A+B) x (A+B) tal que a RA+B

b ssi ( a,b A y aRAb a,b B y aRBb )

es bien fundada



Producto Lexicográfico

Si RA AxA es bien fundada y RB BxB es bien fundada entonces RALexB (AxB) x (AxB) tal que (a,b) RALexB

(a’,b’) ssi ( aRAa’ a=a’ bRBb’ )

es bien fundada

Nota: el producto lexicográfico se generaliza para el caso en elque B es una familia de tipos indizada por A (o sea B: ASet).

En ese caso el orden RALexB x:A B(x) x x:A B(x)Este producto general es el que está definido en Coq.



Exponenciación lexicográfica

Sea W el conjunto de secuencias de elementos de A,

para todo a1...anW definimos

Dec(a1...an) ssi a1RAa2... An-1RAan

Si RA AxA es bien fundada entonces

RLexExp ( x:A Dec(x) x x:A Dec(x) )

tal que

(a,da) RLexExp (b,db) ssi aRAb

es bien fundada


Operadores de buena fundación en Coq

• En las bibliotecas se encuentran:

– Ordenes de base bien fundados • por ejemplo lt en nat está en theories\ARITH\Wf_nat

– Operadores para construir órdenes bien fundados• theories\RELATIONS\WELLFOUNDED (con la prueba

respectiva de que construyen órdenes bien fundados)


BibliografíaExtracción y síntesis de Programas en Coq:• [Paulin-Mohring&Werner] Synthesis of ML programs in the system Coq. Journal of

symbolic Computation 15:607- 640, 1993.

• [Paulin-Mohring 89] Extracting Fw´s programs from proofs in the Calculus of Constructions. Sixteenth anual ACM Symposium on Principles of programming Languages, pgs. 32-49. Austin, 1999.

• [Parent94] Developing certified programs in the system Coq. In H. Barendregt and T. Nipkow, eds, Types for Proofs and Programs, LNCS nr. 806, pages 291-312.

Otros enfoques• [Berardi 96] Pruning simply typed lambda-terms. Journal of Logic and

Computation 6(5)663-681, 1996.

• [Poll 94] A programming logic based on type theory. Ph.D. Thesis, Eindhoven University of Thechnology, 1994

• [Szasz 97] A theory of specifications programs and proofs. Ph.D. Thesis, Chalmers University of Thechnology, 1997

Ordenes bien fundados

• [Paulson86] Constructing Recursion Operators in Intuitionistic Type Theory. J. Symbolic Computation Vol2, 325-355, 1986.


Apéndice

• El módulo ARITH de Coq permite escribir naturales con la sintaxis usual a condición poner los naturales entre paréntesis ( ) . Ejemplo: (2) en lugar de (S (S O)).

• El módulo Omega de Coq permite trabajar con expresiones aritméticas enteras en sintaxis usual a condición de escribirlas entre comillas simples invertidas` `. Ejemplo `x+x <= 2*x`. Con este módulo la táctica Omega resuelve en forma automática las metas de la aritmética de Presburger.

tppsfverificación de programas funcionales - 1 7. verificación de programas funcionales

Documents