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 ρ))
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
def arrow (A B : Rel) : Rel where
holds f g := ∀ x y, A.holds x y → B.holds (Model.app f x) (Model.app g y)
congr hff' hgg' := ⟨
fun h x y hxy => (B.congr (hff'.appFun x) (hgg'.appFun y)).mp (h x y hxy),
fun h x y hxy => (B.congr (hff'.appFun x) (hgg'.appFun y)).mpr (h x y hxy)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:45
def universal {ι : Sort u} (family : ι → Rel) : Rel where
holds f g := ∀ i, (family i).holds f g
congr hff' hgg' := ⟨
fun h i => ((family i).congr hff' hgg').mp (h i),
fun h i => ((family i).congr hff' hgg').mpr (h i)⟩
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:54
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 (ρ ∘ η)
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
@[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 ρ))
CSLibExt/Languages/LambdaCalculus/SystemF/Interpretation.lean:47
@[simp] def rename {n k : Nat} (ρ : Fin n → Fin k) : Ty n → Ty k
| .var i => .var (ρ i)
| .arr A B => .arr (rename ρ A) (rename ρ B)
| .all B => .all (rename (liftRen ρ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:53
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) ρ)
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
@[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 ρ))
CSLibExt/Languages/LambdaCalculus/SystemF/Interpretation.lean:47
@[simp] def subst {n k : Nat} (σ : Fin n → Ty k) : Ty n → Ty k
| .var i => σ i
| .arr A B => .arr (subst σ A) (subst σ B)
| .all B => .all (subst (liftSub σ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:63
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 ρ) ρ)
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
@[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 ρ))
CSLibExt/Languages/LambdaCalculus/SystemF/Interpretation.lean:47
def instantiate {n : Nat} (B : Ty (n + 1)) (A : Ty n) : Ty n :=
subst (Fin.cases A Ty.var) B
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:69
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 ρ
inductive Ty : Nat → Type where
| var {n : Nat} : Fin n → Ty n
| arr {n : Nat} : Ty n → Ty n → Ty n
| all {n : Nat} : Ty (n + 1) → Ty n
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:31
structure Rel where
/-- The actual binary predicate. -/
holds : Model → Model → Prop
/-- Conversion may replace either argument independently. -/
congr : ∀ {f f' g g'}, BetaEq f f' → BetaEq g g' →
(holds f g ↔ holds f' g')
CSLibExt/Languages/LambdaCalculus/SystemF/Relations.lean:26
@[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 ρ))
CSLibExt/Languages/LambdaCalculus/SystemF/Interpretation.lean:47
@[simp] def rename {n k : Nat} (ρ : Fin n → Fin k) : Ty n → Ty k
| .var i => .var (ρ i)
| .arr A B => .arr (rename ρ A) (rename ρ B)
| .all B => .all (rename (liftRen ρ) B)
CSLibExt/Languages/LambdaCalculus/SystemF/Syntax.lean:53
Uses 5 · Used by 1
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.