ประเภทที่ขึ้นอยู่กับประเภทที่เข้ารหัสของคริสตจักรใน PTS / CoC

ฉันกำลังทดลองกับระบบที่บริสุทธิ์ในก้อนแลมบ์ดาของ Barendregt โดยเฉพาะกับแคลคูลัสออฟคอนสตรัคชั่นที่ทรงพลังที่สุด ระบบนี้มีทุกประเภทและ* BOXสำหรับบันทึกด้านล่างฉันใช้ไวยากรณ์ที่เป็นรูปธรรมของMorteเครื่องมือhttps://github.com/Gabriel439/Haskell-Morte-Libraryซึ่งอยู่ใกล้กับแคลคูลัสแลมบ์ดาคลาสสิก

ฉันเห็นว่าเราสามารถเลียนแบบประเภทอุปนัยโดยการเข้ารหัสเหมือนคริสตจักรบางอย่าง (aka Boehm-Berarducci isomorphism สำหรับประเภทข้อมูลพีชคณิต) สำหรับชนิดเช่นฉันใช้งานง่ายBool = ∀(t : *) -> t -> t -> tด้วยการก่อสร้างงานและTrue = λ(t : *) -> λ(x : t) -> λ(y : t) -> xFalse = λ(t : *) -> λ(x : t) -> λ(y : t) -> y

ฉันเห็นว่าประเภทของฟังก์ชั่นระดับคำBool -> Tเป็น isomorphic เพื่อคู่ของประเภทที่Product T TมีProduct = λ(A : *) -> λ(B : *) -> ∀(t : *) -> (A -> B -> t) -> tพารามิเตอร์แบบโมดูโลคลาสสิกโดยวิธีการของฟังก์ชั่นif : Bool -> λ(t : *) -> t -> t -> tซึ่งในความเป็นจริงตัวตน

Bool -> *คำถามทุกข้อดังต่อไปนี้จะเกี่ยวกับการแสดงประเภทขึ้นอยู่กับ

ฉันสามารถแยกD : Bool -> *เป็นคู่D TrueและD False. มีวิธีบัญญัติมาตรฐานในการสร้างDอีกครั้งหรือไม่? ฉันต้องการสร้าง isomosphism ซ้ำBool -> T = Product T Tโดยฟังก์ชันอนาล็อกifที่ระดับประเภท แต่ฉันไม่สามารถเขียนฟังก์ชันนี้ได้ง่ายเหมือนต้นฉบับifเพราะเราไม่สามารถผ่านชนิดในอาร์กิวเมนต์เช่นประเภท
ฉันใช้อุปนัยประเภทที่มีสอง constuctors เพื่อแก้ปัญหาคำถาม (1) คำอธิบายระดับสูง (สไตล์ Agda) เป็นประเภทต่อไปนี้ (ใช้แทนประเภทระดับif)
```
data BoolDep (T : *) (F : *) : Bool -> * where
  DepTrue : T -> BoolDep T F True
  DepFalse : F -> BoolDep T F False
```
ด้วยการเข้ารหัสต่อไปนี้ใน PTS / CoC:
```
λ(T : *) -> λ(F : *) -> λ(bool : Bool ) ->
∀(P : Bool -> *) ->
∀(DepTrue : T -> P True ) ->
∀(DepFalse : F -> P False ) ->
P bool
```
การเข้ารหัสของฉันถูกต้องหรือไม่
ฉันสามารถเขียน constructors สำหรับBoolDepเช่นรหัสนี้สำหรับDepTrue : ∀(T : *) -> ∀(F : *) -> T -> BoolDep T F True:
```
λ(T : *) ->  λ(F : *) ->  λ(arg : T ) ->
λ(P : Bool -> *) ->
λ(DepTrue : T -> P True ) ->
λ(DepFalse : F -> P False ) ->
DepTrue arg
```

