Question

请考虑以下设置：

data level : Set where
  # : ℕ -> level
  ω : level

_⊔_ : level -> level -> level
# α ⊔ # β = # (α ⊔ℕ β)
_   ⊔ _   = ω

_⊔ᵢ_ : level -> level -> level
α ⊔ᵢ # 0 = # 0
α ⊔ᵢ β   = α ⊔ β

mutual
  Prop = Univ (# 0)
  Type = Univ ∘ # ∘ suc

  data Univ : level -> Set where
    bot  : Prop
    top  : Prop
    nat  : Type 0
    univ : ∀ α -> Type α
    σ≡    : ∀ {α β γ} -> α ⊔  β ≡ γ -> (A : Univ α) -> (⟦ A ⟧ -> Univ β) -> Univ γ
    π≡    : ∀ {α β γ} -> α ⊔ᵢ β ≡ γ -> (A : Univ α) -> (⟦ A ⟧ -> Univ β) -> Univ γ
    πᵤ   : ∀ {α} -> (A : Univ α) {k : ⟦ A ⟧ -> level} -> (∀ x -> Univ (k x)) -> Univ ω

  ⟦_⟧ : ∀ {α} -> Univ α -> Set
  ⟦ bot      ⟧ = ⊥
  ⟦ top      ⟧ = ⊤
  ⟦ nat      ⟧ = ℕ
  ⟦ univ α   ⟧ = Univ (# α)
  ⟦ σ≡ _ A B ⟧ = Σ ⟦ A ⟧ λ x -> ⟦ B x ⟧
  ⟦ π≡ _ A B ⟧ = (x : ⟦ A ⟧) -> ⟦ B x ⟧
  ⟦ πᵤ   A B ⟧ = (x : ⟦ A ⟧) -> ⟦ B x ⟧

prop = univ 0
type = univ ∘ suc

我们有一个分层的宇宙层次结构：Prop : Type 0 : Type 1 : ...（其中Prop是不可预测的），Σ-和Π-类型的代码和另一个代码πᵤ的“宇宙多态Π” -types”。就像在Agda ∀ α -> Set α中有[隐藏]类型Setω一样，π nat univ的类型为Univ ω。

有一些快捷方式

_&_ : ∀ {α β} -> Univ α -> Univ β -> Univ (α ⊔  β)
A & B = σ A λ _ -> B

_⇒_ : ∀ {α β} -> Univ α -> Univ β -> Univ (α ⊔ᵢ β)
A ⇒ B = π A λ _ -> B

_‵π‵_ : ∀ {α β} -> (A : Univ α) -> (⟦ A ⟧ -> Univ β) -> Univ (α ⊔ᵢ β)
_‵π‵_ = π

_‵πᵤ‵_ : ∀ {α} -> (A : Univ α) {k : ⟦ A ⟧ -> level} -> (∀ x -> Univ (k x)) -> Univ ω
_‵πᵤ‵_ = πᵤ

我们可以使用目标语言结构定义许多函数，例如

_≟ₚ_ : ⟦ nat ⇒ nat ⇒ prop ⟧
zero  ≟ₚ zero  = top
suc n ≟ₚ suc m = n ≟ₚ m
_     ≟ₚ _     = bot

在一种想象的语言中，我们可以识别代码和相应的类型，从而形成一个封闭的自反宇宙（我们还需要一些数据类型的一阶表示，但这是另一个故事）。但请考虑通常的类型相等：

Eq : ∀ {α β} -> Univ α -> Univ β -> Prop

如何将其嵌入目标语言？我们可以写

EqEmb : ⟦ (nat ‵πᵤ‵ λ α → nat ‵πᵤ‵ λ β → univ α ⇒ univ β ⇒ prop) ⟧

但请注意目标语言不包含ω的任何内容。在Eq中，我们可以对这样的参数进行模式匹配：

Eq (πᵤ A₁ B₁) (πᵤ A₂ B₂) = ...

α和β都变为ω，一切都很好。但在EqEmb中，我们无法像这样进行模式匹配，因为在univ α α中是一个数字而不能是ω，所以⟦ univ α ⟧永远不会{ {1}}。

假设我们可以在普通的Agda类型上进行模式匹配。然后我们可以编写一个函数来确定某个值是否是函数：

Univ ω

但是，如果isFunction : ∀ {α} {A : Set α} -> A -> Bool isFunction {A = Π A B} _ = true isFunction _ = false是“依赖于宇宙的”并且具有这样的类型，那该怎么办：B？然后，∀ α -> Set α的类型为Π A B，Setω与α统一。但是如果我们可以使用ω实例化级别变量，那么我们可以编写像

这样的东西

ω

这是不可预测的（虽然我不知道这种特殊形式的不确定性是否导致不一致。是吗？）。

因此，我们无法将Id : Set ω Id = ∀ α -> (A : Set α) -> A -> A id : Id id α A x = x id ω Id id ~> id作为法律级别添加到目标语言中，并且我们无法在存在“Universe依赖”函数的情况下对ω进行模式匹配。因此“反身”平等

Set α

未定义所有Universe多态函数（不是“依赖于Universe”）。例如。 EqEmb : ⟦ (nat ‵πᵤ‵ λ α → nat ‵πᵤ‵ λ β → univ α ⇒ univ β ⇒ prop) ⟧

的类型

map

是map : ∀ {α β} {A : Set α} {B : Set β} -> (A -> B) -> List A -> List B，我们无法询问是否Setω，因为在Eq (typeOf emb-map) (typeOf emb-map)中Eq A B的类型是A，这是“有限”宇宙（同样适用于⟦ univ α ⟧）。

那么有可能以一种良好的方式嵌入OTT吗？如果没有，我们可以以某种方式作弊吗？我们可以在“宇宙相关”函数的存在中对B进行模式匹配，就像一切都很好吗？

Answer 1

我最终得到了以下层次结构：

Prop : Type 0 : Type 1 : ...
(∀ α -> Type α) : Type ω₀ : Type ω₁

Type ω₁没有代码，因为之前没有Type ω₀的代码，但我们需要Type ω₀的代码才能定义Universe多态函数和代码的相等性Type ω₁的用途不太有用。

现在我们有四个依赖于宇宙的量词

σ₀ π₀   : {α : Lev false}
        -> (A : Univ α) {k : ⟦ A ⟧ -> Lev false} -> (∀ x -> Univ (k x)) -> Univ {false} ω₀
σ₁ π₁   : ∀ {a} {α : Lev a}
        -> (A : Univ α) {b : ⟦ A ⟧ -> Bool} {k : ∀ x -> Lev (b x)}
        -> (∀ x -> Univ (k x))
        -> Univ ω₁

关键是现在可以在π₀上进行模式匹配，从而允许定义Universe多态函数的相等性，但是π₁上的模式匹配是不可能的（与π₀一样这被称为πᵤ），我们可以忍受。

平等有这些“反身”类型：

mutual
  Eq : ⟦ (π₁ lev λ α -> π₁ lev λ β -> univ⁺ α ⇒ univ⁺ β ⇒ prop) ⟧
  eq : ⟦ (π₁ lev λ α -> π₁ lev λ β -> π (univ⁺ α) λ A -> π (univ⁺ β) λ B -> A ⇒ B ⇒ prop) ⟧

代码为here。然而，看起来我需要再次扩展层次结构才能证明一致性。我会问一个问题。

OTT

1 个答案: