ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IntermediateField.finInsepDegree_top
@[simp]
theorem finInsepDegree_top : finInsepDegree F (⊤ : IntermediateField E K) = finInsepDegree F K 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.finInsepDegree F ↥⊤ = Field.finInsepDegree F K
-- IntermediateField.sepDegree_bot'
@[simp]
theorem sepDegree_bot' : sepDegree F (⊥ : IntermediateField E K) = sepDegree F E 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type v) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.sepDegree F ↥⊥ = Field.sepDegree F E
-- IntermediateField.insepDegree_bot'
@[simp]
theorem insepDegree_bot' : insepDegree F (⊥ : IntermediateField E K) = insepDegree F E 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type v) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.insepDegree F ↥⊥ = Field.insepDegree F E
-- Algebra.IsSeparable.sepDegree_eq
theorem Algebra.IsSeparable.sepDegree_eq [Algebra.IsSeparable F E] :
    sepDegree F E = Module.rank F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [Algebra.IsSeparable F E]
Goal: Field.sepDegree F E = Module.rank F E
-- Algebra.IsSeparable.insepDegree_eq
theorem Algebra.IsSeparable.insepDegree_eq [Algebra.IsSeparable F E] : insepDegree F E = 1 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [Algebra.IsSeparable F E]
Goal: Field.insepDegree F E = 1
-- Algebra.IsSeparable.finInsepDegree_eq
theorem Algebra.IsSeparable.finInsepDegree_eq [Algebra.IsSeparable F E] : finInsepDegree F E = 1 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [Algebra.IsSeparable F E]
Goal: Field.finInsepDegree F E = 1
-- IsGalois.to_normal
class IsGalois : Prop where
  [to_isSeparable : Algebra.IsSeparable F E]
  [to_normal : Normal F E]
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] [self : IsGalois F E]
Goal: Normal F E
-- IsGalois.to_isSeparable
class IsGalois : Prop where
  [to_isSeparable : Algebra.IsSeparable F E]
  [to_normal : Normal F E]
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] [self : IsGalois F E]
Goal: Algebra.IsSeparable F E
-- isGalois_iff
theorem isGalois_iff : IsGalois F E ↔ Algebra.IsSeparable F E ∧ Normal F E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E]
Goal: IsGalois F E ↔ Algebra.IsSeparable F E ∧ Normal F E
-- IsGalois.integral
theorem integral [IsGalois F E] (x : E) : IsIntegral F x 
Arguments: (F : Type u_1) [Field F] {E : Type u_2} [Field E] [Algebra F E] [IsGalois F E] (x : E)
Goal: IsIntegral F x
-- IsGalois.separable
theorem separable [IsGalois F E] (x : E) : IsSeparable F x 
Arguments: (F : Type u_1) [Field F] {E : Type u_2} [Field E] [Algebra F E] [IsGalois F E] (x : E)
Goal: IsSeparable F x
-- IsGalois.splits
theorem splits [IsGalois F E] (x : E) : (minpoly F x).Splits (algebraMap F E) 
Arguments: (F : Type u_1) [Field F] {E : Type u_2} [Field E] [Algebra F E] [IsGalois F E] (x : E)
Goal: Polynomial.Splits (algebraMap F E) (minpoly F x)
-- IsGalois.IntermediateField.AdjoinSimple.card_aut_eq_finrank
theorem IntermediateField.AdjoinSimple.card_aut_eq_finrank [FiniteDimensional F E] {α : E}
    (hα : IsIntegral F α) (h_sep : IsSeparable F α)
    (h_splits : (minpoly F α).Splits (algebraMap F F⟮α⟯)) :
    Fintype.card (F⟮α⟯ ≃ₐ[F] F⟮α⟯) = finrank F F⟮α⟯ 
Arguments: (F : Type u_1) [Field F] (E : Type u_2) [Field E] [Algebra F E] [FiniteDimensional F E] {α : E} (hα : IsIntegral F α) (h_sep : IsSeparable F α) (h_splits : Polynomial.Splits (algebraMap F ↥F⟮α⟯) (minpoly F α))
Goal: Fintype.card (↥F⟮α⟯ ≃ₐ[F] ↥F⟮α⟯) = FiniteDimensional.finrank F ↥F⟮α⟯
-- IsGalois.card_aut_eq_finrank
theorem card_aut_eq_finrank [FiniteDimensional F E] [IsGalois F E] :
    Fintype.card (E ≃ₐ[F] E) = finrank F E 
