ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- EuclideanDomain.dvd_div_of_mul_dvd
theorem dvd_div_of_mul_dvd {a b c : R} (h : a * b ∣ c) : b ∣ c / a 
Arguments: {R : Type u} [EuclideanDomain R] {a b c : R} (h : a * b ∣ c)
Goal: b ∣ c / a
-- EuclideanDomain.gcd_zero_right
@[simp]
theorem gcd_zero_right (a : R) : gcd a 0 = a 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a : R)
Goal: EuclideanDomain.gcd a 0 = a
-- EuclideanDomain.gcd_val
theorem gcd_val (a b : R) : gcd a b = gcd (b % a) a 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R)
Goal: EuclideanDomain.gcd a b = EuclideanDomain.gcd (b % a) a
-- EuclideanDomain.gcd_dvd
theorem gcd_dvd (a b : R) : gcd a b ∣ a ∧ gcd a b ∣ b 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R)
Goal: EuclideanDomain.gcd a b ∣ a ∧ EuclideanDomain.gcd a b ∣ b
-- EuclideanDomain.gcd_dvd_left
theorem gcd_dvd_left (a b : R) : gcd a b ∣ a 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R)
Goal: EuclideanDomain.gcd a b ∣ a
-- EuclideanDomain.gcd_dvd_right
theorem gcd_dvd_right (a b : R) : gcd a b ∣ b 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R)
Goal: EuclideanDomain.gcd a b ∣ b
-- EuclideanDomain.gcd_eq_zero_iff
protected theorem gcd_eq_zero_iff {a b : R} : gcd a b = 0 ↔ a = 0 ∧ b = 0 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {a b : R}
Goal: EuclideanDomain.gcd a b = 0 ↔ a = 0 ∧ b = 0
-- EuclideanDomain.dvd_gcd
theorem dvd_gcd {a b c : R} : c ∣ a → c ∣ b → c ∣ gcd a b 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {a b c : R}
Goal: c ∣ a → c ∣ b → c ∣ EuclideanDomain.gcd a b
-- EuclideanDomain.gcd_eq_left
theorem gcd_eq_left {a b : R} : gcd a b = a ↔ a ∣ b 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {a b : R}
Goal: EuclideanDomain.gcd a b = a ↔ a ∣ b
-- EuclideanDomain.gcd_one_left
@[simp]
theorem gcd_one_left (a : R) : gcd 1 a = 1 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a : R)
Goal: EuclideanDomain.gcd 1 a = 1
-- EuclideanDomain.gcd_self
@[simp]
theorem gcd_self (a : R) : gcd a a = a 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a : R)
Goal: EuclideanDomain.gcd a a = a
-- EuclideanDomain.xgcdAux_fst
@[simp]
theorem xgcdAux_fst (x y : R) : ∀ s t s' t', (xgcdAux x s t y s' t').1 = gcd x y 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y s t s' t' : R)
Goal: (EuclideanDomain.xgcdAux x s t y s' t').1 = EuclideanDomain.gcd x y
-- EuclideanDomain.xgcdAux_val
theorem xgcdAux_val (x y : R) : xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y) 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y : R)
Goal: EuclideanDomain.xgcdAux x 1 0 y 0 1 = (EuclideanDomain.gcd x y, EuclideanDomain.xgcd x y)
-- EuclideanDomain.xgcdAux_P
theorem xgcdAux_P (a b : R) {r r' : R} {s t s' t'} (p : P a b (r, s, t))
    (p' : P a b (r', s', t')) : P a b (xgcdAux r s t r' s' t') 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R) {r r' s t s' t' : R} (p : EuclideanDomain.P a b (r, s, t)) (p' : EuclideanDomain.P a b (r', s', t'))
