ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.lt_blsub₂
theorem lt_blsub₂ {o₁ o₂ : Ordinal}
    (op : {a : Ordinal} → (a < o₁) → {b : Ordinal} → (b < o₂) → Ordinal) {a b : Ordinal}
    (ha : a < o₁) (hb : b < o₂) : op ha hb < blsub₂ o₁ o₂ op 
Arguments: {o₁ : Ordinal.{u_4}} {o₂ : Ordinal.{u_5}} (op : {a : Ordinal.{u_4}} → a < o₁ → {b : Ordinal.{u_5}} → b < o₂ → Ordinal.{max (max u_4 u_5) u_6}) {a : Ordinal.{u_4}} {b : Ordinal.{u_5}} (ha : a < o₁) (hb : b < o₂)
Goal: op ha hb < o₁.blsub₂ o₂ fun {a} => op
-- Ordinal.mex_not_mem_range
theorem mex_not_mem_range {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ∉ Set.range f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v})
Goal: Ordinal.mex f ∉ Set.range f
-- Ordinal.le_mex_of_forall
theorem le_mex_of_forall {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal}
    (H : ∀ b < a, ∃ i, f i = b) : a ≤ mex.{_, v} f 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}} (H : ∀ b < a, ∃ i, f i = b)
Goal: a ≤ Ordinal.mex f
-- Ordinal.ne_mex
theorem ne_mex {ι : Type u} (f : ι → Ordinal.{max u v}) : ∀ i, f i ≠ mex.{_, v} f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v}) (i : ι)
Goal: f i ≠ Ordinal.mex f
-- Ordinal.mex_le_of_ne
theorem mex_le_of_ne {ι} {f : ι → Ordinal} {a} (ha : ∀ i, f i ≠ a) : mex f ≤ a 
Arguments: {ι : Type u_4} {f : ι → Ordinal.{max u_5 u_4}} {a : Ordinal.{max u_5 u_4}} (ha : ∀ (i : ι), f i ≠ a)
Goal: Ordinal.mex f ≤ a
-- Ordinal.exists_of_lt_mex
theorem exists_of_lt_mex {ι} {f : ι → Ordinal} {a} (ha : a < mex f) : ∃ i, f i = a 
Arguments: {ι : Type u_4} {f : ι → Ordinal.{max u_5 u_4}} {a : Ordinal.{max u_4 u_5}} (ha : a < Ordinal.mex f)
Goal: ∃ i, f i = a
-- Ordinal.mex_le_lsub
theorem mex_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ≤ lsub.{_, v} f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v})
Goal: Ordinal.mex f ≤ Ordinal.lsub f
-- Ordinal.mex_monotone
theorem mex_monotone {α β : Type u} {f : α → Ordinal.{max u v}} {g : β → Ordinal.{max u v}}
    (h : Set.range f ⊆ Set.range g) : mex.{_, v} f ≤ mex.{_, v} g 
Arguments: {α β : Type u} {f : α → Ordinal.{max u v}} {g : β → Ordinal.{max u v}} (h : Set.range f ⊆ Set.range g)
Goal: Ordinal.mex f ≤ Ordinal.mex g
-- Ordinal.mex_lt_ord_succ_mk
theorem mex_lt_ord_succ_mk {ι : Type u} (f : ι → Ordinal.{u}) :
    mex.{_, u} f < (succ #ι).ord 
Arguments: {ι : Type u} (f : ι → Ordinal.{u})
Goal: Ordinal.mex f < (Order.succ #ι).ord
-- Ordinal.bmex_not_mem_brange
theorem bmex_not_mem_brange {o : Ordinal} (f : ∀ a < o, Ordinal) : bmex o f ∉ brange o f 
Arguments: {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5})
Goal: o.bmex f ∉ o.brange f
-- Ordinal.le_bmex_of_forall
theorem le_bmex_of_forall {o : Ordinal} (f : ∀ a < o, Ordinal) {a : Ordinal}
    (H : ∀ b < a, ∃ i hi, f i hi = b) : a ≤ bmex o f 
Arguments: {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}) {a : Ordinal.{max u_4 u_5}} (H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b)
Goal: a ≤ o.bmex f
-- Ordinal.ne_bmex
theorem ne_bmex {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) {i} (hi) :
    f i hi ≠ bmex.{_, v} o f 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}) {i : Ordinal.{u}} (hi : i < o)
