Coq 建立乘积的sigma和不相交和之间的同构

我根据不相交和的定义定义了布尔归纳类型：

Inductive Boole :=
  | inlb (a: unit)
  | inrb (b: unit).

给定两种类型的

A

和

B

，我试图证明

sigT (fun x: Boole => prod ((eq x (inrb tt)) -> A) (eq x (inlb tt) -> B))

及

我设法证明了同构的一面

Definition sum_to_sigT {A} {B} (z: A + B) :
  sigT (fun x: Boole => prod ((eq x (inrb tt)) -> A) (eq x (inlb tt) -> B)).
Proof.
case z.
  move=> a.
  exists (inrb tt).
  rewrite //=.
move=> b.
  exists (inlb tt).
  rewrite //=.
Defined.

Lemma eq_inla_inltt (a: unit) : eq (inlb a) (inlb tt).
Proof.
by case a.
Qed.

Lemma eq_inra_inrtt (a: unit) : eq (inrb a) (inrb tt).
Proof.
by case a.
Qed.

Definition sigT_to_sum {A} {B} 
  (w: sigT (fun x: Boole => prod ((eq x (inrb tt)) -> A) (eq x (inlb tt) -> B))) :
  A + B.
Proof.
destruct w.
destruct p.
destruct x.
apply (inr (b (eq_inla_inltt a0))).
apply (inl (a (eq_inra_inrtt b0))).
Defined.

Definition eq_sum_sigT {A} {B} (x: A + B): 
  eq x (sigT_to_sum (sum_to_sigT x)).
Proof.
by case x.
Defined.

但我在证明另一方时遇到了麻烦，基本上是因为我无法在以下证明中涉及的不同

x

和

p

之间建立相等性：

Definition eq_sigT_sum {A} {B} 
  (y: sigT (fun x: Boole => prod ((eq x (inrb tt)) -> A) (eq x (inlb tt) -> B))) : eq y (sum_to_sigT (sigT_to_sum y)).
Proof.
case: (sum_to_sigT (sigT_to_sum y)).
  move=> x p.
  destruct y.
  destruct x.
  destruct p.
Defined.

有人知道我如何证明后一个引理吗

---

谢谢你的帮助。

这听起来很奇怪，但你无法用柯克的理论来证明这个结果

让我们调用类型

sigT（funx=>prod（eq x（inrb tt）->A）（eq x（inlb tt）->B））

就是

T

。

T

的任何元素的形式都是

existT x（对fg）

，其中

x:Boole

，

f:eq x（inrb tt）->A

，和

g:eq x（inlb tt）->B

。为了显示您的结果，您需要论证两个

T

类型的表达式是相等的，这需要在某一点上证明

f1

和

f2

类型

eq x（inrb tt）->A

的两个术语是相等的

问题在于

eq x（inrb tt）->A

的元素是函数：它们将

x

和

inrb tt

相等的证明作为输入，并由此产生

A

类型的项。可悲的是，Coq中函数相等的概念太弱，在大多数情况下都没有用处。通常在数学中，我们认为两个函数是相等的，因为它们产生相同的结果，即：

forall f g : A -> B,
  (forall x : A, f x = g x) -> f = g.

这一原则通常被称为函数扩展性，默认情况下在Coq中不可用。幸运的是，该理论允许我们安全地将其作为一条公理添加，而不会损害该理论的可靠性。我们甚至可以在标准库中找到它。我在这里提供了一个稍微修改过的结果的证明。（我已经冒昧地使用了ssreflect库，因为我看到您也在使用它。）

---

非常感谢你。所以，即使修改你的

Sum'

的定义，也无法证明这个结果？太可悲了！谢谢你的证明，我对Coq还是个新手，我会努力的！对的唯一的方法是假设函数的可扩展性，或者类似的公理。

forall f g : A -> B,
  (forall x : A, f x = g x) -> f = g.

From mathcomp Require Import ssreflect ssrfun ssrbool eqtype.

Require Import Coq.Logic.FunctionalExtensionality.

Section Iso.

Variables A B : Type.

Inductive sum' :=
| Sum' x of x = true -> A & x = false -> B.

Definition sum'_of_sum (x : A + B) :=
  match x with
  | inl a =>
    Sum' true
         (fun _ => a)
         (fun e : true = false =>
            match e in _ = c return if c then A else B with
            | erefl => a
            end)
  | inr b =>
    Sum' false
         (fun e =>
            match e in _ = c return if c then A else B with
            | erefl => b
            end)
         (fun _ => b)
  end.

Definition sum_of_sum' (x : sum') : A + B :=
  let: Sum' b f g := x in
  match b return (b = true -> A) -> (b = false -> B) -> A + B with
  | true => fun f _ => inl (f erefl)
  | false => fun _ g => inr (g erefl)
  end f g.

Lemma sum_of_sum'K : cancel sum_of_sum' sum'_of_sum.
Proof.
case=> [[]] /= f g; congr Sum'; apply: functional_extensionality => x //;
by rewrite (eq_axiomK x).
Qed.

End Iso.