ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LieSubmodule.traceForm_eq_zero_of_isTrivial
lemma traceForm_eq_zero_of_isTrivial [LieModule.IsTrivial I N] :
    trace R M (φ x ∘ₗ φ y) = 0 
Arguments: {R : Type u_1} {L : Type u_3} {M : Type u_4} [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] [Module.Free R M] [Module.Finite R M] [IsDomain R] [IsPrincipalIdealRing R] (N : LieSubmodule R L M) (I : LieIdeal R L) (h : I ≤ N.idealizer) (x : L) {y : L} (hy : y ∈ I) [LieModule.IsTrivial ↥↑I ↥↑N]
Goal: (LinearMap.trace R M) (φ x ∘ₗ φ y) = 0
-- killingForm_apply_apply
lemma killingForm_apply_apply (x y : L) : killingForm R L x y = trace R L (ad R L x ∘ₗ ad R L y) 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] (x y : L)
Goal: ((killingForm R L) x) y = (LinearMap.trace R L) ((LieAlgebra.ad R L) x ∘ₗ (LieAlgebra.ad R L) y)
-- killingForm_eq_zero_of_mem_zeroRoot_mem_posFitting
lemma killingForm_eq_zero_of_mem_zeroRoot_mem_posFitting
    (H : LieSubalgebra R L) [LieAlgebra.IsNilpotent R H]
    {x₀ x₁ : L}
    (hx₀ : x₀ ∈ LieAlgebra.zeroRootSubalgebra R L H)
    (hx₁ : x₁ ∈ LieModule.posFittingComp R H L) :
    killingForm R L x₀ x₁ = 0 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] (H : LieSubalgebra R L) [LieAlgebra.IsNilpotent R ↥H] {x₀ x₁ : L} (hx₀ : x₀ ∈ LieAlgebra.zeroRootSubalgebra R L H) (hx₁ : x₁ ∈ LieModule.posFittingComp R (↥H) L)
Goal: ((killingForm R L) x₀) x₁ = 0
-- LieIdeal.toSubmodule_killingCompl
@[simp] lemma toSubmodule_killingCompl :
    LieSubmodule.toSubmodule I.killingCompl = (killingForm R L).orthogonal I.toSubmodule 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: ↑(LieIdeal.killingCompl R L I) = (killingForm R L).orthogonal ↑I
-- LieIdeal.mem_killingCompl
@[simp] lemma mem_killingCompl {x : L} :
    x ∈ I.killingCompl ↔ ∀ y ∈ I, killingForm R L y x = 0 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) {x : L}
Goal: x ∈ LieIdeal.killingCompl R L I ↔ ∀ y ∈ I, ((killingForm R L) y) x = 0
-- LieIdeal.coe_killingCompl_top
lemma coe_killingCompl_top :
    killingCompl R L ⊤ = LinearMap.ker (killingForm R L) 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L]
Goal: (lieIdealSubalgebra R L (LieIdeal.killingCompl R L ⊤)).toSubmodule = LinearMap.ker (killingForm R L)
-- LieIdeal.killingForm_eq
lemma killingForm_eq :
    killingForm R I = (killingForm R L).restrict I 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [Module.Free R L] [Module.Finite R L] (I : LieIdeal R L) [IsDomain R] [IsPrincipalIdealRing R]
Goal: killingForm R ↥↑I = (killingForm R L).restrict (lieIdealSubalgebra R L I).toSubmodule
-- LieIdeal.restrict_killingForm
lemma restrict_killingForm :
    (killingForm R L).restrict I = LieModule.traceForm R I L 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L)
Goal: (killingForm R L).restrict (lieIdealSubalgebra R L I).toSubmodule = LieModule.traceForm R (↥↑I) L
-- LieIdeal.le_killingCompl_top_of_isLieAbelian
@[simp] lemma le_killingCompl_top_of_isLieAbelian [IsLieAbelian I] :
    I ≤ LieIdeal.killingCompl R L ⊤ 
Arguments: (R : Type u_1) (L : Type u_3) [CommRing R] [LieRing L] [LieAlgebra R L] [Module.Free R L] [Module.Finite R L] (I : LieIdeal R L) [IsDomain R] [IsPrincipalIdealRing R] [IsLieAbelian ↥↑I]
Goal: I ≤ LieIdeal.killingCompl R L ⊤
-- LieModule.traceForm_eq_sum_finrank_nsmul_mul
lemma traceForm_eq_sum_finrank_nsmul_mul (x y : L) :
    traceForm K L M x y = ∑ χ : Weight K L M, finrank K (weightSpace M χ) • (χ x * χ y) 
