Vraag Ltac-tically abstracting over een subterm van het doelsoort


Als een ruige en onaangemaakte achtergrond, in HoTT, men leidt heck uit het inductief gedefinieerde type

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

wat de zeer algemene constructie mogelijk maakt

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

De Lemma transport  zou de kern zijn van de "vervang" of "herschrijf" tactieken van HoTT; de truc, voor zover ik het begrijp, zou zijn, veronderstel een doel dat jij of ik abstracts kan herkennen als

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

om uit te zoeken wat het benodigde afhankelijke type G is, zodat we dat kunnen apply (transport G H). Tot nu toe is het enige wat ik heb bedacht dat

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.

is niet algemeen genoeg. Dat is de eerste idtac wordt vrij vaak gebruikt.

De vraag is

[Is er een | wat is de] Het juiste om te doen?


16
2018-01-26 04:50


oorsprong


antwoorden:


Er is een kever over het gebruik van rewrite voor relaties in type, wat je zou toestaan ​​om gewoon te zeggen rewrite <- y. 

In de tussentijd,

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

doet waarschijnlijk wat je wilt.


5
2018-02-22 03:21



Het functieverzoek vermeld door Tom Prince in zijn antwoord Is toegekend:

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.

Ik vond de vereiste exemplaren door de logboeken te vergelijken die ik heb gekregen Set Typeclasses Debug van setoid_rewrite <- H wanneer H : paths x y en wanneer H : eq x y.


1
2017-09-29 18:46