Arguments: (F : Type u_1) [Field F] (E : Type u_2) [Field E] [Algebra F E] [FiniteDimensional F E] [IsGalois F E]
Goal: Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E
-- IsGalois.tower_top_of_isGalois
theorem IsGalois.tower_top_of_isGalois [IsGalois F E] : IsGalois K E 
Arguments: (F : Type u_1) (K : Type u_2) (E : Type u_3) [Field F] [Field K] [Field E] [Algebra F K] [Algebra F E] [Algebra K E] [IsScalarTower F K E] [IsGalois F E]
Goal: IsGalois K E
-- isGalois_iff_isGalois_bot
theorem isGalois_iff_isGalois_bot : IsGalois (⊥ : IntermediateField F E) E ↔ IsGalois F E 
Arguments: {F : Type u_1} {E : Type u_3} [Field F] [Field E] [Algebra F E]
Goal: IsGalois (↥⊥) E ↔ IsGalois F E
-- IsGalois.of_algEquiv
theorem IsGalois.of_algEquiv [IsGalois F E] (f : E ≃ₐ[F] E') : IsGalois F E' 
Arguments: {F : Type u_1} {E : Type u_3} [Field F] [Field E] {E' : Type u_4} [Field E'] [Algebra F E'] [Algebra F E] [IsGalois F E] (f : E ≃ₐ[F] E')
Goal: IsGalois F E'
-- AlgEquiv.transfer_galois
theorem AlgEquiv.transfer_galois (f : E ≃ₐ[F] E') : IsGalois F E ↔ IsGalois F E' 
Arguments: {F : Type u_1} {E : Type u_3} [Field F] [Field E] {E' : Type u_4} [Field E'] [Algebra F E'] [Algebra F E] (f : E ≃ₐ[F] E')
Goal: IsGalois F E ↔ IsGalois F E'
-- isGalois_iff_isGalois_top
theorem isGalois_iff_isGalois_top : IsGalois F (⊤ : IntermediateField F E) ↔ IsGalois F E 
Arguments: {F : Type u_1} {E : Type u_3} [Field F] [Field E] [Algebra F E]
Goal: IsGalois F ↥⊤ ↔ IsGalois F E
-- IntermediateField.finrank_fixedField_eq_card
theorem finrank_fixedField_eq_card [FiniteDimensional F E] [DecidablePred (· ∈ H)] :
    finrank (fixedField H) E = Fintype.card H 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (H : Subgroup (E ≃ₐ[F] E)) [FiniteDimensional F E] [DecidablePred fun x => x ∈ H]
Goal: FiniteDimensional.finrank (↥(IntermediateField.fixedField H)) E = Fintype.card ↥H
-- IntermediateField.le_iff_le
theorem le_iff_le : K ≤ fixedField H ↔ H ≤ fixingSubgroup K 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (H : Subgroup (E ≃ₐ[F] E)) (K : IntermediateField F E)
Goal: K ≤ IntermediateField.fixedField H ↔ H ≤ K.fixingSubgroup
-- IntermediateField.fixingSubgroup_fixedField
theorem fixingSubgroup_fixedField [FiniteDimensional F E] : fixingSubgroup (fixedField H) = H 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (H : Subgroup (E ≃ₐ[F] E)) [FiniteDimensional F E]
Goal: (IntermediateField.fixedField H).fixingSubgroup = H
-- IsGalois.fixedField_fixingSubgroup
theorem fixedField_fixingSubgroup [FiniteDimensional F E] [h : IsGalois F E] :
    IntermediateField.fixedField (IntermediateField.fixingSubgroup K) = K 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (K : IntermediateField F E) [FiniteDimensional F E] [h : IsGalois F E]
Goal: IntermediateField.fixedField K.fixingSubgroup = K
-- IsGalois.card_fixingSubgroup_eq_finrank
theorem card_fixingSubgroup_eq_finrank [DecidablePred (· ∈ IntermediateField.fixingSubgroup K)]
    [FiniteDimensional F E] [IsGalois F E] :
    Fintype.card (IntermediateField.fixingSubgroup K) = finrank K E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (K : IntermediateField F E) [DecidablePred fun x => x ∈ K.fixingSubgroup] [FiniteDimensional F E] [IsGalois F E]
Goal: Fintype.card ↥K.fixingSubgroup = FiniteDimensional.finrank (↥K) E
-- IsGalois.is_separable_splitting_field
theorem is_separable_splitting_field [FiniteDimensional F E] [IsGalois F E] :
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E 
Arguments: (F : Type u_1) [Field F] (E : Type u_2) [Field E] [Algebra F E] [FiniteDimensional F E] [IsGalois F E]
Goal: ∃ p, p.Separable ∧ Polynomial.IsSplittingField F E p
-- IsGalois.of_fixedField_eq_bot
theorem of_fixedField_eq_bot [FiniteDimensional F E]
    (h : IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥) : IsGalois F E 
Arguments: (F : Type u_1) [Field F] (E : Type u_2) [Field E] [Algebra F E] [FiniteDimensional F E] (h : IntermediateField.fixedField ⊤ = ⊥)
Goal: IsGalois F E
-- IsGalois.of_card_aut_eq_finrank
theorem of_card_aut_eq_finrank [FiniteDimensional F E]
    (h : Fintype.card (E ≃ₐ[F] E) = finrank F E) : IsGalois F E 
Arguments: (F : Type u_1) [Field F] (E : Type u_2) [Field E] [Algebra F E] [FiniteDimensional F E] (h : Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E)
Goal: IsGalois F E
-- IsGalois.of_separable_splitting_field_aux
theorem of_separable_splitting_field_aux [hFE : FiniteDimensional F E] [sp : p.IsSplittingField F E]
    (hp : p.Separable) (K : Type*) [Field K] [Algebra F K] [Algebra K E] [IsScalarTower F K E]
    {x : E} (hx : x ∈ p.aroots E)
    -- these are both implied by `hFE`, but as they carry data this makes the lemma more general
    [Fintype (K →ₐ[F] E)]
    [Fintype (K⟮x⟯.restrictScalars F →ₐ[F] E)] :
    Fintype.card (K⟮x⟯.restrictScalars F →ₐ[F] E) = Fintype.card (K →ₐ[F] E) * finrank K K⟮x⟯ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {p : F[X]} [hFE : FiniteDimensional F E] [sp : Polynomial.IsSplittingField F E p] (hp : p.Separable) (K : Type u_3) [Field K] [Algebra F K] [Algebra K E] [IsScalarTower F K E] {x : E} (hx : x ∈ p.aroots E) [Fintype (K →ₐ[F] E)] [Fintype (↥(IntermediateField.restrictScalars F K⟮x⟯) →ₐ[F] E)]
Goal: Fintype.card (↥(IntermediateField.restrictScalars F K⟮x⟯) →ₐ[F] E) =
  Fintype.card (K →ₐ[F] E) * FiniteDimensional.finrank K ↥K⟮x⟯
-- IsGalois.of_separable_splitting_field
theorem of_separable_splitting_field [sp : p.IsSplittingField F E] (hp : p.Separable) :
    IsGalois F E 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {p : F[X]} [sp : Polynomial.IsSplittingField F E p] (hp : p.Separable)
Goal: IsGalois F E
-- IsGalois.tfae
theorem tfae [FiniteDimensional F E] : List.TFAE [
    IsGalois F E,
    IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥,
    Fintype.card (E ≃ₐ[F] E) = finrank F E,
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E] 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] [FiniteDimensional F E]
Goal: [IsGalois F E, IntermediateField.fixedField ⊤ = ⊥, Fintype.card (E ≃ₐ[F] E) = FiniteDimensional.finrank F E,
    ∃ p, p.Separable ∧ Polynomial.IsSplittingField F E p].TFAE
-- CategoryTheory.MonoOver.factors_congr
theorem factors_congr {X : C} {f g : MonoOver X} {Y : C} (h : Y ⟶ X) (e : f ≅ g) :
    f.Factors h ↔ g.Factors h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X} {Y : C} (h : Y ⟶ X) (e : f ≅ g)