Arguments: (K : Type u_2) (L : Type u_3) (M : Type u_4) [LieRing L] [AddCommGroup M] [LieRingModule L M] [Field K] [LieAlgebra K L] [Module K M] [LieModule K L M] [FiniteDimensional K M] [LieAlgebra.IsNilpotent K L] [LieModule.LinearWeights K L M] [LieModule.IsTriangularizable K L M] (x y : L)
Goal: ((LieModule.traceForm K L M) x) y =
  ∑ χ : LieModule.Weight K L M, FiniteDimensional.finrank K ↥↑(LieModule.weightSpace M ⇑χ) • (χ x * χ y)
-- LieModule.traceForm_eq_sum_finrank_nsmul
lemma traceForm_eq_sum_finrank_nsmul :
    traceForm K L M = ∑ χ : Weight K L M, finrank K (weightSpace M χ) •
      (χ : L →ₗ[K] K).smulRight (χ : L →ₗ[K] K) 
Arguments: (K : Type u_2) (L : Type u_3) (M : Type u_4) [LieRing L] [AddCommGroup M] [LieRingModule L M] [Field K] [LieAlgebra K L] [Module K M] [LieModule K L M] [FiniteDimensional K M] [LieAlgebra.IsNilpotent K L] [LieModule.LinearWeights K L M] [LieModule.IsTriangularizable K L M]
Goal: LieModule.traceForm K L M =
  ∑ χ : LieModule.Weight K L M,
    FiniteDimensional.finrank K ↥↑(LieModule.weightSpace M ⇑χ) •
      (LieModule.Weight.toLinear K L M χ).smulRight (LieModule.Weight.toLinear K L M χ)
-- LieModule.range_traceForm_le_span_weight
lemma range_traceForm_le_span_weight :
    LinearMap.range (traceForm K L M) ≤ span K (range (Weight.toLinear K L M)) 
Arguments: (K : Type u_2) (L : Type u_3) (M : Type u_4) [LieRing L] [AddCommGroup M] [LieRingModule L M] [Field K] [LieAlgebra K L] [Module K M] [LieModule K L M] [FiniteDimensional K M] [LieAlgebra.IsNilpotent K L] [LieModule.LinearWeights K L M] [LieModule.IsTriangularizable K L M]
Goal: LinearMap.range (LieModule.traceForm K L M) ≤ Submodule.span K (Set.range (LieModule.Weight.toLinear K L M))
-- MulOpposite.coe_opLinearEquiv
@[simp]
theorem coe_opLinearEquiv : (opLinearEquiv R : M → Mᵐᵒᵖ) = op 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ⇑(MulOpposite.opLinearEquiv R) = MulOpposite.op
-- MulOpposite.coe_opLinearEquiv_symm
@[simp]
theorem coe_opLinearEquiv_symm : ((opLinearEquiv R).symm : Mᵐᵒᵖ → M) = unop 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ⇑(MulOpposite.opLinearEquiv R).symm = MulOpposite.unop
-- MulOpposite.coe_opLinearEquiv_toLinearMap
@[simp]
theorem coe_opLinearEquiv_toLinearMap : ((opLinearEquiv R).toLinearMap : M → Mᵐᵒᵖ) = op 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ⇑↑(MulOpposite.opLinearEquiv R) = MulOpposite.op
-- MulOpposite.coe_opLinearEquiv_symm_toLinearMap
@[simp]
theorem coe_opLinearEquiv_symm_toLinearMap :
    ((opLinearEquiv R).symm.toLinearMap : Mᵐᵒᵖ → M) = unop 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ⇑↑(MulOpposite.opLinearEquiv R).symm = MulOpposite.unop