Goal: f i hi ≠ o.bmex f
-- Ordinal.bmex_le_of_ne
theorem bmex_le_of_ne {o : Ordinal} {f : ∀ a < o, Ordinal} {a} (ha : ∀ i hi, f i hi ≠ a) :
    bmex o f ≤ a 
Arguments: {o : Ordinal.{u_4}} {f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}} {a : Ordinal.{max u_4 u_5}} (ha : ∀ (i : Ordinal.{u_4}) (hi : i < o), f i hi ≠ a)
Goal: o.bmex f ≤ a
-- Ordinal.exists_of_lt_bmex
theorem exists_of_lt_bmex {o : Ordinal} {f : ∀ a < o, Ordinal} {a} (ha : a < bmex o f) :
    ∃ i hi, f i hi = a 
Arguments: {o : Ordinal.{u_4}} {f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}} {a : Ordinal.{max u_5 u_4}} (ha : a < o.bmex f)
Goal: ∃ i, ∃ (hi : i < o), f i hi = a
-- Ordinal.bmex_le_blsub
theorem bmex_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bmex.{_, v} o f ≤ blsub.{_, v} o f 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: o.bmex f ≤ o.blsub f
-- Ordinal.bmex_monotone
theorem bmex_monotone {o o' : Ordinal.{u}}
    {f : ∀ a < o, Ordinal.{max u v}} {g : ∀ a < o', Ordinal.{max u v}}
    (h : brange o f ⊆ brange o' g) : bmex.{_, v} o f ≤ bmex.{_, v} o' g 
Arguments: {o o' : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}} {g : (a : Ordinal.{u}) → a < o' → Ordinal.{max u v}} (h : o.brange f ⊆ o'.brange g)
Goal: o.bmex f ≤ o'.bmex g
-- Ordinal.bmex_lt_ord_succ_card
theorem bmex_lt_ord_succ_card {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{u}) :
    bmex.{_, u} o f < (succ o.card).ord 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u})
Goal: o.bmex f < (Order.succ o.card).ord
-- not_surjective_of_ordinal
theorem not_surjective_of_ordinal {α : Type u} (f : α → Ordinal.{u}) : ¬Surjective f 
Arguments: {α : Type u} (f : α → Ordinal.{u})
Goal: ¬Function.Surjective f
-- not_injective_of_ordinal
theorem not_injective_of_ordinal {α : Type u} (f : Ordinal.{u} → α) : ¬Injective f 
Arguments: {α : Type u} (f : Ordinal.{u} → α)
Goal: ¬Function.Injective f
-- not_surjective_of_ordinal_of_small
theorem not_surjective_of_ordinal_of_small {α : Type v} [Small.{u} α] (f : α → Ordinal.{u}) :
    ¬Surjective f 
Arguments: {α : Type v} [Small.{u, v} α] (f : α → Ordinal.{u})
Goal: ¬Function.Surjective f
-- not_injective_of_ordinal_of_small
theorem not_injective_of_ordinal_of_small {α : Type v} [Small.{u} α] (f : Ordinal.{u} → α) :
    ¬Injective f 
Arguments: {α : Type v} [Small.{u, v} α] (f : Ordinal.{u} → α)
Goal: ¬Function.Injective f
-- not_small_ordinal
theorem not_small_ordinal : ¬Small.{u} Ordinal.{max u v} 
Goal: ¬Small.{u, max (u + 1) (v + 1)} Ordinal.{max u v}
-- Ordinal.enumOrd_def'
theorem enumOrd_def' (o) :
    enumOrd S o = sInf (S ∩ Set.Ici (blsub.{u, u} o fun a _ => enumOrd S a)) 
Arguments: {S : Set Ordinal.{u}} (o : Ordinal.{u})
Goal: Ordinal.enumOrd S o = sInf (S ∩ Set.Ici (o.blsub fun a x => Ordinal.enumOrd S a))
-- Ordinal.enumOrd_def'_nonempty
theorem enumOrd_def'_nonempty (hS : Unbounded (· < ·) S) (a) : (S ∩ Set.Ici a).Nonempty 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (a : Ordinal.{u})
Goal: (S ∩ Set.Ici a).Nonempty
-- _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.enumOrd_mem_aux
private theorem enumOrd_mem_aux (hS : Unbounded (· < ·) S) (o) :
    enumOrd S o ∈ S ∩ Set.Ici (blsub.{u, u} o fun c _ => enumOrd S c) 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (o : Ordinal.{u})
Goal: Ordinal.enumOrd S o ∈ S ∩ Set.Ici (o.blsub fun c x => Ordinal.enumOrd S c)
-- Ordinal.enumOrd_mem
theorem enumOrd_mem (hS : Unbounded (· < ·) S) (o) : enumOrd S o ∈ S 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (o : Ordinal.{u})
Goal: Ordinal.enumOrd S o ∈ S
-- Ordinal.blsub_le_enumOrd
theorem blsub_le_enumOrd (hS : Unbounded (· < ·) S) (o) :
    (blsub.{u, u} o fun c _ => enumOrd S c) ≤ enumOrd S o 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (o : Ordinal.{u})
Goal: (o.blsub fun c x => Ordinal.enumOrd S c) ≤ Ordinal.enumOrd S o
-- Ordinal.enumOrd_strictMono
theorem enumOrd_strictMono (hS : Unbounded (· < ·) S) : StrictMono (enumOrd S) 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S)
Goal: StrictMono (Ordinal.enumOrd S)
-- Ordinal.enumOrd_def
theorem enumOrd_def (o) : enumOrd S o = sInf (S ∩ { b | ∀ c, c < o → enumOrd S c < b }) 
Arguments: {S : Set Ordinal.{u}} (o : Ordinal.{u})
Goal: Ordinal.enumOrd S o = sInf (S ∩ {b | ∀ c < o, Ordinal.enumOrd S c < b})
-- Ordinal.enumOrd_def_nonempty
theorem enumOrd_def_nonempty (hS : Unbounded (· < ·) S) {o} :
    { x | x ∈ S ∧ ∀ c, c < o → enumOrd S c < x }.Nonempty 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) {o : Ordinal.{u}}