Goal: f.Factors h ↔ g.Factors h
-- CategoryTheory.Subobject.mk_factors_iff
@[simp]
theorem mk_factors_iff {X Y Z : C} (f : Y ⟶ X) [Mono f] (g : Z ⟶ X) :
    (Subobject.mk f).Factors g ↔ (MonoOver.mk' f).Factors g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] (g : Z ⟶ X)
Goal: (CategoryTheory.Subobject.mk f).Factors g ↔ (CategoryTheory.MonoOver.mk' f).Factors g
-- CategoryTheory.Subobject.mk_factors_self
theorem mk_factors_self (f : X ⟶ Y) [Mono f] : (mk f).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Subobject.mk f).Factors f
-- CategoryTheory.Subobject.factors_iff
theorem factors_iff {X Y : C} (P : Subobject Y) (f : X ⟶ Y) :
    P.Factors f ↔ (representative.obj P).Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y)
Goal: P.Factors f ↔ (CategoryTheory.Subobject.representative.obj P).Factors f
-- CategoryTheory.Subobject.factors_self
theorem factors_self {X : C} (P : Subobject X) : P.Factors P.arrow 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Subobject X)
Goal: P.Factors P.arrow
-- CategoryTheory.Subobject.factors_comp_arrow
theorem factors_comp_arrow {X Y : C} {P : Subobject Y} (f : X ⟶ P) : P.Factors (f ≫ P.arrow) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {P : CategoryTheory.Subobject Y} (f : X ⟶ CategoryTheory.Subobject.underlying.obj P)
Goal: P.Factors (f ≫ P.arrow)
-- CategoryTheory.Subobject.factors_of_factors_right
theorem factors_of_factors_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) {g : Y ⟶ Z}
    (h : P.Factors g) : P.Factors (f ≫ g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {P : CategoryTheory.Subobject Z} (f : X ⟶ Y) {g : Y ⟶ Z} (h : P.Factors g)
Goal: P.Factors (f ≫ g)
-- CategoryTheory.Subobject.factors_zero
theorem factors_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y} : P.Factors (0 : X ⟶ Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {P : CategoryTheory.Subobject Y}
Goal: P.Factors 0
-- CategoryTheory.Subobject.factors_of_le
theorem factors_of_le {Y Z : C} {P Q : Subobject Y} (f : Z ⟶ Y) (h : P ≤ Q) :
    P.Factors f → Q.Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} {P Q : CategoryTheory.Subobject Y} (f : Z ⟶ Y) (h : P ≤ Q)