-- MulOpposite.opLinearEquiv_toAddEquiv
theorem opLinearEquiv_toAddEquiv : (opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).toAddEquiv = opAddEquiv 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: (MulOpposite.opLinearEquiv R).toAddEquiv = MulOpposite.opAddEquiv
-- MulOpposite.coe_opLinearEquiv_addEquiv
@[simp]
theorem coe_opLinearEquiv_addEquiv : ((opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ) : M ≃+ Mᵐᵒᵖ) = opAddEquiv 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ↑(MulOpposite.opLinearEquiv R) = MulOpposite.opAddEquiv
-- MulOpposite.opLinearEquiv_symm_toAddEquiv
theorem opLinearEquiv_symm_toAddEquiv :
    (opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).symm.toAddEquiv = opAddEquiv.symm 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: (MulOpposite.opLinearEquiv R).symm.toAddEquiv = MulOpposite.opAddEquiv.symm
-- MulOpposite.coe_opLinearEquiv_symm_addEquiv
@[simp]
theorem coe_opLinearEquiv_symm_addEquiv :
    ((opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).symm : Mᵐᵒᵖ ≃+ M) = opAddEquiv.symm 
Arguments: (R : Type u) {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ↑(MulOpposite.opLinearEquiv R).symm = MulOpposite.opAddEquiv.symm
-- List.sum_smul
theorem List.sum_smul {l : List R} {x : M} : l.sum • x = (l.map fun r ↦ r • x).sum 
Arguments: {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] {l : List R} {x : M}
Goal: l.sum • x = (List.map (fun r => r • x) l).sum
-- Multiset.sum_smul
theorem Multiset.sum_smul {l : Multiset R} {x : M} : l.sum • x = (l.map fun r ↦ r • x).sum 
Arguments: {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] {l : Multiset R} {x : M}
Goal: l.sum • x = (Multiset.map (fun r => r • x) l).sum
-- Multiset.sum_smul_sum
theorem Multiset.sum_smul_sum {s : Multiset R} {t : Multiset M} :
    s.sum • t.sum = ((s ×ˢ t).map fun p : R × M ↦ p.fst • p.snd).sum 
Arguments: {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] {s : Multiset R} {t : Multiset M}
Goal: s.sum • t.sum = (Multiset.map (fun p => p.1 • p.2) (s ×ˢ t)).sum
-- Finset.sum_smul
theorem Finset.sum_smul {f : ι → R} {s : Finset ι} {x : M} :
    (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x 
Arguments: {ι : Type u_1} {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] {f : ι → R} {s : Finset ι} {x : M}
Goal: (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x
-- Finset.sum_smul_sum
lemma Finset.sum_smul_sum (s : Finset α) (t : Finset β) {f : α → R} {g : β → M} :
    (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j 
Arguments: {α : Type u_3} {β : Type u_4} {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] (s : Finset α) (t : Finset β) {f : α → R} {g : β → M}
Goal: (∑ i ∈ s, f i) • ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i • g j
-- Fintype.sum_smul_sum
lemma Fintype.sum_smul_sum [Fintype α] [Fintype β] (f : α → R) (g : β → M) :
    (∑ i, f i) • ∑ j, g j = ∑ i, ∑ j, f i • g j 
Arguments: {α : Type u_3} {β : Type u_4} {R : Type u_5} {M : Type u_6} [Semiring R] [AddCommMonoid M] [Module R M] [Fintype α] [Fintype β] (f : α → R) (g : β → M)
Goal: (∑ i : α, f i) • ∑ j : β, g j = ∑ i : α, ∑ j : β, f i • g j
-- Finset.cast_card
theorem Finset.cast_card [CommSemiring R] (s : Finset α) : (s.card : R) = ∑ a ∈ s, 1 
Arguments: {α : Type u_3} {R : Type u_5} [CommSemiring R] (s : Finset α)
Goal: ↑s.card = ∑ a ∈ s, 1
-- Fintype.sum_piFinset_apply
lemma sum_piFinset_apply (f : κ → α) (s : Finset κ) (i : ι) :
    ∑ g ∈ piFinset fun _ : ι ↦ s, f (g i) = s.card ^ (card ι - 1) • ∑ b ∈ s, f b 
Arguments: {ι : Type u_1} {κ : Type u_2} {α : Type u_3} [DecidableEq ι] [Fintype ι] [AddCommMonoid α] (f : κ → α) (s : Finset κ) (i : ι)
Goal: ∑ g ∈ Fintype.piFinset fun x => s, f (g i) = s.card ^ (Fintype.card ι - 1) • ∑ b ∈ s, f b
-- SymAlg.unsym_sym
@[simp]
theorem unsym_sym (a : α) : unsym (sym a) = a 
Arguments: {α : Type u_1} (a : α)
Goal: SymAlg.unsym (SymAlg.sym a) = a
-- SymAlg.sym_unsym
@[simp]
theorem sym_unsym (a : α) : sym (unsym a) = a 
Arguments: {α : Type u_1} (a : α)
Goal: SymAlg.sym (SymAlg.unsym a) = a
-- SymAlg.sym_comp_unsym
@[simp]
theorem sym_comp_unsym : (sym : α → αˢʸᵐ) ∘ unsym = id 
Arguments: {α : Type u_1}
Goal: ⇑SymAlg.sym ∘ ⇑SymAlg.unsym = id
-- SymAlg.unsym_comp_sym
@[simp]
theorem unsym_comp_sym : (unsym : αˢʸᵐ → α) ∘ sym = id 
Arguments: {α : Type u_1}
Goal: ⇑SymAlg.unsym ∘ ⇑SymAlg.sym = id
-- SymAlg.sym_symm
@[simp]
theorem sym_symm : (@sym α).symm = unsym 
Arguments: {α : Type u_1}
Goal: SymAlg.sym.symm = SymAlg.unsym
-- SymAlg.unsym_symm
@[simp]
theorem unsym_symm : (@unsym α).symm = sym 
Arguments: {α : Type u_1}
Goal: SymAlg.unsym.symm = SymAlg.sym
-- SymAlg.sym_bijective
theorem sym_bijective : Bijective (sym : α → αˢʸᵐ) 
Arguments: {α : Type u_1}
Goal: Function.Bijective ⇑SymAlg.sym
-- SymAlg.unsym_bijective
theorem unsym_bijective : Bijective (unsym : αˢʸᵐ → α) 
Arguments: {α : Type u_1}
Goal: Function.Bijective ⇑SymAlg.unsym
-- SymAlg.sym_injective
theorem sym_injective : Injective (sym : α → αˢʸᵐ) 
Arguments: {α : Type u_1}
Goal: Function.Injective ⇑SymAlg.sym
-- SymAlg.sym_surjective
theorem sym_surjective : Surjective (sym : α → αˢʸᵐ) 
Arguments: {α : Type u_1}
Goal: Function.Surjective ⇑SymAlg.sym
-- SymAlg.unsym_injective
theorem unsym_injective : Injective (unsym : αˢʸᵐ → α) 
Arguments: {α : Type u_1}
Goal: Function.Injective ⇑SymAlg.unsym
-- SymAlg.unsym_surjective
theorem unsym_surjective : Surjective (unsym : αˢʸᵐ → α) 
Arguments: {α : Type u_1}
Goal: Function.Surjective ⇑SymAlg.unsym
-- SymAlg.sym_inj
theorem sym_inj {a b : α} : sym a = sym b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: SymAlg.sym a = SymAlg.sym b ↔ a = b
-- SymAlg.unsym_inj
theorem unsym_inj {a b : αˢʸᵐ} : unsym a = unsym b ↔ a = b 
Arguments: {α : Type u_1} {a b : αˢʸᵐ}
Goal: SymAlg.unsym a = SymAlg.unsym b ↔ a = b
-- SymAlg.sym_one
@[to_additive (attr := simp)]
theorem sym_one [One α] : sym (1 : α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: SymAlg.sym 1 = 1
-- SymAlg.sym_zero
@[to_additive (attr := simp)]
theorem sym_one [One α] : sym (1 : α) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: SymAlg.sym 0 = 0
-- SymAlg.unsym_zero
@[to_additive (attr := simp)]
theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: SymAlg.unsym 0 = 0
-- SymAlg.unsym_one
@[to_additive (attr := simp)]
theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1 
Arguments: {α : Type u_1} [One α]
Goal: SymAlg.unsym 1 = 1
-- SymAlg.sym_add
@[simp]
theorem sym_add [Add α] (a b : α) : sym (a + b) = sym a + sym b 
Arguments: {α : Type u_1} [Add α] (a b : α)
Goal: SymAlg.sym (a + b) = SymAlg.sym a + SymAlg.sym b
-- SymAlg.unsym_add
@[simp]
theorem unsym_add [Add α] (a b : αˢʸᵐ) : unsym (a + b) = unsym a + unsym b 
Arguments: {α : Type u_1} [Add α] (a b : αˢʸᵐ)
Goal: SymAlg.unsym (a + b) = SymAlg.unsym a + SymAlg.unsym b
-- SymAlg.sym_sub
@[simp]
theorem sym_sub [Sub α] (a b : α) : sym (a - b) = sym a - sym b 
Arguments: {α : Type u_1} [Sub α] (a b : α)
Goal: SymAlg.sym (a - b) = SymAlg.sym a - SymAlg.sym b
-- SymAlg.unsym_sub
@[simp]
theorem unsym_sub [Sub α] (a b : αˢʸᵐ) : unsym (a - b) = unsym a - unsym b 
Arguments: {α : Type u_1} [Sub α] (a b : αˢʸᵐ)
Goal: SymAlg.unsym (a - b) = SymAlg.unsym a - SymAlg.unsym b
-- SymAlg.sym_neg
@[simp]
theorem sym_neg [Neg α] (a : α) : sym (-a) = -sym a 
Arguments: {α : Type u_1} [Neg α] (a : α)
Goal: SymAlg.sym (-a) = -SymAlg.sym a
-- SymAlg.unsym_neg
@[simp]
theorem unsym_neg [Neg α] (a : αˢʸᵐ) : unsym (-a) = -unsym a 
Arguments: {α : Type u_1} [Neg α] (a : αˢʸᵐ)
Goal: SymAlg.unsym (-a) = -SymAlg.unsym a
-- SymAlg.mul_def
theorem mul_def [Add α] [Mul α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
    a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) 
Arguments: {α : Type u_1} [Add α] [Mul α] [One α] [OfNat α 2] [Invertible 2] (a b : αˢʸᵐ)
Goal: a * b = SymAlg.sym (⅟2 * (SymAlg.unsym a * SymAlg.unsym b + SymAlg.unsym b * SymAlg.unsym a))
-- SymAlg.unsym_mul
theorem unsym_mul [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
    unsym (a * b) = ⅟ 2 * (unsym a * unsym b + unsym b * unsym a) 
Arguments: {α : Type u_1} [Mul α] [Add α] [One α] [OfNat α 2] [Invertible 2] (a b : αˢʸᵐ)
Goal: SymAlg.unsym (a * b) = ⅟2 * (SymAlg.unsym a * SymAlg.unsym b + SymAlg.unsym b * SymAlg.unsym a)
-- SymAlg.sym_mul_sym
theorem sym_mul_sym [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : α) :
    sym a * sym b = sym (⅟ 2 * (a * b + b * a)) 
Arguments: {α : Type u_1} [Mul α] [Add α] [One α] [OfNat α 2] [Invertible 2] (a b : α)
Goal: SymAlg.sym a * SymAlg.sym b = SymAlg.sym (⅟2 * (a * b + b * a))
-- SymAlg.sym_inv
@[simp, to_additive existing]
theorem sym_inv [Inv α] (a : α) : sym a⁻¹ = (sym a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : α)
Goal: SymAlg.sym a⁻¹ = (SymAlg.sym a)⁻¹
-- SymAlg.unsym_inv
@[simp, to_additive existing]
theorem unsym_inv [Inv α] (a : αˢʸᵐ) : unsym a⁻¹ = (unsym a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : αˢʸᵐ)
Goal: SymAlg.unsym a⁻¹ = (SymAlg.unsym a)⁻¹
-- SymAlg.sym_smul
@[simp]
theorem sym_smul {R : Type*} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a 
Arguments: {α : Type u_1} {R : Type u_2} [SMul R α] (c : R) (a : α)
Goal: SymAlg.sym (c • a) = c • SymAlg.sym a
-- SymAlg.unsym_smul
@[simp]
theorem unsym_smul {R : Type*} [SMul R α] (c : R) (a : αˢʸᵐ) : unsym (c • a) = c • unsym a 
Arguments: {α : Type u_1} {R : Type u_2} [SMul R α] (c : R) (a : αˢʸᵐ)
Goal: SymAlg.unsym (c • a) = c • SymAlg.unsym a
-- SymAlg.unsym_eq_one_iff
@[to_additive (attr := simp)]
theorem unsym_eq_one_iff [One α] (a : αˢʸᵐ) : unsym a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] (a : αˢʸᵐ)
Goal: SymAlg.unsym a = 1 ↔ a = 1
-- SymAlg.unsym_eq_zero_iff
@[to_additive (attr := simp)]
theorem unsym_eq_one_iff [One α] (a : αˢʸᵐ) : unsym a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [Zero α] (a : αˢʸᵐ)
Goal: SymAlg.unsym a = 0 ↔ a = 0
-- SymAlg.sym_eq_zero_iff
@[to_additive (attr := simp)]
theorem sym_eq_one_iff [One α] (a : α) : sym a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [Zero α] (a : α)
Goal: SymAlg.sym a = 0 ↔ a = 0
-- SymAlg.sym_eq_one_iff
@[to_additive (attr := simp)]
theorem sym_eq_one_iff [One α] (a : α) : sym a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] (a : α)
Goal: SymAlg.sym a = 1 ↔ a = 1
-- SymAlg.unsym_ne_one_iff
@[to_additive]
theorem unsym_ne_one_iff [One α] (a : αˢʸᵐ) : unsym a ≠ (1 : α) ↔ a ≠ (1 : αˢʸᵐ) 
Arguments: {α : Type u_1} [One α] (a : αˢʸᵐ)
Goal: SymAlg.unsym a ≠ 1 ↔ a ≠ 1
-- SymAlg.unsym_ne_zero_iff
@[to_additive]
theorem unsym_ne_one_iff [One α] (a : αˢʸᵐ) : unsym a ≠ (1 : α) ↔ a ≠ (1 : αˢʸᵐ) 
Arguments: {α : Type u_1} [Zero α] (a : αˢʸᵐ)
Goal: SymAlg.unsym a ≠ 0 ↔ a ≠ 0
-- SymAlg.sym_ne_one_iff
@[to_additive]
theorem sym_ne_one_iff [One α] (a : α) : sym a ≠ (1 : αˢʸᵐ) ↔ a ≠ (1 : α) 
Arguments: {α : Type u_1} [One α] (a : α)
Goal: SymAlg.sym a ≠ 1 ↔ a ≠ 1
-- SymAlg.sym_ne_zero_iff
@[to_additive]
theorem sym_ne_one_iff [One α] (a : α) : sym a ≠ (1 : αˢʸᵐ) ↔ a ≠ (1 : α) 
Arguments: {α : Type u_1} [Zero α] (a : α)
Goal: SymAlg.sym a ≠ 0 ↔ a ≠ 0
-- SymAlg.invOf_sym
@[simp]
theorem invOf_sym [Mul α] [AddMonoidWithOne α] [Invertible (2 : α)] (a : α) [Invertible a] :
    ⅟ (sym a) = sym (⅟ a) 
Arguments: {α : Type u_1} [Mul α] [AddMonoidWithOne α] [Invertible 2] (a : α) [Invertible a]
Goal: ⅟(SymAlg.sym a) = SymAlg.sym ⅟a
-- SymAlg.unsym_mul_self
theorem unsym_mul_self [Semiring α] [Invertible (2 : α)] (a : αˢʸᵐ) :
    unsym (a * a) = unsym a * unsym a 
Arguments: {α : Type u_1} [Semiring α] [Invertible 2] (a : αˢʸᵐ)
Goal: SymAlg.unsym (a * a) = SymAlg.unsym a * SymAlg.unsym a
-- SymAlg.sym_mul_self
theorem sym_mul_self [Semiring α] [Invertible (2 : α)] (a : α) : sym (a * a) = sym a * sym a 
Arguments: {α : Type u_1} [Semiring α] [Invertible 2] (a : α)
Goal: SymAlg.sym (a * a) = SymAlg.sym a * SymAlg.sym a
-- SymAlg.mul_comm
theorem mul_comm [Mul α] [AddCommSemigroup α] [One α] [OfNat α 2] [Invertible (2 : α)]
    (a b : αˢʸᵐ) :
    a * b = b * a 
Arguments: {α : Type u_1} [Mul α] [AddCommSemigroup α] [One α] [OfNat α 2] [Invertible 2] (a b : αˢʸᵐ)
Goal: a * b = b * a
-- mem_nonZeroDivisorsLeft_iff
@[simp] lemma mem_nonZeroDivisorsLeft_iff {x : M₀} :
    x ∈ nonZeroDivisorsLeft M₀ ↔ ∀ y, y * x = 0 → y = 0 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] {x : M₀}
Goal: x ∈ nonZeroDivisorsLeft M₀ ↔ ∀ (y : M₀), y * x = 0 → y = 0
-- nmem_nonZeroDivisorsLeft_iff
lemma nmem_nonZeroDivisorsLeft_iff {r : M₀} :
    r ∉ nonZeroDivisorsLeft M₀ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] {r : M₀}
Goal: r ∉ nonZeroDivisorsLeft M₀ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty
-- mem_nonZeroDivisorsRight_iff
@[simp] lemma mem_nonZeroDivisorsRight_iff {x : M₀} :
    x ∈ nonZeroDivisorsRight M₀ ↔ ∀ y, x * y = 0 → y = 0 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] {x : M₀}
Goal: x ∈ nonZeroDivisorsRight M₀ ↔ ∀ (y : M₀), x * y = 0 → y = 0
-- nmem_nonZeroDivisorsRight_iff
lemma nmem_nonZeroDivisorsRight_iff {r : M₀} :
    r ∉ nonZeroDivisorsRight M₀ ↔ {s | r * s = 0 ∧ s ≠ 0}.Nonempty 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] {r : M₀}
