Type-beta confluence and conversion inversion
InductiveParallel type-beta reduction in Fω#✓fully proved
Parallel type-beta reduction, retaining the context and kind indices.
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
{b c : Ty (κ :: Δ) μ} {a a' : Ty Δ κ} :
Par b c → Par a a' → Par (.app (.lam b) a) (instantiate c a')
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive KVar : List Kind → Kind → Type where
| zero {Δ : List Kind} {κ : Kind} : KVar (κ :: Δ) κ
| succ {Δ : List Kind} {κ μ : Kind} : KVar Δ κ → KVar (μ :: Δ) κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:43
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
Uses 4 · Used by 17
TheoremReflexivity of parallel type-beta reduction#✓fully proved
Parallel reduction is reflexive on every kinded operator.
theorem Par.refl (a : Ty Δ κ) : Par a a
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
Uses 4 · Used by 3
TheoremParallel type-beta reduction is stable under renaming#✓fully proved
Parallel beta reduction is stable under kinded renaming.
theorem Par.rename (h : Par a b) (ρ : KRen Δ Ε) :
Par (Ty.rename ρ a) (Ty.rename ρ b)
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
abbrev KRen (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → KVar Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:48
def rename {Δ Ε : List Kind} (ρ : KRen Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => .var (ρ x)
| _, .lam b => .lam (rename (KRen.lift ρ) b)
| _, .app f a => .app (rename ρ f) (rename ρ a)
| _, .arr a b => .arr (rename ρ a) (rename ρ b)
| _, .all b => .all (rename (KRen.lift ρ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:73
Uses 9 · Used by 1
TheoremParallel type-beta reduction is stable under substitution#✓fully proved
Parallel reduction respects simultaneous substitution on both sides.
theorem Par.subst (h : Par a b) {σ τ : Sub Δ Ε}
(hσ : ∀ {ν} (x : KVar Δ ν), Par (σ x) (τ x)) :
Par (Ty.subst σ a) (Ty.subst τ b)
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
abbrev Sub (Δ Ε : List Kind) := ∀ {κ}, KVar Δ κ → Ty Ε κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:82
inductive KVar : List Kind → Kind → Type where
| zero {Δ : List Kind} {κ : Kind} : KVar (κ :: Δ) κ
| succ {Δ : List Kind} {κ μ : Kind} : KVar Δ κ → KVar (μ :: Δ) κ
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:43
def subst {Δ Ε : List Kind} (σ : Sub Δ Ε) :
{κ : Kind} → Ty Δ κ → Ty Ε κ
| _, .var x => σ x
| _, .lam b => .lam (subst (liftSub σ) b)
| _, .app f a => .app (subst σ f) (subst σ a)
| _, .arr a b => .arr (subst σ a) (subst σ b)
| _, .all b => .all (subst (liftSub σ) b)
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:91
Uses 10 · Used by 1
TheoremParallel type-beta reduction is stable under instantiation#✓fully proved
Parallel reduction respects discharging a binder and reducing its image.
theorem Par.instantiate {b c : Ty (μ :: Δ) κ} {a a' : Ty Δ μ}
(hb : Par b c) (ha : Par a a') :
Par (Ty.instantiate b a) (Ty.instantiate c a')
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
Uses 7 · Used by 1
DefinitionComplete development of type-beta redexes#✓fully proved
Contract all originally present type-beta redexes recursively.
def develop : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ
| _, _, .var x => .var x
| _, _, .lam b => .lam (develop b)
| _, _, .app (.lam b) a => instantiate (develop b) (develop a)
| _, _, .app f a => .app (develop f) (develop a)
| _, _, .arr a b => .arr (develop a) (develop b)
| _, _, .all b => .all (develop b)
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
def instantiate {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) : Ty Δ μ := subst (single a) b
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:105
TheoremParallel reducts reduce to the complete development#✓fully proved
Every parallel reduct reduces to the original complete development.
theorem Par.to_develop (h : Par a b) : Par b (develop a)
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
def develop : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ
| _, _, .var x => .var x
| _, _, .lam b => .lam (develop b)
| _, _, .app (.lam b) a => instantiate (develop b) (develop a)
| _, _, .app f a => .app (develop f) (develop a)
| _, _, .arr a b => .arr (develop a) (develop b)
| _, _, .all b => .all (develop b)
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:104
Uses 7 · Used by 1
TheoremDiamond property of parallel type-beta reduction#✓fully proved
Parallel beta reduction has the diamond property at each kind.
theorem par_diamond : Relation.Diamond (Par (Δ := Δ) (κ := κ))
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
Uses 5 · Used by 1
TheoremConfluence of parallel type-beta reduction#✓fully proved
Parallel type-beta reduction is confluent; no termination premise.
theorem par_confluent : Relation.Confluent (Par (Δ := Δ) (κ := κ))
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
Uses 4 · Used by 1
AbbreviationMultistep parallel type-beta reduction#✓fully proved
Finitely many parallel beta reductions, including zero reductions.
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
Uses 3 · Used by 12
TheoremMultistep type-beta reduction under an operator abstraction#✓fully proved
Multiple parallel reductions are stable under an operator binder.
theorem Red.lam {b c : Ty (μ :: Δ) κ} (h : Red b c) :
Red (.lam b) (.lam c)
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 4 · Used by 1
TheoremMultistep type-beta reduction under a universal quantifier#✓fully proved
Multiple parallel reductions are stable under a universal binder.
theorem Red.all {b c : Ty (μ :: Δ) .star} (h : Red b c) :
Red (.all b) (.all c)
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 4 · Used by 1
TheoremMultistep type-beta reduction in type applications#✓fully proved
Multiple reductions are congruent in both type-application arguments.
theorem Red.app {f g : Ty Δ (.arrow μ κ)} {a b : Ty Δ μ}
(hf : Red f g) (ha : Red a b) : Red (.app f a) (.app g b)
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 5 · Used by 1
TheoremMultistep type-beta reduction in function types#✓fully proved
Multiple reductions are congruent in both term-function type arguments.
theorem Red.arr {a a' b b' : Ty Δ .star}
(ha : Red a a') (hb : Red b b') : Red (.arr a b) (.arr a' b')
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 5 · Used by 1
TheoremChurch–Rosser property of type-beta conversion#✓fully proved
Conversion entails a common parallel-beta reduct (Church-Rosser).
theorem Conv.join (h : Conv a b) : ∃ c, Red a c ∧ Red b c
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 12 · Used by 4
TheoremParallel type-beta reduction implies conversion#✓fully proved
Every parallel-beta reduction is a proved conversion.
theorem Par.conv (h : Par a b) : Conv a b
inductive Par : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| var {Δ : List Kind} {κ : Kind} (x : KVar Δ κ) : Par (.var x) (.var x)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Par b c → Par (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
{f g : Ty Δ (.arrow κ μ)} {a b : Ty Δ κ} :
Par f g → Par a b → Par (.app f a) (.app g b)
| arr {Δ : List Kind} {a a' b b' : Ty Δ .star} :
Par a a' → Par b b' → Par (.arr a b) (.arr a' b')
| all {Δ : List Kind} {κ : Kind} {b c : Ty (κ :: Δ) .star} :
Par b c → Par (.all b) (.all c)
| beta {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:33
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
Uses 6 · Used by 1
TheoremMultistep type-beta reduction implies conversion#✓fully proved
Finitely many parallel-beta reductions are a proved conversion.
theorem Red.conv (h : Red a b) : Conv a b
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
Uses 6 · Used by 3
TheoremType-beta conversion is joinability by a common reduct#✓fully proved
Conversion is exactly common-reduct joinability, not semantic equality.
theorem conv_iff_join : Conv a b ↔ ∃ c, Red a c ∧ Red b c
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
TheoremReducts of function types are function types#✓fully proved
Reduction of a term-function type keeps its outer constructor.
theorem Red.arr_inv {a b c : Ty Δ .star} (h : Red (.arr a b) c) :
∃ a' b', c = .arr a' b' ∧ Red a a' ∧ Red b b'
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 6 · Used by 1
TheoremReducts of quantified types are quantified types#✓fully proved
Reduction of a quantified type keeps its binder kind and outer shape.
theorem Red.all_inv {body : Ty (μ :: Δ) .star} {c : Ty Δ .star}
(h : Red (.all body) c) :
∃ body' : Ty (μ :: Δ) .star, c = .all body' ∧ Red body body'
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
abbrev Red (a b : Ty Δ κ) := Relation.ReflTransGen Par a b
CSLibExt/Languages/LambdaCalculus/FOmega/Confluence.lean:148
Uses 6 · Used by 2
TheoremInjectivity of function types up to conversion#✓fully proved
Convertible term-function types have convertible domains and codomains.
theorem Conv.arr_inj {a a' b b' : Ty Δ .star}
(h : Conv (.arr a b) (.arr a' b')) : Conv a a' ∧ Conv b b'
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
Uses 8 · Used by 1
TheoremConversion preserves the kind of a universal binder#✓fully proved
Conversion cannot change the kind of a universal binder.
theorem Conv.all_kind {ν : Kind} {body : Ty (μ :: Δ) .star}
{body' : Ty (ν :: Δ) .star} (h : Conv (.all body) (.all body')) :
μ = ν
inductive Kind where
| star : Kind
| arrow : Kind → Kind → Kind
deriving DecidableEq, Repr
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:37
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
TheoremInjectivity of quantified types up to conversion#✓fully proved
Convertible quantified types at the same kind have convertible bodies.
theorem Conv.all_inj {body body' : Ty (μ :: Δ) .star}
(h : Conv (.all body) (.all body')) : Conv body body'
inductive Ty : List Kind → Kind → Type where
| var {Δ : List Kind} {κ : Kind} : KVar Δ κ → Ty Δ κ
| lam {Δ : List Kind} {κ μ : Kind} :
Ty (κ :: Δ) μ → Ty Δ (.arrow κ μ)
| app {Δ : List Kind} {κ μ : Kind} :
Ty Δ (.arrow κ μ) → Ty Δ κ → Ty Δ μ
| arr {Δ : List Kind} : Ty Δ .star → Ty Δ .star → Ty Δ .star
| all {Δ : List Kind} {κ : Kind} : Ty (κ :: Δ) .star → Ty Δ .star
CSLibExt/Languages/LambdaCalculus/FOmega/Syntax.lean:61
inductive Conv : {Δ : List Kind} → {κ : Kind} → Ty Δ κ → Ty Δ κ → Prop where
| refl {Δ : List Kind} {κ : Kind} (a : Ty Δ κ) : Conv a a
| symm {Δ : List Kind} {κ : Kind} {a b : Ty Δ κ} :
Conv a b → Conv b a
| trans {Δ : List Kind} {κ : Kind} {a b c : Ty Δ κ} :
Conv a b → Conv b c → Conv a c
| beta {Δ : List Kind} {κ μ : Kind}
(b : Ty (κ :: Δ) μ) (a : Ty Δ κ) :
Conv (.app (.lam b) a) (instantiate b a)
| lam {Δ : List Kind} {κ μ : Kind} {b c : Ty (κ :: Δ) μ} :
Conv b c → Conv (.lam b) (.lam c)
| app {Δ : List Kind} {κ μ : Kind}
⋯
CSLibExt/Languages/LambdaCalculus/FOmega/Conversion.lean:30
Uses 8 · Used by 1
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.