Goal: P.Factors f → Q.Factors f
-- CategoryTheory.Subobject.factorThru_arrow
@[reassoc (attr := simp)]
theorem factorThru_arrow {X Y : C} (P : Subobject Y) (f : X ⟶ Y) (h : Factors P f) :
    P.factorThru f h ≫ P.arrow = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y) (h : P.Factors f)
Goal: P.factorThru f h ≫ P.arrow = f
-- CategoryTheory.Subobject.factorThru_self
@[simp]
theorem factorThru_self {X : C} (P : Subobject X) (h) : P.factorThru P.arrow h = 𝟙 (P : C) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (P : CategoryTheory.Subobject X) (h : P.Factors P.arrow)
Goal: P.factorThru P.arrow h = 𝟙 (CategoryTheory.Subobject.underlying.obj P)
-- CategoryTheory.Subobject.factorThru_mk_self
@[simp]
theorem factorThru_mk_self (f : X ⟶ Y) [Mono f] :
    (mk f).factorThru f (mk_factors_self f) = (underlyingIso f).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Subobject.mk f).factorThru f ⋯ = (CategoryTheory.Subobject.underlyingIso f).inv
-- CategoryTheory.Subobject.factorThru_comp_arrow
@[simp]
theorem factorThru_comp_arrow {X Y : C} {P : Subobject Y} (f : X ⟶ P) (h) :
    P.factorThru (f ≫ P.arrow) h = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {P : CategoryTheory.Subobject Y} (f : X ⟶ CategoryTheory.Subobject.underlying.obj P) (h : P.Factors (f ≫ P.arrow))
