PTS / CoC'de Kilise kodlu türe göre bağımlı tipler

Barendregt'in lambda küpündeki saf tip sistemleri, özellikle en güçlü olanı olan İnşaat Analizini deniyorum. Bu sistemin çeşitleri *ve BOX. Sadece kayıt için, aşağıda klasik lambda hesabına yakın olan https://github.com/Gabriel439/Haskell-Morte-LibraryMorte aracının somut sözdizimini kullanıyorum .

Endüktif türleri bir çeşit Kilise benzeri kodlamayla (cebirsel veri türleri için Boehm-Berarducci izomorfizmi olarak) taklit edebileceğimizi görüyorum. Basit bir örnek için tür Bool = ∀(t : *) -> t -> t -> tyapıcıları True = λ(t : *) -> λ(x : t) -> λ(y : t) -> xile yazın False = λ(t : *) -> λ(x : t) -> λ(y : t) -> y.

Terim düzeyindeki işlevlerin Bool -> Ttürünün , aslında özdeş olan işlev aracılığıyla Product T Tklasik Product = λ(A : *) -> λ(B : *) -> ∀(t : *) -> (A -> B -> t) -> tmodulo parametrikliği olan tip çiftlerine izomorfik olduğunu görüyorum if : Bool -> λ(t : *) -> t -> t -> t.

Aşağıdaki tüm sorular bağımlı türlerin temsili ile ilgili olacaktır Bool -> *.

Ben ayırabilir D : Bool -> *çifti içine D Trueve D False. DTekrar yaratmanın kanonik yolu var mı? İzomosfizmi tür düzeyinde bir Bool -> T = Product T Tişlev analogu ile çoğaltmak istiyorum ifancak bu işlevi orijinal kadar basit yazamıyorum ifçünkü türler gibi argümanlarda tür iletemiyoruz .

Soruyu çözmek için iki türden bir tür endüktif tip kullanıyorum (1). Üst düzey açıklama (Agda stili) aşağıdaki türdür (tür düzeyi yerine kullanılır if)

data BoolDep (T : *) (F : *) : Bool -> * where
  DepTrue : T -> BoolDep T F True
  DepFalse : F -> BoolDep T F False

PTS / CoC'de aşağıdaki kodlamayla:

λ(T : *) -> λ(F : *) -> λ(bool : Bool ) ->
∀(P : Bool -> *) ->
∀(DepTrue : T -> P True ) ->
∀(DepFalse : F -> P False ) ->
P bool

Yukarıdaki kodlamam doğru mu?

Ben BoolDepbu kod gibi için yapıcılar yazabilirsiniz DepTrue : ∀(T : *) -> ∀(F : *) -> T -> BoolDep T F True:

λ(T : *) ->  λ(F : *) ->  λ(arg : T ) ->
λ(P : Bool -> *) ->
λ(DepTrue : T -> P True ) ->
λ(DepFalse : F -> P False ) ->
DepTrue arg

ancak ters fonksiyonu (veya ters yönde herhangi bir fonksiyonu) yazamıyorum. Mümkün mü? Yoksa BoolDepbir izomorfizm üretmek için başka bir gösterim BoolDep T F True = Tmi kullanmalıyım?

type-theory type-systems dependent-type

— Zeitraffer
kaynak

Product T T

$\text{Product T T}$

Bool \to T

$\text{Bool} \to T$

Bool \to T

$\text{Bool} \to T$

(\forall (t : *) \to (t \to t \to t)) \to T

$(\forall (t : *) \to (t \to t \to t)) \to T$

Product T T

$\text{Product} T T$

\forall (t : *) \to ((T \to T \to t) \to t)

$\forall (t : *) \to ((T \to T \to t) \to t)$

@Giorgio Mossa bkz. Cstheory.stackexchange.com/questions/30923/… - parametrikliğiniz varsa (tüm modellerde değil, ilk (sözdizimsel olanda )) izomorfizme sahipsiniz.

— ZeitRaffer

Bunu geleneksel Kilise kodlamasını kullanarak yapamazsınız Bool:

#Bool = ∀(Bool : *) → ∀(True : Bool) → ∀(False : Bool) → Bool

... türünde (yararlı) bir işlev yazamadığınız için:

#Bool → *

Belirttiğiniz *gibi, ilk argüman olarak geçememenizin #Boolnedeni, Trueve ve Falseargümanlarının tür olmayabilir.

Bunu çözmenin en az üç yolu vardır:

Endüktif Yapılar Analizini kullanın. Sonra türünü genelleştirebilirsiniz #Bool:
```
#Bool = ∀(n : Nat) → ∀(Bool : *ₙ) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
... ve sonra örneğini olurdu niçin 1içeri geçebileceği hangi araçlar, *₀çünkü ikinci tip-çek olur argüman olarak:
```
*₀ : *₁
```
... böylece #Booliki tür arasında seçim yapabilirsiniz.
Bir sıralama daha ekleyin:
```
* : □ : △
```
Sonra şöyle ayrı bir #Bool₂tür tanımlarsınız :
```
#Bool₂ = ∀(Bool : □) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
Bu aslında Endüktif yapıların Hesabı için özel bir durumdur, ancak şimdi daha az yeniden kullanılabilir kod üretir, çünkü şimdi #Booldesteklemek istediğimiz her tür için bir tane olmak üzere iki ayrı tanım sürdürmeliyiz .
#Bool₂Doğrudan İnşaat Hesabı içinde şu şekilde kodlayın :
```
#Bool₂ = ∀(True : *) → ∀(False : *) → *
```

Amaç bunu doğrudan değiştirilmemiş bir şekilde kullanmaksa, mortesadece # 3 yaklaşımı işe yarayacaktır.

— Gabriel Gonzalez
kaynak

Görebildiğim gibi # Bool₁ -> # Bool₂ dönüştürülemiyor, değil mi?

— ZeitRaffer

@ZeitRaffer Doğru. Şunlar arasından dönüştürülemiyor #Bool₁için#Bool₂

— Gabriel Gonzalez

Hmm ... IIUC, "Endüktif Yapıların Hesabı" adını sonsuz tür hiyerarşisine sahip bir kalkülüs olarak adlandırıyorsunuz, ancak AFAIK orijinal CIC'de böyle bir şey yoktu (sadece CoC'ye Endüktif türleri ekledi). Luo'nun ECC'sini (inşaatların genişletilmiş hesabı) mı düşünüyorsunuz?

— Stefan