แต่ฉันไม่สามารถเขียนฟังก์ชันผกผันได้ (หรือฟังก์ชันใด ๆ ในทิศทางตรงกันข้าม) เป็นไปได้ไหม? หรือฉันควรใช้เป็นตัวแทนอีกBoolDepในการผลิตมอร์ฟBoolDep T F True = T?

type-theory type-systems dependent-type

— ZeitRaffer
แหล่งที่มา

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 เห็นcstheory.stackexchange.com/questions/30923/… - ถ้าคุณมีพาราเมทริก (ไม่ใช่ในทุกรุ่น แต่เป็นรุ่นแรก ( ซินแทกติก )) จากนั้นคุณก็มีมอร์ฟิซึ่มส์

— ZeitRaffer

คุณไม่สามารถทำได้โดยใช้การเข้ารหัสของโบสถ์แบบดั้งเดิมสำหรับBool:

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

... เนื่องจากคุณไม่สามารถเขียนฟังก์ชัน (มีประโยชน์) ประเภท:

#Bool → *

เหตุผลที่ตามที่คุณบันทึกไว้คือคุณไม่สามารถส่งผ่าน*เป็นอาร์กิวเมนต์แรกถึง#Boolซึ่งหมายความว่าอาร์กิวเมนต์TrueและFalseอาจไม่เป็นประเภท

มีอย่างน้อยสามวิธีที่คุณสามารถแก้ไขปัญหานี้:

ใช้แคลคูลัสของอุปนัย จากนั้นคุณสามารถพูดคุยประเภทของ#Boolถึง:
```
#Bool = ∀(n : Nat) → ∀(Bool : *ₙ) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
... และแล้วคุณจะยกตัวอย่างnไป1ซึ่งหมายความว่าคุณสามารถส่งผ่าน*₀เป็นอาร์กิวเมนต์ที่สองซึ่งจะพิมพ์ตรวจสอบเนื่องจาก:
```
*₀ : *₁
```
... ดังนั้นคุณสามารถใช้#Boolเพื่อเลือกระหว่างสองประเภท
เพิ่มการจัดเรียงอีกหนึ่งรายการ:
```
* : □ : △
```
จากนั้นคุณจะกำหนด#Bool₂ประเภทแยกดังนี้:
```
#Bool₂ = ∀(Bool : □) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
นี่เป็นกรณีพิเศษของแคลคูลัสของการสร้างแบบอุปนัย แต่สร้างรหัสที่สามารถนำกลับมาใช้ใหม่ได้น้อยกว่าเนื่องจากตอนนี้เราต้องรักษาคำจำกัดความที่แยกจากกันสองคำ#Boolสำหรับแต่ละประเภทที่เราต้องการสนับสนุน
เข้ารหัส#Bool₂โดยตรงภายในแคลคูลัสของการก่อสร้างเป็น:
```
#Bool₂ = ∀(True : *) → ∀(False : *) → *
```

หากเป้าหมายคือการใช้สิ่งนี้โดยตรงภายในไม่ได้แก้ไขmorteวิธีการเฉพาะ # 3 จะทำงานได้

— Gabriel Gonzalez
แหล่งที่มา

อย่างที่ฉันเห็นเราไม่สามารถแปลง # Bool₁ -> # Bool₂ได้ใช่ไหม

— ZeitRaffer

@ ZeitRaffer ถูกต้อง คุณไม่สามารถแปลงจาก#Bool₁เป็น#Bool₂

— Gabriel Gonzalez

อืม ... IIUC คุณเรียกว่า "แคลคูลัสแห่งอุปนัย" แคลคูลัสที่มีลำดับชั้นไม่ จำกัด ประเภท แต่ AFAIK CIC ดั้งเดิมไม่ได้มีสิ่งนั้น คุณอาจคิดถึง ECC ของ Luo (แคลคูลัสเพิ่มเติมของสิ่งก่อสร้าง)?

— Stefan