Goal: P.factorThru (f ≫ P.arrow) h = f
-- CategoryTheory.Subobject.factorThru_eq_zero
@[simp]
theorem factorThru_eq_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y} {f : X ⟶ Y}
    {h : Factors P f} : P.factorThru f h = 0 ↔ f = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {P : CategoryTheory.Subobject Y} {f : X ⟶ Y} {h : P.Factors f}
Goal: P.factorThru f h = 0 ↔ f = 0
-- CategoryTheory.Subobject.factorThru_right
theorem factorThru_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) (g : Y ⟶ Z) (h : P.Factors g) :
    f ≫ P.factorThru g h = P.factorThru (f ≫ g) (factors_of_factors_right f h) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {P : CategoryTheory.Subobject Z} (f : X ⟶ Y) (g : Y ⟶ Z) (h : P.Factors g)
Goal: f ≫ P.factorThru g h = P.factorThru (f ≫ g) ⋯
-- CategoryTheory.Subobject.factorThru_zero
@[simp]
theorem factorThru_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y}
    (h : P.Factors (0 : X ⟶ Y)) : P.factorThru 0 h = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} {P : CategoryTheory.Subobject Y} (h : P.Factors 0)
Goal: P.factorThru 0 h = 0
-- CategoryTheory.Subobject.factorThru_ofLE
theorem factorThru_ofLE {Y Z : C} {P Q : Subobject Y} {f : Z ⟶ Y} (h : P ≤ Q) (w : P.Factors f) :
    Q.factorThru f (factors_of_le f h w) = P.factorThru f w ≫ ofLE P Q h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} {P Q : CategoryTheory.Subobject Y} {f : Z ⟶ Y} (h : P ≤ Q) (w : P.Factors f)
Goal: Q.factorThru f ⋯ = P.factorThru f w ≫ P.ofLE Q h
-- CategoryTheory.Subobject.factors_add
theorem factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y) (wf : P.Factors f)
    (wg : P.Factors g) : P.Factors (f + g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (wf : P.Factors f) (wg : P.Factors g)
Goal: P.Factors (f + g)
-- CategoryTheory.Subobject.factorThru_add
theorem factorThru_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g))
    (wf : P.Factors f) (wg : P.Factors g) :
    P.factorThru (f + g) w = P.factorThru f wf + P.factorThru g wg 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g)) (wf : P.Factors f) (wg : P.Factors g)
Goal: P.factorThru (f + g) w = P.factorThru f wf + P.factorThru g wg
-- CategoryTheory.Subobject.factors_left_of_factors_add
theorem factors_left_of_factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wg : P.Factors g) : P.Factors f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g)) (wg : P.Factors g)
Goal: P.Factors f
-- CategoryTheory.Subobject.factorThru_add_sub_factorThru_right
@[simp]
theorem factorThru_add_sub_factorThru_right {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wg : P.Factors g) :
    P.factorThru (f + g) w - P.factorThru g wg =
      P.factorThru f (factors_left_of_factors_add f g w wg) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g)) (wg : P.Factors g)
Goal: P.factorThru (f + g) w - P.factorThru g wg = P.factorThru f ⋯
-- CategoryTheory.Subobject.factors_right_of_factors_add
theorem factors_right_of_factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wf : P.Factors f) : P.Factors g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g)) (wf : P.Factors f)
Goal: P.Factors g
-- CategoryTheory.Subobject.factorThru_add_sub_factorThru_left
@[simp]
theorem factorThru_add_sub_factorThru_left {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wf : P.Factors f) :
    P.factorThru (f + g) w - P.factorThru f wf =
      P.factorThru g (factors_right_of_factors_add f g w wf) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Preadditive C] {X Y : C} {P : CategoryTheory.Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g)) (wf : P.Factors f)
