Coqでの基本的なカテゴリー理論の形式化

私はCoqの完全な初心者であり、いくつかのカテゴリー理論のものを演習として実装しようとしています。

私は多くの利用可能なそのような実装（HoTT、AwodeyのCoqコンパニオンなど）のgitリポジトリの中で少しサーフィンしましたが、すべてのプロジェクトがそのようなものを実装しているようです

Record Category : Type :=
  mkCategory{
    ob : Type ;
    mor : ob -> ob -> Type ;
    compose : forall x y z : ob,
                mor x y -> mor y z -> mor x z ;
    identity : forall x, mor x x ;
    (* ... axioms ... *)
  }.

現代の本のカテゴリーのほとんどの定義を考えると、それは自然なことです。ただし、内部的に実装する方が簡単だと思います（誤解しない限り、グロタンディークの当時の一般的な定義でした）。

定義。カテゴリはのデータです

• セット/クラス $\rm Ob$ オブジェクトの
• セット/クラス $\rm Mor$ 射の
• 機能 $s,t \colon {\rm Mor} \to {\rm Ob}$、および $i \colon {\rm Ob} \to {\rm Mor}$ （$s$略で、ソース、$t$以下のためのターゲット、および$i$以下のためのアイデンティティ）
• 機能 $\circ \colon {\rm Mor} \times_{s,t} {\rm Mor} \to {\rm Mor}$ そのドメインはの繊維製品です $${\rm Mor} \stackrel s \to {\rm Ob} \stackrel t \leftarrow {\rm Mor}$$

いくつかの公理を満たす...

このような定義の利点は、「セット/クラス」を「あるカテゴリのオブジェクト」で置き換え、「関数」を「このカテゴリの射」で置き換えることにより直接一般化され、内部カテゴリの概念につながることです。（その後、トポロジー/差分カテゴリ、またはトポス内のカテゴリなどについて話すことができます。）

私の問題は、ファイバー製品をCoqで形式化することです。私の最初の試みは次のようなことをすることです

Record Category : Type :=
  mkCategory{
    ob : Type ;
    mor : Type ;
    s : mor -> ob ;
    t : mor -> ob ;
    compose : mor -> mor -> option mor ;
    i : ob -> mor ;

    adequacy : forall f g : mor, 
                 (exists h, (compose f g) = (some h)) -> (t f = s g) ;
    (* ... axioms ... *)
  }.

しかし、それは後で厄介なコードにつながる可能性があると感じています。たとえば、チェーン構成は読みにくくなります。

内部定義に基づいて実装されたプロジェクトはありますか？Coqで必要な繊維製品をすばやく定義する方法はありますか？

編集。ちなみに、私はたくさん見ます

Ob :> Type

のではなく

Ob : Type

余分な「>」の意味は何ですか？文書から、それはある種の強制であるようです。これはどういう意味ですか？

必要なものを書き留める自然な方法は、コンポジションのタイプを「合成可能な」射だけに制限することです。

$$\mathrm{compose}:\forall f\ g: \mathrm{mor}, t(f) = s(g)\rightarrow \mathrm{mor}$$

もちろん、条件を追加します：

$$s(\mathrm{compose}\ f\ g\ e)=s(f)$$ $$t(\mathrm{compose}\ f\ g\ e)=t(g)$$

これは機能します。これは、現在は構成可能であると証明できる構成関数のみを許可しているためです。これは、お話したカテゴリー理論における繊維製品にほぼ対応しています。

ただし、すべてのアプリケーションに証明義務を追加するため、やや厄介ですcompose、すぐに管理できなくなる可能（関連付けを表現することさえ困難です！）。また、表記法を追加することをやや妨げます$\circ=\mathrm{compose}$、以来 composeは3つの引数を取るです。

これは型理論においてやや一般的な問題であり、部分関数を持つという根本的な緊張から生じます全体言語でを使用するます。

別のエレガントな解決策は、どこでも定義されるように構成を定義することです：

