coq - sportif - Abstracción láctica sobre un fondo del tipo de meta.

coq traducción

Question

Como fondo áspero y sin tutor, en HoTT , se deduce el diablo del tipo definido inductivamente

Inductive paths {X : Type } : X -> X -> Type :=
| idpath : forall x: X, paths x x.

Lo que permite la construcción muy general.

Lemma transport {X : Type } (P : X -> Type ){ x y : X} (γ : paths x y):
P x -> P y.
Proof.
induction γ.
exact (fun a => a).
Defined.

El Lemma transport estaría en el corazón de las tácticas de "reemplazo" o "reescritura" de HoTT; El truco, por lo que yo entiendo, sería, suponiendo un objetivo que usted o yo podemos reconocer de manera abstracta como

...
H : paths x y
[ Q : (G x) ]
_____________
(G y)

para averiguar cuál es el tipo G dependiente necesario, para que podamos apply (transport GH) . Hasta ahora, todo lo que he descubierto es que

Ltac transport_along γ :=
match (type of γ) with
| ?a ~~> ?b =>
match goal with
|- ?F b => apply (transport F γ)
| _ => idtac "apparently couldn''t abstract" b "from the goal." end
| _ => idtac "Are you sure" γ "is a path?" end.

no es lo suficientemente general Es decir, el primer idtac se usa bastante a menudo.

La pregunta es

[¿Hay un | ¿Qué es lo que hay que hacer ?

Answer 1

Hay un bug sobre el uso de reescritura para las relaciones de tipo, lo que le permitiría simplemente rewrite <- y.

Mientras tanto,

Ltac transport_along γ :=
match (type of γ) with
| ?a ~~> ?b => pattern b; apply (transport _ y)
| _ => idtac "Are you sure" γ "is a path?"
end.

probablemente hace lo que tu quieres

Answer 2

La solicitud de característica mencionada por Tom Prince en su respuesta ha sido concedida:

Require Import Coq.Setoids.Setoid Coq.Classes.CMorphisms.
Inductive paths {X : Type } : X -> X -> Type :=
| idpath : forall x: X, paths x x.
Lemma transport {X : Type } (P : X -> Type ){ x y : X} (γ : paths x y):
P x -> P y.
Proof.
induction γ.
exact (fun a => a).
Defined.
Global Instance paths_Reflexive {A} : Reflexive (@paths A) := idpath.
Global Instance paths_Symmetric {A} : Symmetric (@paths A).
Proof. intros ?? []; constructor. Defined.
Global Instance proper_paths {A} (x : A) : Proper paths x := idpath x.
Global Instance paths_subrelation
(A : Type) (R : crelation A)
{RR : Reflexive R}
: subrelation paths R.
Proof.
intros ?? p.
apply (transport _ p), RR.
Defined.
Global Instance reflexive_paths_dom_reflexive
{B} {R'' : crelation B} {RR'' : Reflexive R''}
{A : Type}
: Reflexive (@paths A ==> R'')%signature.
Proof. intros ??? []; apply RR''. Defined.
Goal forall (x y : nat) G, paths x y -> G x -> G y.
intros x y G H Q.
rewrite <- H.
exact Q.
Qed.

Encontré las instancias necesarias comparando los registros que obtuve con Set Typeclasses Debug de setoid_rewrite <- H cuando H : paths xy y cuando H : eq xy .