Goal: P.factorThru (f + g) w - P.factorThru f wf = P.factorThru g ⋯
-- AddCircle.ae_empty_or_univ_of_forall_vadd_ae_eq_self
theorem ae_empty_or_univ_of_forall_vadd_ae_eq_self {s : Set <| AddCircle T}
    (hs : NullMeasurableSet s volume) {ι : Type*} {l : Filter ι} [l.NeBot] {u : ι → AddCircle T}
    (hu₁ : ∀ i, (u i +ᵥ s : Set _) =ᵐ[volume] s) (hu₂ : Tendsto (addOrderOf ∘ u) l atTop) :
    s =ᵐ[volume] (∅ : Set <| AddCircle T) ∨ s =ᵐ[volume] univ 
Arguments: {T : ℝ} [hT : Fact (0 < T)] {s : Set (AddCircle T)} (hs : MeasureTheory.NullMeasurableSet s MeasureTheory.volume) {ι : Type u_1} {l : Filter ι} [l.NeBot] {u : ι → AddCircle T} (hu₁ : ∀ (i : ι), u i +ᵥ s =ᵐ[MeasureTheory.volume] s) (hu₂ : Filter.Tendsto (addOrderOf ∘ u) l Filter.atTop)
Goal: s =ᵐ[MeasureTheory.volume] ∅ ∨ s =ᵐ[MeasureTheory.volume] Set.univ
-- AddCircle.ergodic_zsmul
theorem ergodic_zsmul {n : ℤ} (hn : 1 < |n|) : Ergodic fun y : AddCircle T => n • y 
Arguments: {T : ℝ} [hT : Fact (0 < T)] {n : ℤ} (hn : 1 < |n|)
Goal: Ergodic (fun y => n • y) MeasureTheory.volume
-- AddCircle.ergodic_nsmul
theorem ergodic_nsmul {n : ℕ} (hn : 1 < n) : Ergodic fun y : AddCircle T => n • y 
Arguments: {T : ℝ} [hT : Fact (0 < T)] {n : ℕ} (hn : 1 < n)
Goal: Ergodic (fun y => n • y) MeasureTheory.volume
-- AddCircle.ergodic_zsmul_add
theorem ergodic_zsmul_add (x : AddCircle T) {n : ℤ} (h : 1 < |n|) : Ergodic fun y => n • y + x 
Arguments: {T : ℝ} [hT : Fact (0 < T)] (x : AddCircle T) {n : ℤ} (h : 1 < |n|)
Goal: Ergodic (fun y => n • y + x) MeasureTheory.volume
-- AddCircle.ergodic_nsmul_add
theorem ergodic_nsmul_add (x : AddCircle T) {n : ℕ} (h : 1 < n) : Ergodic fun y => n • y + x 
Arguments: {T : ℝ} [hT : Fact (0 < T)] (x : AddCircle T) {n : ℕ} (h : 1 < n)
Goal: Ergodic (fun y => n • y + x) MeasureTheory.volume
-- root_X_pow_sub_C_pow
lemma root_X_pow_sub_C_pow (n : ℕ) (a : K) :
    (AdjoinRoot.root (X ^ n - C a)) ^ n = AdjoinRoot.of _ a 
Arguments: {K : Type u} [Field K] (n : ℕ) (a : K)
Goal: AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a) ^ n = (AdjoinRoot.of (Polynomial.X ^ n - Polynomial.C a)) a
-- root_X_pow_sub_C_ne_zero
lemma root_X_pow_sub_C_ne_zero {n : ℕ} (hn : 1 < n) (a : K) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0 
Arguments: {K : Type u} [Field K] {n : ℕ} (hn : 1 < n) (a : K)
Goal: AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a) ≠ 0
-- root_X_pow_sub_C_ne_zero'
lemma root_X_pow_sub_C_ne_zero' {n : ℕ} {a : K} (hn : 0 < n) (ha : a ≠ 0) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0 
Arguments: {K : Type u} [Field K] {n : ℕ} {a : K} (hn : 0 < n) (ha : a ≠ 0)
Goal: AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a) ≠ 0
-- X_pow_sub_C_splits_of_isPrimitiveRoot
theorem X_pow_sub_C_splits_of_isPrimitiveRoot
    {n : ℕ} {ζ : K} (hζ : IsPrimitiveRoot ζ n) {α a : K} (e : α ^ n = a) :
    (X ^ n - C a).Splits (RingHom.id _) 