Goal: r ∉ nonZeroDivisorsRight M₀ ↔ {s | r * s = 0 ∧ s ≠ 0}.Nonempty
-- nonZeroDivisorsLeft_eq_right
lemma nonZeroDivisorsLeft_eq_right (M₀ : Type*) [CommMonoidWithZero M₀] :
    nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀ 
Arguments: (M₀ : Type u_2) [CommMonoidWithZero M₀]
Goal: nonZeroDivisorsLeft M₀ = nonZeroDivisorsRight M₀
-- coe_nonZeroDivisorsLeft_eq
@[simp] lemma coe_nonZeroDivisorsLeft_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
    nonZeroDivisorsLeft M₀ = {x : M₀ | x ≠ 0} 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] [NoZeroDivisors M₀] [Nontrivial M₀]
Goal: ↑(nonZeroDivisorsLeft M₀) = {x | x ≠ 0}
-- coe_nonZeroDivisorsRight_eq
@[simp] lemma coe_nonZeroDivisorsRight_eq [NoZeroDivisors M₀] [Nontrivial M₀] :
    nonZeroDivisorsRight M₀ = {x : M₀ | x ≠ 0} 
Arguments: (M₀ : Type u_1) [MonoidWithZero M₀] [NoZeroDivisors M₀] [Nontrivial M₀]
Goal: ↑(nonZeroDivisorsRight M₀) = {x | x ≠ 0}
-- mem_nonZeroDivisors_iff
theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0 
Arguments: {M : Type u_2} [MonoidWithZero M] {r : M}
Goal: r ∈ M⁰ ↔ ∀ (x : M), x * r = 0 → x = 0
-- nmem_nonZeroDivisors_iff
lemma nmem_nonZeroDivisors_iff {r : M} : r ∉ M⁰ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty 
Arguments: {M : Type u_2} [MonoidWithZero M] {r : M}
Goal: r ∉ M⁰ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty
-- mul_right_mem_nonZeroDivisors_eq_zero_iff
theorem mul_right_mem_nonZeroDivisors_eq_zero_iff {x r : M} (hr : r ∈ M⁰) : x * r = 0 ↔ x = 0 
Arguments: {M : Type u_2} [MonoidWithZero M] {x r : M} (hr : r ∈ M⁰)
Goal: x * r = 0 ↔ x = 0
-- mul_right_coe_nonZeroDivisors_eq_zero_iff
@[simp]
theorem mul_right_coe_nonZeroDivisors_eq_zero_iff {x : M} {c : M⁰} : x * c = 0 ↔ x = 0 
Arguments: {M : Type u_2} [MonoidWithZero M] {x : M} {c : ↥M⁰}
Goal: x * ↑c = 0 ↔ x = 0
-- mul_left_mem_nonZeroDivisors_eq_zero_iff
theorem mul_left_mem_nonZeroDivisors_eq_zero_iff {r x : M₁} (hr : r ∈ M₁⁰) : r * x = 0 ↔ x = 0 
Arguments: {M₁ : Type u_4} [CommMonoidWithZero M₁] {r x : M₁} (hr : r ∈ M₁⁰)
Goal: r * x = 0 ↔ x = 0
-- mul_left_coe_nonZeroDivisors_eq_zero_iff
@[simp]
theorem mul_left_coe_nonZeroDivisors_eq_zero_iff {c : M₁⁰} {x : M₁} : (c : M₁) * x = 0 ↔ x = 0 
Arguments: {M₁ : Type u_4} [CommMonoidWithZero M₁] {c : ↥M₁⁰} {x : M₁}
Goal: ↑c * x = 0 ↔ x = 0
-- mul_cancel_right_mem_nonZeroDivisors
theorem mul_cancel_right_mem_nonZeroDivisors {x y r : R} (hr : r ∈ R⁰) : x * r = y * r ↔ x = y 
Arguments: {R : Type u_5} [Ring R] {x y r : R} (hr : r ∈ R⁰)
Goal: x * r = y * r ↔ x = y
-- mul_cancel_right_coe_nonZeroDivisors
theorem mul_cancel_right_coe_nonZeroDivisors {x y : R} {c : R⁰} : x * c = y * c ↔ x = y 
Arguments: {R : Type u_5} [Ring R] {x y : R} {c : ↥R⁰}
Goal: x * ↑c = y * ↑c ↔ x = y
-- mul_cancel_left_mem_nonZeroDivisors
@[simp]
theorem mul_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) :
    r * x = r * y ↔ x = y 