Goal: EuclideanDomain.P a b (EuclideanDomain.xgcdAux r s t r' s' t')
-- EuclideanDomain.gcd_eq_gcd_ab
theorem gcd_eq_gcd_ab (a b : R) : (gcd a b : R) = a * gcdA a b + b * gcdB a b 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (a b : R)
Goal: EuclideanDomain.gcd a b = a * EuclideanDomain.gcdA a b + b * EuclideanDomain.gcdB a b
-- EuclideanDomain.dvd_lcm_left
theorem dvd_lcm_left (x y : R) : x ∣ lcm x y 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y : R)
Goal: x ∣ EuclideanDomain.lcm x y
-- EuclideanDomain.dvd_lcm_right
theorem dvd_lcm_right (x y : R) : y ∣ lcm x y 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y : R)
Goal: y ∣ EuclideanDomain.lcm x y
-- EuclideanDomain.lcm_dvd
theorem lcm_dvd {x y z : R} (hxz : x ∣ z) (hyz : y ∣ z) : lcm x y ∣ z 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {x y z : R} (hxz : x ∣ z) (hyz : y ∣ z)
Goal: EuclideanDomain.lcm x y ∣ z
-- EuclideanDomain.lcm_dvd_iff
@[simp]
theorem lcm_dvd_iff {x y z : R} : lcm x y ∣ z ↔ x ∣ z ∧ y ∣ z 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {x y z : R}
Goal: EuclideanDomain.lcm x y ∣ z ↔ x ∣ z ∧ y ∣ z
-- EuclideanDomain.lcm_zero_left
@[simp]
theorem lcm_zero_left (x : R) : lcm 0 x = 0 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x : R)
Goal: EuclideanDomain.lcm 0 x = 0
-- EuclideanDomain.lcm_zero_right
@[simp]
theorem lcm_zero_right (x : R) : lcm x 0 = 0 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x : R)
Goal: EuclideanDomain.lcm x 0 = 0
-- EuclideanDomain.lcm_eq_zero_iff
@[simp]
theorem lcm_eq_zero_iff {x y : R} : lcm x y = 0 ↔ x = 0 ∨ y = 0 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] {x y : R}
Goal: EuclideanDomain.lcm x y = 0 ↔ x = 0 ∨ y = 0
-- EuclideanDomain.gcd_mul_lcm
@[simp]
theorem gcd_mul_lcm (x y : R) : gcd x y * lcm x y = x * y 
Arguments: {R : Type u} [EuclideanDomain R] [DecidableEq R] (x y : R)
Goal: EuclideanDomain.gcd x y * EuclideanDomain.lcm x y = x * y
-- EuclideanDomain.mul_div_mul_cancel
theorem mul_div_mul_cancel {a b c : R} (ha : a ≠ 0) (hcb : c ∣ b) : a * b / (a * c) = b / c 
Arguments: {R : Type u} [EuclideanDomain R] {a b c : R} (ha : a ≠ 0) (hcb : c ∣ b)
Goal: a * b / (a * c) = b / c
-- EuclideanDomain.mul_div_mul_comm_of_dvd_dvd
theorem mul_div_mul_comm_of_dvd_dvd {a b c d : R} (hac : c ∣ a) (hbd : d ∣ b) :
    a * b / (c * d) = a / c * (b / d) 
Arguments: {R : Type u} [EuclideanDomain R] {a b c d : R} (hac : c ∣ a) (hbd : d ∣ b)
Goal: a * b / (c * d) = a / c * (b / d)
-- FreeNonUnitalNonAssocAlgebra.lift_symm_apply
@[simp]
theorem lift_symm_apply (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
    (lift R).symm F = F ∘ of R 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A)
Goal: (FreeNonUnitalNonAssocAlgebra.lift R).symm F = ⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R
-- FreeNonUnitalNonAssocAlgebra.of_comp_lift
@[simp]
theorem of_comp_lift (f : X → A) : lift R f ∘ of R = f 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : X → A)
Goal: ⇑((FreeNonUnitalNonAssocAlgebra.lift R) f) ∘ FreeNonUnitalNonAssocAlgebra.of R = f
-- FreeNonUnitalNonAssocAlgebra.lift_unique
@[simp]
theorem lift_unique (f : X → A) (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
    F ∘ of R = f ↔ F = lift R f 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : X → A) (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A)
