Chính thức hóa lý thuyết thể loại cơ bản trong Coq

Tôi hoàn toàn là người mới bắt đầu ở Coq và tôi đang cố gắng thực hiện một số công cụ lý thuyết thể loại như một bài tập.

Tôi lướt một chút trong số các git repos của nhiều triển khai như vậy (HoTT, đồng hành Coq của Awode, v.v.) dường như mỗi dự án đều thực hiện một cái gì đó giống như vậy

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 ... *)
  }.

Đó là loại tự nhiên, xem xét hầu hết định nghĩa của các thể loại trong cuốn sách hiện đại. Tuy nhiên, tôi cảm thấy rằng việc triển khai nội bộ sẽ dễ dàng hơn (nếu không nhầm, đó là định nghĩa phổ biến vào thời của Grothendieck):

Định nghĩa. Một danh mục là dữ liệu của

• một bộ / lớp $\rm Ob$ của các đối tượng,
• một bộ / lớp $\rm Mor$ của hình thái,
• chức năng $s,t \colon {\rm Mor} \to {\rm Ob}$và $i \colon {\rm Ob} \to {\rm Mor}$ ($s$là viết tắt của nguồn ,$t$cho mục tiêu và$i$cho danh tính )
• một chức năng $\circ \colon {\rm Mor} \times_{s,t} {\rm Mor} \to {\rm Mor}$ tên miền là sản phẩm sợi của $${\rm Mor} \stackrel s \to {\rm Ob} \stackrel t \leftarrow {\rm Mor}$$

đáp ứng một số tiên đề ...

Ưu điểm của định nghĩa như vậy là nó khái quát trực tiếp bằng cách thay thế "tập hợp / lớp" bằng "đối tượng của một số loại" và "hàm" bằng "hình thái của thể loại này", dẫn đến khái niệm phạm trù nội bộ . (Sau đó, bạn có thể nói về các loại cấu trúc liên kết / khác biệt hoặc các loại trong một topos, v.v.)

Vấn đề của tôi là chính thức hóa sản phẩm sợi trong Coq. Attemp đầu tiên của tôi sẽ là làm một cái gì đó như

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 ... *)
  }.

Nhưng tôi cảm thấy điều đó có thể dẫn đến một số mã khó hiểu sau này. Ví dụ, các tác phẩm xích sẽ khó đọc.

Có một dự án với việc thực hiện dựa trên định nghĩa nội bộ? Có cách nào nhanh chóng để xác định sản phẩm sợi tôi cần trong Coq không?

Biên tập. Nhân tiện, tôi thấy rất nhiều

Ob :> Type

thay vì

Ob : Type

Ý nghĩa của phần phụ ">" là gì? Từ tài liệu, có vẻ như đó là một kiểu ép buộc . Chính xác điều này có nghĩa là gì?

Một cách tự nhiên để viết ra những gì bạn muốn là hạn chế loại sáng tác chỉ trong các hình thái "có thể tổng hợp":

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

thêm, tất nhiên, các điều kiện:

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

Điều này hoạt động, vì bây giờ nó chỉ cho phép soạn thảo các chức năng có thể tổng hợp được. Điều này gần tương ứng với sản phẩm sợi trong lý thuyết thể loại mà bạn đang đề cập.

Tuy nhiên có phần lúng túng vì nó bổ sung nghĩa vụ bằng chứng cho mọi ứng dụng compose, điều này có thể nhanh chóng trở nên không thể quản lý được (thậm chí thể hiện sự kết hợp là khó!). Ngoài ra, nó phần nào ngăn cản việc thêm ký hiệu$\circ=\mathrm{compose}$, kể từ khi composecó 3 đối số.

Đây là một vấn đề khá phổ biến trong lý thuyết loại, xuất phát từ sự căng thẳng cơ bản của việc có các chức năng một phần trong một ngôn ngữ tổng thể.

Một giải pháp khác, ít thanh lịch hơn, là xác định bố cục ở mọi nơi được xác định :

$$\mathrm{compose} :\mathrm{mor}\rightarrow\mathrm{mor}\rightarrow\mathrm{mor}$$ và bảo vệ mọi định lý liên quan đến thành phần với các điều kiện xác định rõ:

$$\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$$ Điều này về cơ bản có nghĩa là:

composeđược định nghĩa ở mọi nơi, nhưng định nghĩa chỉ có ý nghĩa nếu được áp dụng cho các hình thái tổng hợp.

Cách tiếp cận này cũng có những hạn chế, chủ yếu là số lượng lớn các nghĩa vụ chứng minh tuân theo mọi ứng dụng của các tiên đề cơ bản.

Tôi sợ bạn phải chọn chất độc của mình trong trường hợp này, hoặc đưa ra một cách thông minh để làm tốt hơn ...

Sau một vài lần vật lộn, tôi nghĩ cách tốt nhất để làm những gì tôi muốn là thực sự mã hóa sản phẩm sợi loại thông qua đặc tính phổ quát của nó.

Nó đi dọc theo dòng đó:

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)
  }.

Sau đó, phiên bản nội bộ của khái niệm thể loại được đưa ra bởi:

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          
  }.