Impredicative binary interpretation of System F types

DefinitionBinary logical relation of a System F type#✓fully proved

The impredicative binary logical relation denoted by a System F type.

@[simp] def interpret {n : Nat} : Ty n → (Fin n → Rel) → Rel
  | .var i, ρ => ρ i
  | .arr A B, ρ => Rel.arrow (interpret A ρ) (interpret B ρ)
  | .all B, ρ => Rel.universal (fun R : Rel => interpret B (Fin.cases R ρ))
Uses 4 · Used by 9

TheoremRelational interpretation of a renamed System F type#✓fully proved

Interpreting a renamed type precomposes the relation environment.

theorem interpret_rename {n k : Nat} (η : Fin n → Fin k) (A : Ty n)
    (ρ : Fin k → Rel) :
    interpret (rename η A) ρ = interpret A (ρ ∘ η)
Uses 7 · Used by 2

TheoremRelational interpretation of a substituted System F type#✓fully proved

Type substitution is interpreted by substituting arbitrary relations.

theorem interpret_subst {n k : Nat} (σ : Fin n → Ty k) (A : Ty n)
    (ρ : Fin k → Rel) :
    interpret (subst σ A) ρ = interpret A (fun i => interpret (σ i) ρ)
Uses 8 · Used by 1

TheoremRelational interpretation of an instantiated System F type#✓fully proved

Universal instantiation inserts the argument's whole logical relation.

theorem interpret_instantiate {n : Nat} (B : Ty (n + 1)) (A : Ty n)
    (ρ : Fin n → Rel) :
    interpret (instantiate B A) ρ =
      interpret B (Fin.cases (interpret A ρ) ρ)
Uses 6 · Used by 1

TheoremRelational interpretation of a weakened System F type#✓fully proved

Weakening a type does not make it depend on the new arbitrary relation.

@[simp] theorem interpret_weaken {n : Nat} (A : Ty n) (ρ : Fin n → Rel)
    (R : Rel) : interpret (rename Fin.succ A) (Fin.cases R ρ) =
      interpret A ρ
Uses 5 · Used by 1
5 fully proved

The dependency explorer needs JavaScript and its graph data.

Download the complete graph data.