Goal: {x | x ∈ S ∧ ∀ c < o, Ordinal.enumOrd S c < x}.Nonempty
-- Ordinal.enumOrd_range
@[simp]
theorem enumOrd_range {f : Ordinal → Ordinal} (hf : StrictMono f) : enumOrd (range f) = f 
Arguments: {f : Ordinal.{u_1} → Ordinal.{u_1}} (hf : StrictMono f)
Goal: Ordinal.enumOrd (Set.range f) = f
-- Ordinal.enumOrd_univ
@[simp]
theorem enumOrd_univ : enumOrd Set.univ = id 
Goal: Ordinal.enumOrd Set.univ = id
-- Ordinal.enumOrd_zero
@[simp]
theorem enumOrd_zero : enumOrd S 0 = sInf S 
Arguments: {S : Set Ordinal.{u}}
Goal: Ordinal.enumOrd S 0 = sInf S
-- Ordinal.enumOrd_succ_le
theorem enumOrd_succ_le {a b} (hS : Unbounded (· < ·) S) (ha : a ∈ S) (hb : enumOrd S b < a) :
    enumOrd S (succ b) ≤ a 
Arguments: {S : Set Ordinal.{u}} {a b : Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (ha : a ∈ S) (hb : Ordinal.enumOrd S b < a)
Goal: Ordinal.enumOrd S (Order.succ b) ≤ a
-- Ordinal.enumOrd_le_of_subset
theorem enumOrd_le_of_subset {S T : Set Ordinal} (hS : Unbounded (· < ·) S) (hST : S ⊆ T) (a) :
    enumOrd T a ≤ enumOrd S a 
Arguments: {S T : Set Ordinal.{u_1}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (hST : S ⊆ T) (a : Ordinal.{u_1})
Goal: Ordinal.enumOrd T a ≤ Ordinal.enumOrd S a
-- Ordinal.enumOrd_surjective
theorem enumOrd_surjective (hS : Unbounded (· < ·) S) : ∀ s ∈ S, ∃ a, enumOrd S a = s 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S) (s : Ordinal.{u})
Goal: s ∈ S → ∃ a, Ordinal.enumOrd S a = s
-- Ordinal.range_enumOrd
theorem range_enumOrd (hS : Unbounded (· < ·) S) : range (enumOrd S) = S 
Arguments: {S : Set Ordinal.{u}} (hS : Set.Unbounded (fun x x_1 => x < x_1) S)
Goal: Set.range (Ordinal.enumOrd S) = S
-- Ordinal.eq_enumOrd
theorem eq_enumOrd (f : Ordinal → Ordinal) (hS : Unbounded (· < ·) S) :
    StrictMono f ∧ range f = S ↔ f = enumOrd S 
Arguments: {S : Set Ordinal.{u}} (f : Ordinal.{u} → Ordinal.{u}) (hS : Set.Unbounded (fun x x_1 => x < x_1) S)
Goal: StrictMono f ∧ Set.range f = S ↔ f = Ordinal.enumOrd S
-- Ordinal.one_add_natCast
@[simp]
theorem one_add_natCast (m : ℕ) : 1 + (m : Ordinal) = succ m 
Arguments: (m : ℕ)
Goal: 1 + ↑m = ↑(Order.succ m)
-- Ordinal.one_add_ofNat
@[simp]
theorem one_add_ofNat (m : ℕ) [m.AtLeastTwo] :
    1 + (no_index (OfNat.ofNat m : Ordinal)) = Order.succ (OfNat.ofNat m : Ordinal) 
Arguments: (m : ℕ) [m.AtLeastTwo]
Goal: 1 + OfNat.ofNat m = Order.succ (OfNat.ofNat m)
-- Ordinal.natCast_mul
@[simp, norm_cast]
theorem natCast_mul (m : ℕ) : ∀ n : ℕ, ((m * n : ℕ) : Ordinal) = m * n
  
Arguments: (m n : ℕ)
Goal: ↑(m * n) = ↑m * ↑n
-- Ordinal.natCast_le
theorem natCast_le {m n : ℕ} : (m : Ordinal) ≤ n ↔ m ≤ n 
Arguments: {m n : ℕ}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Ordinal.natCast_inj
theorem natCast_inj {m n : ℕ} : (m : Ordinal) = n ↔ m = n 
Arguments: {m n : ℕ}
Goal: ↑m = ↑n ↔ m = n
-- Ordinal.natCast_lt
theorem natCast_lt {m n : ℕ} : (m : Ordinal) < n ↔ m < n 
Arguments: {m n : ℕ}
Goal: ↑m < ↑n ↔ m < n
-- Ordinal.natCast_eq_zero
theorem natCast_eq_zero {n : ℕ} : (n : Ordinal) = 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: ↑n = 0 ↔ n = 0
-- Ordinal.natCast_ne_zero
theorem natCast_ne_zero {n : ℕ} : (n : Ordinal) ≠ 0 ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Ordinal.natCast_pos
theorem natCast_pos {n : ℕ} : (0 : Ordinal) < n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < ↑n ↔ 0 < n
-- Ordinal.natCast_sub
@[simp, norm_cast]
theorem natCast_sub (m n : ℕ) : ((m - n : ℕ) : Ordinal) = m - n 
Arguments: (m n : ℕ)
Goal: ↑(m - n) = ↑m - ↑n
-- Ordinal.natCast_div
@[simp, norm_cast]
theorem natCast_div (m n : ℕ) : ((m / n : ℕ) : Ordinal) = m / n 
Arguments: (m n : ℕ)
Goal: ↑(m / n) = ↑m / ↑n
-- Ordinal.natCast_mod
@[simp, norm_cast]
theorem natCast_mod (m n : ℕ) : ((m % n : ℕ) : Ordinal) = m % n 
Arguments: (m n : ℕ)
Goal: ↑(m % n) = ↑m % ↑n
-- Ordinal.lift_natCast
@[simp]
theorem lift_natCast : ∀ n : ℕ, lift.{u, v} n = n
  
Arguments: (n : ℕ)
Goal: Ordinal.lift.{u, v} ↑n = ↑n
-- Ordinal.lift_ofNat
@[simp]
theorem lift_ofNat (n : ℕ) [n.AtLeastTwo] :
    lift.{u, v} (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: Ordinal.lift.{u, v} (OfNat.ofNat n) = OfNat.ofNat n
-- Cardinal.ord_aleph0
@[simp]
theorem ord_aleph0 : ord.{u} ℵ₀ = ω 
Goal: ℵ₀.ord = ω
-- Cardinal.add_one_of_aleph0_le
@[simp]
theorem add_one_of_aleph0_le {c} (h : ℵ₀ ≤ c) : c + 1 = c 
Arguments: {c : Cardinal.{u_1}} (h : ℵ₀ ≤ c)
Goal: c + 1 = c
-- Ordinal.lt_add_of_limit
theorem lt_add_of_limit {a b c : Ordinal.{u}} (h : IsLimit c) :
    a < b + c ↔ ∃ c' < c, a < b + c' 
Arguments: {a b c : Ordinal.{u}} (h : c.IsLimit)
Goal: a < b + c ↔ ∃ c' < c, a < b + c'
-- Ordinal.lt_omega
theorem lt_omega {o : Ordinal} : o < ω ↔ ∃ n : ℕ, o = n 
Arguments: {o : Ordinal.{u_1}}
Goal: o < ω ↔ ∃ n, o = ↑n
-- Ordinal.nat_lt_omega
theorem nat_lt_omega (n : ℕ) : ↑n < ω 
Arguments: (n : ℕ)
Goal: ↑n < ω
-- Ordinal.omega_pos
theorem omega_pos : 0 < ω 
Goal: 0 < ω
-- Ordinal.omega_ne_zero
theorem omega_ne_zero : ω ≠ 0 
Goal: ω ≠ 0
-- Ordinal.one_lt_omega
theorem one_lt_omega : 1 < ω 
Goal: 1 < ω
-- Ordinal.omega_isLimit
theorem omega_isLimit : IsLimit ω 
Goal: ω.IsLimit
-- Ordinal.omega_le
theorem omega_le {o : Ordinal} : ω ≤ o ↔ ∀ n : ℕ, ↑n ≤ o 
Arguments: {o : Ordinal.{u_1}}
Goal: ω ≤ o ↔ ∀ (n : ℕ), ↑n ≤ o
-- Ordinal.sup_natCast
@[simp]
theorem sup_natCast : sup Nat.cast = ω 
Goal: Ordinal.sup Nat.cast = ω
-- Ordinal.nat_lt_limit
theorem nat_lt_limit {o} (h : IsLimit o) : ∀ n : ℕ, ↑n < o
  
Arguments: {o : Ordinal.{u_1}} (h : o.IsLimit) (n : ℕ)
Goal: ↑n < o
-- Ordinal.omega_le_of_isLimit
theorem omega_le_of_isLimit {o} (h : IsLimit o) : ω ≤ o 
Arguments: {o : Ordinal.{u_1}} (h : o.IsLimit)
Goal: ω ≤ o
-- Ordinal.isLimit_iff_omega_dvd
theorem isLimit_iff_omega_dvd {a : Ordinal} : IsLimit a ↔ a ≠ 0 ∧ ω ∣ a 
Arguments: {a : Ordinal.{u_1}}
Goal: a.IsLimit ↔ a ≠ 0 ∧ ω ∣ a
-- Ordinal.add_mul_limit_aux
theorem add_mul_limit_aux {a b c : Ordinal} (ba : b + a = a) (l : IsLimit c)
    (IH : ∀ c' < c, (a + b) * succ c' = a * succ c' + b) : (a + b) * c = a * c 
Arguments: {a b c : Ordinal.{u_1}} (ba : b + a = a) (l : c.IsLimit) (IH : ∀ c' < c, (a + b) * Order.succ c' = a * Order.succ c' + b)
Goal: (a + b) * c = a * c
-- Ordinal.add_mul_succ
theorem add_mul_succ {a b : Ordinal} (c) (ba : b + a = a) : (a + b) * succ c = a * succ c + b 
Arguments: {a b : Ordinal.{u_1}} (c : Ordinal.{u_1}) (ba : b + a = a)
Goal: (a + b) * Order.succ c = a * Order.succ c + b
-- Ordinal.add_mul_limit
theorem add_mul_limit {a b c : Ordinal} (ba : b + a = a) (l : IsLimit c) : (a + b) * c = a * c 
Arguments: {a b c : Ordinal.{u_1}} (ba : b + a = a) (l : c.IsLimit)
Goal: (a + b) * c = a * c
-- Ordinal.add_le_of_forall_add_lt
theorem add_le_of_forall_add_lt {a b c : Ordinal} (hb : 0 < b) (h : ∀ d < b, a + d < c) :
    a + b ≤ c 
Arguments: {a b c : Ordinal.{u_1}} (hb : 0 < b) (h : ∀ d < b, a + d < c)
Goal: a + b ≤ c
-- Ordinal.IsNormal.apply_omega
theorem IsNormal.apply_omega {f : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f) :
    Ordinal.sup.{0, u} (f ∘ Nat.cast) = f ω 
Arguments: {f : Ordinal.{u} → Ordinal.{u}} (hf : Ordinal.IsNormal f)
Goal: Ordinal.sup (f ∘ Nat.cast) = f ω
-- Ordinal.sup_add_nat
@[simp]
theorem sup_add_nat (o : Ordinal) : (sup fun n : ℕ => o + n) = o + ω 
Arguments: (o : Ordinal.{u_1})
Goal: (Ordinal.sup fun n => o + ↑n) = o + ω
-- Ordinal.sup_mul_nat
@[simp]
theorem sup_mul_nat (o : Ordinal) : (sup fun n : ℕ => o * n) = o * ω 
Arguments: (o : Ordinal.{u_1})
Goal: (Ordinal.sup fun n => o * ↑n) = o * ω
-- Acc.rank_eq
theorem rank_eq (h : Acc r a) :
    h.rank = Ordinal.sup.{u, u} fun b : { b // r b a } => Order.succ (h.inv b.2).rank 
Arguments: {α : Type u} {r : α → α → Prop} {a : α} (h : Acc r a)
Goal: h.rank = Ordinal.sup fun b => Order.succ ⋯.rank
-- Acc.rank_lt_of_rel
theorem rank_lt_of_rel (hb : Acc r b) (h : r a b) : (hb.inv h).rank < hb.rank 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (hb : Acc r b) (h : r a b)
Goal: ⋯.rank < hb.rank
-- WellFounded.rank_eq
theorem rank_eq :
    hwf.rank a = Ordinal.sup.{u, u} fun b : { b // r b a } => Order.succ <| hwf.rank b 
Arguments: {α : Type u} {r : α → α → Prop} {a : α} (hwf : WellFounded r)
Goal: hwf.rank a = Ordinal.sup fun b => Order.succ (hwf.rank ↑b)
-- WellFounded.rank_lt_of_rel
theorem rank_lt_of_rel (h : r a b) : hwf.rank a < hwf.rank b 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (hwf : WellFounded r) (h : r a b)
Goal: hwf.rank a < hwf.rank b
-- WellFounded.rank_strictMono
theorem rank_strictMono [Preorder α] [WellFoundedLT α] :
    StrictMono (rank <| @wellFounded_lt α _ _) 
Arguments: {α : Type u} [Preorder α] [WellFoundedLT α]
Goal: StrictMono ⋯.rank
-- WellFounded.rank_strictAnti
theorem rank_strictAnti [Preorder α] [WellFoundedGT α] :
    StrictAnti (rank <| @wellFounded_gt α _ _) 
Arguments: {α : Type u} [Preorder α] [WellFoundedGT α]
Goal: StrictAnti ⋯.rank
-- SimpleGraph.isSymm_degMatrix
theorem isSymm_degMatrix [AddMonoidWithOne R] : (G.degMatrix R).IsSymm 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [AddMonoidWithOne R]
Goal: (SimpleGraph.degMatrix R G).IsSymm
-- SimpleGraph.isSymm_lapMatrix
theorem isSymm_lapMatrix [AddGroupWithOne R] : (G.lapMatrix R).IsSymm 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [AddGroupWithOne R]
Goal: (SimpleGraph.lapMatrix R G).IsSymm
-- SimpleGraph.degMatrix_mulVec_apply
theorem degMatrix_mulVec_apply [NonAssocSemiring R] (v : V) (vec : V → R) :
    (G.degMatrix R *ᵥ vec) v = G.degree v * vec v 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [NonAssocSemiring R] (v : V) (vec : V → R)
Goal: (SimpleGraph.degMatrix R G *ᵥ vec) v = ↑(G.degree v) * vec v
-- SimpleGraph.lapMatrix_mulVec_apply
theorem lapMatrix_mulVec_apply [NonAssocRing R] (v : V) (vec : V → R) :
    (G.lapMatrix R *ᵥ vec) v = G.degree v * vec v - ∑ u ∈ G.neighborFinset v, vec u 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [NonAssocRing R] (v : V) (vec : V → R)
Goal: (SimpleGraph.lapMatrix R G *ᵥ vec) v = ↑(G.degree v) * vec v - ∑ u ∈ G.neighborFinset v, vec u
-- SimpleGraph.lapMatrix_mulVec_const_eq_zero
theorem lapMatrix_mulVec_const_eq_zero [Ring R] : mulVec (G.lapMatrix R) (fun _ ↦ 1) = 0 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [Ring R]
Goal: (SimpleGraph.lapMatrix R G *ᵥ fun x => 1) = 0
-- SimpleGraph.dotProduct_mulVec_degMatrix
theorem dotProduct_mulVec_degMatrix [CommRing R] (x : V → R) :
    x ⬝ᵥ (G.degMatrix R *ᵥ x) = ∑ i : V, G.degree i * x i * x i 
Arguments: {V : Type u_1} {R : Type u_2} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [CommRing R] (x : V → R)
Goal: x ⬝ᵥ SimpleGraph.degMatrix R G *ᵥ x = ∑ i : V, ↑(G.degree i) * x i * x i
-- SimpleGraph.degree_eq_sum_if_adj
theorem degree_eq_sum_if_adj [AddCommMonoidWithOne R] (i : V) :
    (G.degree i : R) = ∑ j : V, if G.Adj i j then 1 else 0 
Arguments: {V : Type u_1} (R : Type u_2) [Fintype V] (G : SimpleGraph V) [DecidableRel G.Adj] [AddCommMonoidWithOne R] (i : V)
Goal: ↑(G.degree i) = ∑ j : V, if G.Adj i j then 1 else 0
-- SimpleGraph.lapMatrix_toLinearMap₂'
theorem lapMatrix_toLinearMap₂' [Field R] [CharZero R] (x : V → R) :
    toLinearMap₂' R (G.lapMatrix R) x x =
    (∑ i : V, ∑ j : V, if G.Adj i j then (x i - x j)^2 else 0) / 2 
Arguments: {V : Type u_1} (R : Type u_2) [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [Field R] [CharZero R] (x : V → R)
Goal: (((Matrix.toLinearMap₂' R) (SimpleGraph.lapMatrix R G)) x) x =
  (∑ i : V, ∑ j : V, if G.Adj i j then (x i - x j) ^ 2 else 0) / 2
-- SimpleGraph.posSemidef_lapMatrix
theorem posSemidef_lapMatrix [LinearOrderedField R] [StarRing R]
    [TrivialStar R] : PosSemidef (G.lapMatrix R) 
Arguments: {V : Type u_1} (R : Type u_2) [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [LinearOrderedField R] [StarRing R] [TrivialStar R]
Goal: (SimpleGraph.lapMatrix R G).PosSemidef
-- SimpleGraph.lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj
theorem lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj [LinearOrderedField R] (x : V → R) :
    Matrix.toLinearMap₂' R (G.lapMatrix R) x x = 0 ↔ ∀ i j : V, G.Adj i j → x i = x j 
Arguments: {V : Type u_1} (R : Type u_2) [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [LinearOrderedField R] (x : V → R)
Goal: (((Matrix.toLinearMap₂' R) (SimpleGraph.lapMatrix R G)) x) x = 0 ↔ ∀ (i j : V), G.Adj i j → x i = x j
-- SimpleGraph.lapMatrix_toLin'_apply_eq_zero_iff_forall_adj
theorem lapMatrix_toLin'_apply_eq_zero_iff_forall_adj (x : V → ℝ) :
    Matrix.toLin' (G.lapMatrix ℝ) x = 0 ↔ ∀ i j : V, G.Adj i j → x i = x j 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] (x : V → ℝ)
Goal: (Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)) x = 0 ↔ ∀ (i j : V), G.Adj i j → x i = x j
-- SimpleGraph.lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_reachable
theorem lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_reachable (x : V → ℝ) :
    Matrix.toLinearMap₂' ℝ (G.lapMatrix ℝ) x x = 0 ↔
      ∀ i j : V, G.Reachable i j → x i = x j 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] (x : V → ℝ)
Goal: (((Matrix.toLinearMap₂' ℝ) (SimpleGraph.lapMatrix ℝ G)) x) x = 0 ↔ ∀ (i j : V), G.Reachable i j → x i = x j
-- SimpleGraph.lapMatrix_toLin'_apply_eq_zero_iff_forall_reachable
theorem lapMatrix_toLin'_apply_eq_zero_iff_forall_reachable (x : V → ℝ) :
    Matrix.toLin' (G.lapMatrix ℝ) x = 0 ↔ ∀ i j : V, G.Reachable i j → x i = x j 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] (x : V → ℝ)
Goal: (Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)) x = 0 ↔ ∀ (i j : V), G.Reachable i j → x i = x j
-- SimpleGraph.mem_ker_toLin'_lapMatrix_of_connectedComponent
lemma mem_ker_toLin'_lapMatrix_of_connectedComponent {G : SimpleGraph V} [DecidableRel G.Adj]
    [DecidableEq G.ConnectedComponent] (c : G.ConnectedComponent) :
    (fun i ↦ if connectedComponentMk G i = c then 1 else 0) ∈
      LinearMap.ker (toLin' (lapMatrix ℝ G)) 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] {G : SimpleGraph V} [DecidableRel G.Adj] [DecidableEq G.ConnectedComponent] (c : G.ConnectedComponent)
Goal: (fun i => if G.connectedComponentMk i = c then 1 else 0) ∈ LinearMap.ker (Matrix.toLin' (SimpleGraph.lapMatrix ℝ G))
-- SimpleGraph.linearIndependent_lapMatrix_ker_basis_aux
lemma linearIndependent_lapMatrix_ker_basis_aux :
    LinearIndependent ℝ (lapMatrix_ker_basis_aux G) 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [DecidableEq G.ConnectedComponent]
Goal: LinearIndependent ℝ G.lapMatrix_ker_basis_aux
-- SimpleGraph.top_le_span_range_lapMatrix_ker_basis_aux
lemma top_le_span_range_lapMatrix_ker_basis_aux :
    ⊤ ≤ Submodule.span ℝ (Set.range (lapMatrix_ker_basis_aux G)) 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] [DecidableEq G.ConnectedComponent]
Goal: ⊤ ≤ Submodule.span ℝ (Set.range G.lapMatrix_ker_basis_aux)
-- SimpleGraph.card_ConnectedComponent_eq_rank_ker_lapMatrix
theorem card_ConnectedComponent_eq_rank_ker_lapMatrix : Fintype.card G.ConnectedComponent =
    FiniteDimensional.finrank ℝ (LinearMap.ker (Matrix.toLin' (G.lapMatrix ℝ))) 
Arguments: {V : Type u_1} [Fintype V] [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj]
Goal: Fintype.card G.ConnectedComponent =
  FiniteDimensional.finrank ℝ ↥(LinearMap.ker (Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)))
-- Finset.mulDysonETransform_fst
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [CommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.mulDysonETransform e x).1 = x.1 ∪ e • x.2
-- Finset.addDysonETransform_snd
@[to_additive (attr := simps) "The **Dyson e-transform**.
Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
def mulDysonETransform : Finset α × Finset α 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommGroup α] (e : α) (x : Finset α × Finset α)
Goal: (Finset.addDysonETransform e x).2 = x.2 ∩ (-e +ᵥ x.1)