es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Buena manera de probar una clase en Coq.

01 Jun, 2023 Programación

¿Existe una buena manera de probar la implementación de una clase en Coq?

Por ejemplo, si tengo la siguiente Clase muy simple:

El teorema chekc_modulo (c: nat): {c mod 2 = 0} + {c mod 2 <> 0} .
Admitido.

Definición update(n: nat):= add n one.

Clase test :={
  f: R -> nat;
  g: R -> nat;
  contando: nat;
  iniciar: contando = zero /\ f 0 = 0 /\ g 0 = 0;
  resultado: para todo t, t >= 0 ->
  coincidir con chekc_modulo contando con
    |left _ => f t = 1 /\ g t = 0 /\ actualizar contando
    |right _ => g t = 1 /\ g t = 0 /\ actualizar contando
  fin
}.

Me gustaría encontrar una manera de probar esta clase, básicamente para verificar que f y g tengan los valores requeridos después de procesar el resultado.

Lo que he hecho hasta ahora: Implementé manualmente f y g dándoles los valores que espero que tengan en un t dado, después de procesar en resultado. Y ahora intento crear una instancia de la Clase test para ver qué sucede con el resultado.

Estoy un poco atascado porque no veo cómo obtener el resultado real y, por lo tanto, cómo verificar que la implementación es correcta.

¿Alguien tiene un consejo? En general, ¿existe una mejor manera de probar el código en Coq, especialmente en Clases?

EDICIÓN:

En mi estrategia de prueba, he definido el comportamiento esperado de f y g:

Definición f': nat -> nat :=
  fun t =>
    coincidir con chekc_modulo t con 
    |left _ => 1
    |right _ => 0
    fin.

Definición g': nat -> nat :=
  fun t =>
    coincidir con chekc_modulo t con 
    |left _ => 0
    |right _ => 1
    fin.

Entonces, el siguiente paso sería verificar que este comportamiento es de hecho el mismo que lo que sucede después de que se procese el resultado.

Tags:  

Answer

  1. Avatar for davy.ai
    davy.ai

    Para probar la implementación de la clase test en Coq, puede crear una instancia de la clase y luego usar el comando Compute para evaluar la salida de f y g. Por ejemplo:

    Instancia test_instance: test := { 
  f := fun r => f' (counting_of r); 
  g := fun r => g' (counting_of r); 
  counting := zero;
  init := conj eq_refl (conj eq_refl eq_refl);
}. 

Compute f test_instance 0.   (* debería dar como resultado 0 *) 
Compute g test_instance 0.   (* debería dar como resultado 0 *)

    Esto crea una instancia de la clase test con contando inicializado en 0, y f y g definidos usando el comportamiento esperado f' y g'. Luego, usamos el comando Compute para evaluar f y g en el momento t=0 y verificar que tienen los valores esperados.

    Este enfoque se puede extender para evaluar f y g en otros momentos y verificar que tengan los valores esperados.

    En general, una buena manera de probar el código Coq es escribir pruebas unitarias usando Compute o el comando Example para evaluar el comportamiento esperado bajo entradas dadas. Además, es posible que desee usar la táctica not de Coq para especificar propiedades que no deberían cumplirse, y luego usar un demostrador de teoremas para verificar que estas propiedades de hecho no se cumplen.

Comments are closed.