Arguments: {K : Type u} [Field K] {n : ℕ} {ζ : K} (hζ : IsPrimitiveRoot ζ n) {α a : K} (e : α ^ n = a)
Goal: Polynomial.Splits (RingHom.id K) (Polynomial.X ^ n - Polynomial.C a)
-- _private.Mathlib.FieldTheory.KummerExtension.0.X_pow_sub_C_eq_prod'
private
theorem X_pow_sub_C_eq_prod'
    {n : ℕ} {ζ : K} (hζ : IsPrimitiveRoot ζ n) {α a : K} (hn : 0 < n) (e : α ^ n = a) :
    (X ^ n - C a) = ∏ i ∈ Finset.range n, (X - C (ζ ^ i * α)) 
Arguments: {K : Type u} [Field K] {n : ℕ} {ζ : K} (hζ : IsPrimitiveRoot ζ n) {α a : K} (hn : 0 < n) (e : α ^ n = a)
Goal: Polynomial.X ^ n - Polynomial.C a = ∏ i ∈ Finset.range n, (Polynomial.X - Polynomial.C (ζ ^ i * α))
-- X_pow_sub_C_eq_prod
lemma X_pow_sub_C_eq_prod {R : Type*} [CommRing R] [IsDomain R]
    {n : ℕ} {ζ : R} (hζ : IsPrimitiveRoot ζ n) {α a : R} (hn : 0 < n) (e : α ^ n = a) :
    (X ^ n - C a) = ∏ i ∈ Finset.range n, (X - C (ζ ^ i * α)) 
Arguments: {R : Type u_1} [CommRing R] [IsDomain R] {n : ℕ} {ζ : R} (hζ : IsPrimitiveRoot ζ n) {α a : R} (hn : 0 < n) (e : α ^ n = a)
Goal: Polynomial.X ^ n - Polynomial.C a = ∏ i ∈ Finset.range n, (Polynomial.X - Polynomial.C (ζ ^ i * α))
-- ne_zero_of_irreducible_X_pow_sub_C
lemma ne_zero_of_irreducible_X_pow_sub_C {n : ℕ} {a : K} (H : Irreducible (X ^ n - C a)) :
    n ≠ 0 
Arguments: {K : Type u} [Field K] {n : ℕ} {a : K} (H : Irreducible (Polynomial.X ^ n - Polynomial.C a))
Goal: n ≠ 0
-- ne_zero_of_irreducible_X_pow_sub_C'
lemma ne_zero_of_irreducible_X_pow_sub_C' {n : ℕ} (hn : n ≠ 1) {a : K}
    (H : Irreducible (X ^ n - C a)) : a ≠ 0 
Arguments: {K : Type u} [Field K] {n : ℕ} (hn : n ≠ 1) {a : K} (H : Irreducible (Polynomial.X ^ n - Polynomial.C a))
Goal: a ≠ 0
-- root_X_pow_sub_C_eq_zero_iff
lemma root_X_pow_sub_C_eq_zero_iff {n : ℕ} {a : K} (H : Irreducible (X ^ n - C a)) :
    (AdjoinRoot.root (X ^ n - C a)) = 0 ↔ a = 0 
Arguments: {K : Type u} [Field K] {n : ℕ} {a : K} (H : Irreducible (Polynomial.X ^ n - Polynomial.C a))
Goal: AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a) = 0 ↔ a = 0
-- root_X_pow_sub_C_ne_zero_iff
lemma root_X_pow_sub_C_ne_zero_iff {n : ℕ} {a : K} (H : Irreducible (X ^ n - C a)) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0 ↔ a ≠ 0 
Arguments: {K : Type u} [Field K] {n : ℕ} {a : K} (H : Irreducible (Polynomial.X ^ n - Polynomial.C a))
Goal: AdjoinRoot.root (Polynomial.X ^ n - Polynomial.C a) ≠ 0 ↔ a ≠ 0