Goal: ⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R = f ↔ F = (FreeNonUnitalNonAssocAlgebra.lift R) f
-- FreeNonUnitalNonAssocAlgebra.lift_of_apply
@[simp]
theorem lift_of_apply (f : X → A) (x) : lift R f (of R x) = f x 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (f : X → A) (x : X)
Goal: ((FreeNonUnitalNonAssocAlgebra.lift R) f) (FreeNonUnitalNonAssocAlgebra.of R x) = f x
-- FreeNonUnitalNonAssocAlgebra.lift_comp_of
@[simp]
theorem lift_comp_of (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) : lift R (F ∘ of R) = F 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A)
Goal: (FreeNonUnitalNonAssocAlgebra.lift R) (⇑F ∘ FreeNonUnitalNonAssocAlgebra.of R) = F
-- FreeNonUnitalNonAssocAlgebra.hom_ext
@[ext]
theorem hom_ext {F₁ F₂ : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A}
    (h : ∀ x, F₁ (of R x) = F₂ (of R x)) : F₁ = F₂ 
Arguments: (R : Type u) {X : Type v} [Semiring R] {A : Type w} [NonUnitalNonAssocSemiring A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] {F₁ F₂ : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A} (h : ∀ (x : X), F₁ (FreeNonUnitalNonAssocAlgebra.of R x) = F₂ (FreeNonUnitalNonAssocAlgebra.of R x))
Goal: F₁ = F₂
-- LinearRecurrence.is_sol_mkSol
theorem is_sol_mkSol (init : Fin E.order → α) : E.IsSolution (E.mkSol init) 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) (init : Fin E.order → α)
Goal: E.IsSolution (E.mkSol init)
-- LinearRecurrence.mkSol_eq_init
theorem mkSol_eq_init (init : Fin E.order → α) : ∀ n : Fin E.order, E.mkSol init n = init n 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) (init : Fin E.order → α) (n : Fin E.order)
Goal: E.mkSol init ↑n = init n
-- LinearRecurrence.eq_mk_of_is_sol_of_eq_init
theorem eq_mk_of_is_sol_of_eq_init {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u)
    (heq : ∀ n : Fin E.order, u n = init n) : ∀ n, u n = E.mkSol init n 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u) (heq : ∀ (n : Fin E.order), u ↑n = init n) (n : ℕ)
Goal: u n = E.mkSol init n
-- LinearRecurrence.eq_mk_of_is_sol_of_eq_init'
theorem eq_mk_of_is_sol_of_eq_init' {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u)
    (heq : ∀ n : Fin E.order, u n = init n) : u = E.mkSol init 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u) (heq : ∀ (n : Fin E.order), u ↑n = init n)
Goal: u = E.mkSol init
-- LinearRecurrence.is_sol_iff_mem_solSpace
theorem is_sol_iff_mem_solSpace (u : ℕ → α) : E.IsSolution u ↔ u ∈ E.solSpace 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) (u : ℕ → α)
Goal: E.IsSolution u ↔ u ∈ E.solSpace
-- LinearRecurrence.sol_eq_of_eq_init
theorem sol_eq_of_eq_init (u v : ℕ → α) (hu : E.IsSolution u) (hv : E.IsSolution v) :
    u = v ↔ Set.EqOn u v ↑(range E.order) 
Arguments: {α : Type u_1} [CommSemiring α] (E : LinearRecurrence α) (u v : ℕ → α) (hu : E.IsSolution u) (hv : E.IsSolution v)
Goal: u = v ↔ Set.EqOn u v ↑(Finset.range E.order)
-- LinearRecurrence.solSpace_rank
theorem solSpace_rank : Module.rank α E.solSpace = E.order 
Arguments: {α : Type u_1} [CommRing α] [StrongRankCondition α] (E : LinearRecurrence α)
Goal: Module.rank α ↥E.solSpace = ↑E.order
-- LinearRecurrence.geom_sol_iff_root_charPoly
theorem geom_sol_iff_root_charPoly (q : α) :
    (E.IsSolution fun n ↦ q ^ n) ↔ E.charPoly.IsRoot q 