Arguments: {R' : Type u_6} [CommRing R'] {x y r : R'} (hr : r ∈ R'⁰)
Goal: r * x = r * y ↔ x = y
-- mul_cancel_left_coe_nonZeroDivisors
theorem mul_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : (c : R') * x = c * y ↔ x = y 
Arguments: {R' : Type u_6} [CommRing R'] {x y : R'} {c : ↥R'⁰}
Goal: ↑c * x = ↑c * y ↔ x = y
-- dvd_cancel_right_mem_nonZeroDivisors
theorem dvd_cancel_right_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : x * r ∣ y * r ↔ x ∣ y 
Arguments: {R' : Type u_6} [CommRing R'] {x y r : R'} (hr : r ∈ R'⁰)
Goal: x * r ∣ y * r ↔ x ∣ y
-- dvd_cancel_right_coe_nonZeroDivisors
theorem dvd_cancel_right_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : x * c ∣ y * c ↔ x ∣ y 
Arguments: {R' : Type u_6} [CommRing R'] {x y : R'} {c : ↥R'⁰}
Goal: x * ↑c ∣ y * ↑c ↔ x ∣ y
-- dvd_cancel_left_mem_nonZeroDivisors
theorem dvd_cancel_left_mem_nonZeroDivisors {x y r : R'} (hr : r ∈ R'⁰) : r * x ∣ r * y ↔ x ∣ y 
Arguments: {R' : Type u_6} [CommRing R'] {x y r : R'} (hr : r ∈ R'⁰)
Goal: r * x ∣ r * y ↔ x ∣ y
-- dvd_cancel_left_coe_nonZeroDivisors
theorem dvd_cancel_left_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : c * x ∣ c * y ↔ x ∣ y 
Arguments: {R' : Type u_6} [CommRing R'] {x y : R'} {c : ↥R'⁰}
Goal: ↑c * x ∣ ↑c * y ↔ x ∣ y
-- zero_not_mem_nonZeroDivisors
theorem zero_not_mem_nonZeroDivisors [Nontrivial M] : 0 ∉ M⁰ 
Arguments: {M : Type u_2} [MonoidWithZero M] [Nontrivial M]
Goal: 0 ∉ M⁰
-- nonZeroDivisors.ne_zero
theorem nonZeroDivisors.ne_zero [Nontrivial M] {x} (hx : x ∈ M⁰) : x ≠ 0 
Arguments: {M : Type u_2} [MonoidWithZero M] [Nontrivial M] {x : M} (hx : x ∈ M⁰)
Goal: x ≠ 0
-- nonZeroDivisors.coe_ne_zero
@[simp]
theorem nonZeroDivisors.coe_ne_zero [Nontrivial M] (x : M⁰) : (x : M) ≠ 0 
Arguments: {M : Type u_2} [MonoidWithZero M] [Nontrivial M] (x : ↥M⁰)
Goal: ↑x ≠ 0