$$\mathrm{compose} :\mathrm{mor}\rightarrow\mathrm{mor}\rightarrow\mathrm{mor}$$ そして、明確に定義された条件で構成を含むすべての定理を守ります：

$$\mathrm{assoc}:\forall f g h:\mathrm{mor}, t(f)=s(g)\wedge t(g)=s(h)\Rightarrow\\ \mathrm{compose}\ f\ (\mathrm{compose}\ g\ h) = \mathrm{compose}\ (\mathrm{compose}\ f\ g)\ h$$ これは基本的に次のことを意味します。

composeはどこでも定義されていますが、定義は合成可能な射に適用される場合にのみ意味があります。

このアプローチには欠点もあります。主に、基本的な公理のすべての適用に従う証拠義務の量が膨大です。

この場合、毒を選択するか、より良い方法を考え出す必要があります...

いくつかの苦労の後、私が望むことを行うための最良の方法は、その普遍的な特性を通じて実際に種類の繊維製品を実際にエンコードすることだと思います。

それはその種の行に沿っています：

Class FiberProduct (A B C : Type) (f : A -> C) (g : B -> C) : Type :=
  {
    FiberProductCarrier : Type ;
    FiberProductProj_1 : FiberProductCarrier -> A ;
    FiberProductProj_2 : FiberProductCarrier -> B ;
    FiberProductCommutativity :
      forall x : FiberProductCarrier,
        f (FiberProductProj_1 x) = g (FiberProductProj_2 x) ;
    FiberProductUniversalExistence :
      forall X : Type, forall (p_1 : X -> A) (p_2 : X -> B),
        (forall x : X, f (p_1 x) = g (p_2 x)) ->
        (exists h : X -> FiberProductCarrier,
           (forall x : X, FiberProductProj_1 (h x) = p_1 x
                          /\ FiberProductProj_2 (h x) = p_2 x)) ;
    FiberProductUniversalUniqueness :
      forall X : Type, forall (p_1 : X -> A) (p_2 : X -> B),
        (forall x : X, f (p_1 x) = g (p_2 x)) ->
        (forall k l : X -> FiberProductCarrier,
           (forall x : X, FiberProductProj_1 (k x) = p_1 x
                          /\ FiberProductProj_2 (k x) = p_2 x
                          /\ FiberProductProj_1 (l x) = p_1 x
                          /\ FiberProductProj_2 (l x) = p_2 x)
           -> k = l)
  }.

次に、カテゴリの概念の内部バージョンは次のように与えられます。

Class InternalCategory : Type :=
  {
    ob : Type ;
    mor : Type ;
    s : mor -> ob ;
    t : mor -> ob ;
    i : ob -> mor ;
    comp_domain : FiberProduct mor mor ob s t ;
    comp : FiberProductCarrier  -> mor  ;
    (* axioms *)
    asso :
      forall fg_h f_gh : FiberProductCarrier,
        (exists fg gh : FiberProductCarrier,
           FiberProductProj_1 fg_h = comp fg /\
           FiberProductProj_2 f_gh = comp gh /\
           FiberProductProj_1 fg = FiberProductProj_1 f_gh /\
           FiberProductProj_2 fg = FiberProductProj_1 gh /\
           FiberProductProj_2 gh = FiberProductProj_2 fg_h) ->
        (comp fg_h = comp f_gh) ;
    id_right :
      forall fid : FiberProductCarrier,
      forall f : mor,
        (FiberProductProj_1 fid = f) ->
        (exists x : ob, FiberProductProj_2 fid = i x) ->
        (comp fid = f) ;
    id_left :
      forall idf : FiberProductCarrier,
      forall f : mor,
        (FiberProductProj_2 idf = f) ->
        (exists x : ob, FiberProductProj_1 idf = i x) ->
        (comp idf = f) ;
    id_s :
      forall x, s (i x) = x ;
    id_t :
      forall x, t (i x) = x          
  }.