Arguments: {α : Type u_1} [CommRing α] (E : LinearRecurrence α) (q : α)
Goal: (E.IsSolution fun n => q ^ n) ↔ E.charPoly.IsRoot q
-- Commute.div_eq_div_iff
protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
    a / b = c / d ↔ a * d = c * b 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {a b c d : G₀} (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0)
Goal: a / b = c / d ↔ a * d = c * b
-- map_ne_zero
theorem map_ne_zero : f a ≠ 0 ↔ a ≠ 0 
Arguments: {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [MonoidWithZero M₀] [GroupWithZero G₀] [Nontrivial M₀] [FunLike F G₀ M₀] [MonoidWithZeroHomClass F G₀ M₀] (f : F) {a : G₀}
Goal: f a ≠ 0 ↔ a ≠ 0
-- map_eq_zero
@[simp]
theorem map_eq_zero : f a = 0 ↔ a = 0 
Arguments: {M₀ : Type u_2} {G₀ : Type u_3} {F : Type u_6} [MonoidWithZero M₀] [GroupWithZero G₀] [Nontrivial M₀] [FunLike F G₀ M₀] [MonoidWithZeroHomClass F G₀ M₀] (f : F) {a : G₀}
Goal: f a = 0 ↔ a = 0
-- eq_on_inv₀
theorem eq_on_inv₀ [MonoidWithZeroHomClass F' G₀ M₀'] (f g : F') (h : f a = g a) :
    f a⁻¹ = g a⁻¹ 
Arguments: {G₀ : Type u_3} {M₀' : Type u_4} {F' : Type u_7} [GroupWithZero G₀] [MonoidWithZero M₀'] [FunLike F' G₀ M₀'] {a : G₀} [MonoidWithZeroHomClass F' G₀ M₀'] (f g : F') (h : f a = g a)
Goal: f a⁻¹ = g a⁻¹
-- map_inv₀
@[simp]
theorem map_inv₀ : f a⁻¹ = (f a)⁻¹ 
Arguments: {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀)
Goal: f a⁻¹ = (f a)⁻¹
-- map_div₀
@[simp]
theorem map_div₀ : f (a / b) = f a / f b 
Arguments: {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a b : G₀)
Goal: f (a / b) = f a / f b
-- MonoidWithZero.coe_inverse
@[simp]
theorem MonoidWithZero.coe_inverse {M : Type*} [CommMonoidWithZero M] :
    (MonoidWithZero.inverse : M → M) = Ring.inverse 
Arguments: {M : Type u_8} [CommMonoidWithZero M]
Goal: ⇑MonoidWithZero.inverse = Ring.inverse
-- MonoidWithZero.inverse_apply
@[simp]
theorem MonoidWithZero.inverse_apply {M : Type*} [CommMonoidWithZero M] (a : M) :
    MonoidWithZero.inverse a = Ring.inverse a 
Arguments: {M : Type u_8} [CommMonoidWithZero M] (a : M)
Goal: MonoidWithZero.inverse a = Ring.inverse a
-- Units.smul_mk0
@[simp]
theorem smul_mk0 {α : Type*} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α) : mk0 g hg • a = g • a 
Arguments: {G₀ : Type u_3} [GroupWithZero G₀] {α : Type u_8} [SMul G₀ α] {g : G₀} (hg : g ≠ 0) (a : α)
Goal: Units.mk0 g hg • a = g • a
-- map_zpow₀
@[simp]
theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀']
    [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ) : f (x ^ n) = f x ^ n 
Arguments: {F : Type u_8} {G₀ : Type u_9} {G₀' : Type u_10} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ)
Goal: f (x ^ n) = f x ^ n
-- isConj_iff₀
@[simp] lemma isConj_iff₀ : IsConj a b ↔ ∃ c : α, c ≠ 0 ∧ c * a * c⁻¹ = b 
Arguments: {α : Type u_1} [GroupWithZero α] {a b : α}
Goal: IsConj a b ↔ ∃ c, c ≠ 0 ∧ c * a * c⁻¹ = b
-- Equiv.mulLeft₀_apply
@[simps! (config := .asFn)]
protected def mulLeft₀ (a : G) (ha : a ≠ 0) : Perm G 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: ⇑(Equiv.mulLeft₀ a ha) = fun x => a * x
-- Equiv.mulLeft₀_symm_apply
@[simps! (config := .asFn)]
protected def mulLeft₀ (a : G) (ha : a ≠ 0) : Perm G 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: ⇑(Equiv.symm (Equiv.mulLeft₀ a ha)) = fun x => a⁻¹ * x
-- mulLeft_bijective₀
theorem _root_.mulLeft_bijective₀ (a : G) (ha : a ≠ 0) : Function.Bijective (a * · : G → G) 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: Function.Bijective fun x => a * x
-- Equiv.mulRight₀_apply
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: ⇑(Equiv.mulRight₀ a ha) = fun x => x * a
-- Equiv.mulRight₀_symm_apply
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: ⇑(Equiv.symm (Equiv.mulRight₀ a ha)) = fun x => x * a⁻¹
-- mulRight_bijective₀
theorem _root_.mulRight_bijective₀ (a : G) (ha : a ≠ 0) : Function.Bijective ((· * a) : G → G) 
Arguments: {G : Type u_1} [GroupWithZero G] (a : G) (ha : a ≠ 0)
Goal: Function.Bijective fun x => x * a
-- LieAlgebra.derivedSeriesOfIdeal_zero
@[simp]
theorem derivedSeriesOfIdeal_zero : derivedSeriesOfIdeal R L 0 I = I 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: LieAlgebra.derivedSeriesOfIdeal R L 0 I = I
-- LieAlgebra.derivedSeriesOfIdeal_succ
@[simp]
theorem derivedSeriesOfIdeal_succ (k : ℕ) :
    derivedSeriesOfIdeal R L (k + 1) I =
      ⁅derivedSeriesOfIdeal R L k I, derivedSeriesOfIdeal R L k I⁆ 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I =
  ⁅LieAlgebra.derivedSeriesOfIdeal R L k I, LieAlgebra.derivedSeriesOfIdeal R L k I⁆
-- LieAlgebra.derivedSeries_def
theorem derivedSeries_def (k : ℕ) : derivedSeries R L k = derivedSeriesOfIdeal R L k ⊤ 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (k : ℕ)
Goal: LieAlgebra.derivedSeries R L k = LieAlgebra.derivedSeriesOfIdeal R L k ⊤
-- LieAlgebra.derivedSeriesOfIdeal_add
theorem derivedSeriesOfIdeal_add (k l : ℕ) : D (k + l) I = D k (D l I) 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k l : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L (k + l) I =
  LieAlgebra.derivedSeriesOfIdeal R L k (LieAlgebra.derivedSeriesOfIdeal R L l I)
-- LieAlgebra.derivedSeriesOfIdeal_le
@[mono]
theorem derivedSeriesOfIdeal_le {I J : LieIdeal R L} {k l : ℕ} (h₁ : I ≤ J) (h₂ : l ≤ k) :
    D k I ≤ D l J 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I J : LieIdeal R L} {k l : ℕ} (h₁ : I ≤ J) (h₂ : l ≤ k)
Goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L l J
-- LieAlgebra.derivedSeriesOfIdeal_succ_le
theorem derivedSeriesOfIdeal_succ_le (k : ℕ) : D (k + 1) I ≤ D k I 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I ≤ LieAlgebra.derivedSeriesOfIdeal R L k I
-- LieAlgebra.derivedSeriesOfIdeal_le_self
theorem derivedSeriesOfIdeal_le_self (k : ℕ) : D k I ≤ I 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ I
-- LieAlgebra.derivedSeriesOfIdeal_mono
theorem derivedSeriesOfIdeal_mono {I J : LieIdeal R L} (h : I ≤ J) (k : ℕ) : D k I ≤ D k J 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I J : LieIdeal R L} (h : I ≤ J) (k : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L k J
-- LieAlgebra.derivedSeriesOfIdeal_antitone
theorem derivedSeriesOfIdeal_antitone {k l : ℕ} (h : l ≤ k) : D k I ≤ D l I 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) {k l : ℕ} (h : l ≤ k)
Goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L l I
-- LieAlgebra.derivedSeriesOfIdeal_add_le_add
theorem derivedSeriesOfIdeal_add_le_add (J : LieIdeal R L) (k l : ℕ) :
    D (k + l) (I + J) ≤ D k I + D l J 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I J : LieIdeal R L) (k l : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L (k + l) (I + J) ≤
  LieAlgebra.derivedSeriesOfIdeal R L k I + LieAlgebra.derivedSeriesOfIdeal R L l J
-- LieAlgebra.derivedSeries_of_bot_eq_bot
theorem derivedSeries_of_bot_eq_bot (k : ℕ) : derivedSeriesOfIdeal R L k ⊥ = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (k : ℕ)
Goal: LieAlgebra.derivedSeriesOfIdeal R L k ⊥ = ⊥
-- LieAlgebra.abelian_iff_derived_one_eq_bot
theorem abelian_iff_derived_one_eq_bot : IsLieAbelian I ↔ derivedSeriesOfIdeal R L 1 I = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: IsLieAbelian ↥↑I ↔ LieAlgebra.derivedSeriesOfIdeal R L 1 I = ⊥
-- LieAlgebra.abelian_iff_derived_succ_eq_bot
theorem abelian_iff_derived_succ_eq_bot (I : LieIdeal R L) (k : ℕ) :
    IsLieAbelian (derivedSeriesOfIdeal R L k I) ↔ derivedSeriesOfIdeal R L (k + 1) I = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: IsLieAbelian ↥↑(LieAlgebra.derivedSeriesOfIdeal R L k I) ↔ LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I = ⊥
-- LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_comap
theorem derivedSeries_eq_derivedSeriesOfIdeal_comap (k : ℕ) :
    derivedSeries R I k = (derivedSeriesOfIdeal R L k I).comap I.incl 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedSeries R (↥↑I) k = LieIdeal.comap I.incl (LieAlgebra.derivedSeriesOfIdeal R L k I)
-- LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_map
theorem derivedSeries_eq_derivedSeriesOfIdeal_map (k : ℕ) :
    (derivedSeries R I k).map I.incl = derivedSeriesOfIdeal R L k I 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieIdeal.map I.incl (LieAlgebra.derivedSeries R (↥↑I) k) = LieAlgebra.derivedSeriesOfIdeal R L k I
-- LieIdeal.derivedSeries_eq_bot_iff
theorem derivedSeries_eq_bot_iff (k : ℕ) :
    derivedSeries R I k = ⊥ ↔ derivedSeriesOfIdeal R L k I = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (k : ℕ)
Goal: LieAlgebra.derivedSeries R (↥↑I) k = ⊥ ↔ LieAlgebra.derivedSeriesOfIdeal R L k I = ⊥
-- LieIdeal.derivedSeries_add_eq_bot
theorem derivedSeries_add_eq_bot {k l : ℕ} {I J : LieIdeal R L} (hI : derivedSeries R I k = ⊥)
    (hJ : derivedSeries R J l = ⊥) : derivedSeries R (I + J) (k + l) = ⊥ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {k l : ℕ} {I J : LieIdeal R L} (hI : LieAlgebra.derivedSeries R (↥↑I) k = ⊥) (hJ : LieAlgebra.derivedSeries R (↥↑J) l = ⊥)
Goal: LieAlgebra.derivedSeries R (↥↑(I + J)) (k + l) = ⊥
-- LieIdeal.derivedSeries_map_le
theorem derivedSeries_map_le (k : ℕ) : (derivedSeries R L' k).map f ≤ derivedSeries R L k 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L' →ₗ⁅R⁆ L} (k : ℕ)
Goal: LieIdeal.map f (LieAlgebra.derivedSeries R L' k) ≤ LieAlgebra.derivedSeries R L k
-- LieIdeal.derivedSeries_map_eq
theorem derivedSeries_map_eq (k : ℕ) (h : Function.Surjective f) :
    (derivedSeries R L' k).map f = derivedSeries R L k 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L' →ₗ⁅R⁆ L} (k : ℕ) (h : Function.Surjective ⇑f)
Goal: LieIdeal.map f (LieAlgebra.derivedSeries R L' k) = LieAlgebra.derivedSeries R L k
-- LieIdeal.derivedSeries_succ_eq_top_iff
theorem derivedSeries_succ_eq_top_iff (n : ℕ) :
    derivedSeries R L (n + 1) = ⊤ ↔ derivedSeries R L 1 = ⊤ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (n : ℕ)
Goal: LieAlgebra.derivedSeries R L (n + 1) = ⊤ ↔ LieAlgebra.derivedSeries R L 1 = ⊤
-- LieIdeal.derivedSeries_eq_top
theorem derivedSeries_eq_top (n : ℕ) (h : derivedSeries R L 1 = ⊤) :
    derivedSeries R L n = ⊤ 
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (n : ℕ) (h : LieAlgebra.derivedSeries R L 1 = ⊤)
Goal: LieAlgebra.derivedSeries R L n = ⊤
-- LieAlgebra.IsSolvable.solvable
class IsSolvable : Prop where
  solvable : ∃ k, derivedSeries R L k = ⊥
Arguments: {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] [self : LieAlgebra.IsSolvable R L]
Goal: ∃ k, LieAlgebra.derivedSeries R L k = ⊥
-- LieAlgebra.derivedSeries_lt_top_of_solvable
theorem derivedSeries_lt_top_of_solvable [IsSolvable R L] [Nontrivial L] :
    derivedSeries R L 1 < ⊤ 
Arguments: (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] [LieAlgebra.IsSolvable R L] [Nontrivial L]
Goal: LieAlgebra.derivedSeries R L 1 < ⊤
-- Function.Injective.lieAlgebra_isSolvable
theorem Injective.lieAlgebra_isSolvable [h₁ : IsSolvable R L] (h₂ : Injective f) :
    IsSolvable R L' 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L' →ₗ⁅R⁆ L} [h₁ : LieAlgebra.IsSolvable R L] (h₂ : Function.Injective ⇑f)
Goal: LieAlgebra.IsSolvable R L'
-- Function.Surjective.lieAlgebra_isSolvable
theorem Surjective.lieAlgebra_isSolvable [h₁ : IsSolvable R L'] (h₂ : Surjective f) :
    IsSolvable R L 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L' →ₗ⁅R⁆ L} [h₁ : LieAlgebra.IsSolvable R L'] (h₂ : Function.Surjective ⇑f)
Goal: LieAlgebra.IsSolvable R L
-- LieHom.isSolvable_range
theorem LieHom.isSolvable_range (f : L' →ₗ⁅R⁆ L) [LieAlgebra.IsSolvable R L'] :
    LieAlgebra.IsSolvable R f.range 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L' →ₗ⁅R⁆ L) [LieAlgebra.IsSolvable R L']
Goal: LieAlgebra.IsSolvable R ↥f.range
-- LieAlgebra.solvable_iff_equiv_solvable
theorem solvable_iff_equiv_solvable (e : L' ≃ₗ⁅R⁆ L) : IsSolvable R L' ↔ IsSolvable R L 
Arguments: {R : Type u} {L : Type v} {L' : Type w₁} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (e : L' ≃ₗ⁅R⁆ L)
Goal: LieAlgebra.IsSolvable R L' ↔ LieAlgebra.IsSolvable R L