ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- HahnSeries.leadingCoeff_eq
theorem leadingCoeff_eq [Zero Γ] {x : HahnSeries Γ R} : x.leadingCoeff = x.coeff x.order 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] [Zero Γ] {x : HahnSeries Γ R}
Goal: x.leadingCoeff = x.coeff x.order
-- HahnSeries.embDomain_coeff
@[simp]
theorem embDomain_coeff {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {a : Γ} :
    (embDomain f x).coeff (f a) = x.coeff a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {a : Γ}
Goal: (HahnSeries.embDomain f x).coeff (f a) = x.coeff a
-- HahnSeries.embDomain_mk_coeff
@[simp]
theorem embDomain_mk_coeff {f : Γ → Γ'} (hfi : Function.Injective f)
    (hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') {x : HahnSeries Γ R} {a : Γ} :
    (embDomain ⟨⟨f, hfi⟩, hf _ _⟩ x).coeff (f a) = x.coeff a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ → Γ'} (hfi : Function.Injective f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') {x : HahnSeries Γ R} {a : Γ}
Goal: (HahnSeries.embDomain { toFun := f, inj' := hfi, map_rel_iff' := ⋯ } x).coeff (f a) = x.coeff a
-- HahnSeries.embDomain_notin_image_support
theorem embDomain_notin_image_support {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'}
    (hb : b ∉ f '' x.support) : (embDomain f x).coeff b = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'} (hb : b ∉ ⇑f '' x.support)
Goal: (HahnSeries.embDomain f x).coeff b = 0
-- HahnSeries.support_embDomain_subset
theorem support_embDomain_subset {f : Γ ↪o Γ'} {x : HahnSeries Γ R} :
    support (embDomain f x) ⊆ f '' x.support 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'} {x : HahnSeries Γ R}
Goal: (HahnSeries.embDomain f x).support ⊆ ⇑f '' x.support
-- HahnSeries.embDomain_notin_range
theorem embDomain_notin_range {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'} (hb : b ∉ Set.range f) :
    (embDomain f x).coeff b = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'} (hb : b ∉ Set.range ⇑f)
Goal: (HahnSeries.embDomain f x).coeff b = 0
-- HahnSeries.embDomain_zero
@[simp]
theorem embDomain_zero {f : Γ ↪o Γ'} : embDomain f (0 : HahnSeries Γ R) = 0 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'}
Goal: HahnSeries.embDomain f 0 = 0
-- HahnSeries.embDomain_single
@[simp]
theorem embDomain_single {f : Γ ↪o Γ'} {g : Γ} {r : R} :
    embDomain f (single g r) = single (f g) r 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'} {g : Γ} {r : R}
Goal: HahnSeries.embDomain f ((HahnSeries.single g) r) = (HahnSeries.single (f g)) r
-- HahnSeries.embDomain_injective
theorem embDomain_injective {f : Γ ↪o Γ'} :
    Function.Injective (embDomain f : HahnSeries Γ R → HahnSeries Γ' R) 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [Zero R] {Γ' : Type u_3} [PartialOrder Γ'] {f : Γ ↪o Γ'}
Goal: Function.Injective (HahnSeries.embDomain f)
-- HahnSeries.suppBddBelow_supp_PWO
theorem suppBddBelow_supp_PWO (f : Γ → R) (hf : BddBelow (Function.support f)) :
    (Function.support f).IsPWO 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] [LocallyFiniteOrder Γ] (f : Γ → R) (hf : BddBelow (Function.support f))
Goal: (Function.support f).IsPWO
-- HahnSeries.forallLTEqZero_supp_BddBelow
theorem forallLTEqZero_supp_BddBelow (f : Γ → R) (n : Γ) (hn : ∀(m : Γ), m < n → f m = 0) :
    BddBelow (Function.support f) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] (f : Γ → R) (n : Γ) (hn : ∀ m < n, f m = 0)
Goal: BddBelow (Function.support f)
-- HahnSeries.ofSuppBddBelow_coeff
@[simps]
def ofSuppBddBelow (f : Γ → R) (hf : BddBelow (Function.support f)) : HahnSeries Γ R 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] [LocallyFiniteOrder Γ] (f : Γ → R) (hf : BddBelow (Function.support f))
Goal: ∀ (a : Γ), (HahnSeries.ofSuppBddBelow f hf).coeff a = f a
-- HahnSeries.BddBelow_zero
theorem BddBelow_zero [Nonempty Γ] : BddBelow (Function.support (0 : Γ → R)) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] [Nonempty Γ]
Goal: BddBelow (Function.support 0)
-- HahnSeries.zero_ofSuppBddBelow
@[simp]
theorem zero_ofSuppBddBelow [Nonempty Γ] : ofSuppBddBelow 0 BddBelow_zero = (0 : HahnSeries Γ R) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] [LocallyFiniteOrder Γ] [Nonempty Γ]
Goal: HahnSeries.ofSuppBddBelow 0 ⋯ = 0
-- HahnSeries.order_ofForallLtEqZero
theorem order_ofForallLtEqZero [Zero Γ] (f : Γ → R) (hf : f ≠ 0) (n : Γ)
    (hn : ∀(m : Γ), m < n → f m = 0) :
    n ≤ order (ofSuppBddBelow f (forallLTEqZero_supp_BddBelow f n hn)) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Zero R] [LinearOrder Γ] [LocallyFiniteOrder Γ] [Zero Γ] (f : Γ → R) (hf : f ≠ 0) (n : Γ) (hn : ∀ m < n, f m = 0)
Goal: n ≤ (HahnSeries.ofSuppBddBelow f ⋯).order
-- exists_maximalIdeal_pow_eq_of_principal
theorem exists_maximalIdeal_pow_eq_of_principal [IsNoetherianRing R] [LocalRing R] [IsDomain R]
    (h' : (maximalIdeal R).IsPrincipal) (I : Ideal R) (hI : I ≠ ⊥) :
    ∃ n : ℕ, I = maximalIdeal R ^ n 
Arguments: (R : Type u_1) [CommRing R] [IsNoetherianRing R] [LocalRing R] [IsDomain R] (h' : Submodule.IsPrincipal (LocalRing.maximalIdeal R)) (I : Ideal R) (hI : I ≠ ⊥)
Goal: ∃ n, I = LocalRing.maximalIdeal R ^ n
-- maximalIdeal_isPrincipal_of_isDedekindDomain
theorem maximalIdeal_isPrincipal_of_isDedekindDomain [LocalRing R] [IsDomain R]
    [IsDedekindDomain R] : (maximalIdeal R).IsPrincipal 
Arguments: (R : Type u_1) [CommRing R] [LocalRing R] [IsDomain R] [IsDedekindDomain R]
Goal: Submodule.IsPrincipal (LocalRing.maximalIdeal R)
-- tfae_of_isNoetherianRing_of_localRing_of_isDomain
theorem tfae_of_isNoetherianRing_of_localRing_of_isDomain
    [IsNoetherianRing R] [LocalRing R] [IsDomain R] :
    List.TFAE
      [IsPrincipalIdealRing R, ValuationRing R, IsDedekindDomain R,
        IsIntegrallyClosed R ∧ ∀ P : Ideal R, P ≠ ⊥ → P.IsPrime → P = maximalIdeal R,
        (maximalIdeal R).IsPrincipal,
        finrank (ResidueField R) (CotangentSpace R) ≤ 1,
        ∀ (I) (_ : I ≠ ⊥), ∃ n : ℕ, I = maximalIdeal R ^ n] 
Arguments: (R : Type u_1) [CommRing R] [IsNoetherianRing R] [LocalRing R] [IsDomain R]
Goal: [IsPrincipalIdealRing R, ValuationRing R, IsDedekindDomain R,
    IsIntegrallyClosed R ∧ ∀ (P : Ideal R), P ≠ ⊥ → P.IsPrime → P = LocalRing.maximalIdeal R,
    Submodule.IsPrincipal (LocalRing.maximalIdeal R),
    FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) ≤ 1,
    ∀ (I : Ideal R), I ≠ ⊥ → ∃ n, I = LocalRing.maximalIdeal R ^ n].TFAE
-- DiscreteValuationRing.TFAE
theorem DiscreteValuationRing.TFAE [IsNoetherianRing R] [LocalRing R] [IsDomain R]
    (h : ¬IsField R) :
    List.TFAE
      [DiscreteValuationRing R, ValuationRing R, IsDedekindDomain R,
        IsIntegrallyClosed R ∧ ∃! P : Ideal R, P ≠ ⊥ ∧ P.IsPrime, (maximalIdeal R).IsPrincipal,
        finrank (ResidueField R) (CotangentSpace R) = 1,
        ∀ (I) (_ : I ≠ ⊥), ∃ n : ℕ, I = maximalIdeal R ^ n] 
Arguments: (R : Type u_1) [CommRing R] [IsNoetherianRing R] [LocalRing R] [IsDomain R] (h : ¬IsField R)
Goal: [DiscreteValuationRing R, ValuationRing R, IsDedekindDomain R, IsIntegrallyClosed R ∧ ∃! P, P ≠ ⊥ ∧ P.IsPrime,
    Submodule.IsPrincipal (LocalRing.maximalIdeal R),
    FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 1,
    ∀ (I : Ideal R), I ≠ ⊥ → ∃ n, I = LocalRing.maximalIdeal R ^ n].TFAE
-- LocalRing.finrank_CotangentSpace_eq_one_iff
lemma LocalRing.finrank_CotangentSpace_eq_one_iff [IsNoetherianRing R] [LocalRing R] [IsDomain R] :
    finrank (ResidueField R) (CotangentSpace R) = 1 ↔ DiscreteValuationRing R 
Arguments: {R : Type u_1} [CommRing R] [IsNoetherianRing R] [LocalRing R] [IsDomain R]
Goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 1 ↔ DiscreteValuationRing R
-- LocalRing.finrank_CotangentSpace_eq_one
lemma LocalRing.finrank_CotangentSpace_eq_one [IsDomain R] [DiscreteValuationRing R] :
    finrank (ResidueField R) (CotangentSpace R) = 1 
Arguments: (R : Type u_1) [CommRing R] [IsDomain R] [DiscreteValuationRing R]
Goal: FiniteDimensional.finrank (LocalRing.ResidueField R) (LocalRing.CotangentSpace R) = 1
-- HahnSeries.toPowerSeries_apply
@[simps]
def toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R 
Arguments: {R : Type u_2} [Semiring R] (f : HahnSeries ℕ R)
Goal: HahnSeries.toPowerSeries f = PowerSeries.mk f.coeff
-- HahnSeries.toPowerSeries_symm_apply_coeff
@[simps]
def toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R 
Arguments: {R : Type u_2} [Semiring R] (f : PowerSeries R) (n : ℕ)
Goal: (HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff R n) f
-- HahnSeries.coeff_toPowerSeries
theorem coeff_toPowerSeries {f : HahnSeries ℕ R} {n : ℕ} :
    PowerSeries.coeff R n (toPowerSeries f) = f.coeff n 
Arguments: {R : Type u_2} [Semiring R] {f : HahnSeries ℕ R} {n : ℕ}
Goal: (PowerSeries.coeff R n) (HahnSeries.toPowerSeries f) = f.coeff n
-- HahnSeries.coeff_toPowerSeries_symm
theorem coeff_toPowerSeries_symm {f : PowerSeries R} {n : ℕ} :
    (HahnSeries.toPowerSeries.symm f).coeff n = PowerSeries.coeff R n f 
Arguments: {R : Type u_2} [Semiring R] {f : PowerSeries R} {n : ℕ}
Goal: (HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff R n) f
-- HahnSeries.ofPowerSeries_injective
theorem ofPowerSeries_injective : Function.Injective (ofPowerSeries Γ R) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Semiring R] [StrictOrderedSemiring Γ]
Goal: Function.Injective ⇑(HahnSeries.ofPowerSeries Γ R)
-- HahnSeries.ofPowerSeries_apply
theorem ofPowerSeries_apply (x : PowerSeries R) :
    ofPowerSeries Γ R x =
      HahnSeries.embDomain
        ⟨⟨((↑) : ℕ → Γ), Nat.strictMono_cast.injective⟩, by
          simp only [Function.Embedding.coeFn_mk]
          exact Nat.cast_le⟩
        (toPowerSeries.symm x) 
Arguments: {Γ : Type u_1} {R : Type u_2} [Semiring R] [StrictOrderedSemiring Γ] (x : PowerSeries R)
Goal: (HahnSeries.ofPowerSeries Γ R) x =
  HahnSeries.embDomain { toFun := Nat.cast, inj' := ⋯, map_rel_iff' := ⋯ } (HahnSeries.toPowerSeries.symm x)
-- HahnSeries.ofPowerSeries_apply_coeff
theorem ofPowerSeries_apply_coeff (x : PowerSeries R) (n : ℕ) :
    (ofPowerSeries Γ R x).coeff n = PowerSeries.coeff R n x 
Arguments: {Γ : Type u_1} {R : Type u_2} [Semiring R] [StrictOrderedSemiring Γ] (x : PowerSeries R) (n : ℕ)
Goal: ((HahnSeries.ofPowerSeries Γ R) x).coeff ↑n = (PowerSeries.coeff R n) x
-- HahnSeries.ofPowerSeries_C
@[simp]
theorem ofPowerSeries_C (r : R) : ofPowerSeries Γ R (PowerSeries.C R r) = HahnSeries.C r 
Arguments: {Γ : Type u_1} {R : Type u_2} [Semiring R] [StrictOrderedSemiring Γ] (r : R)
Goal: (HahnSeries.ofPowerSeries Γ R) ((PowerSeries.C R) r) = HahnSeries.C r
-- HahnSeries.ofPowerSeries_X
@[simp]
theorem ofPowerSeries_X : ofPowerSeries Γ R PowerSeries.X = single 1 1 
Arguments: {Γ : Type u_1} {R : Type u_2} [Semiring R] [StrictOrderedSemiring Γ]
Goal: (HahnSeries.ofPowerSeries Γ R) PowerSeries.X = (HahnSeries.single 1) 1
-- HahnSeries.ofPowerSeries_X_pow
theorem ofPowerSeries_X_pow {R} [Semiring R] (n : ℕ) :
    ofPowerSeries Γ R (PowerSeries.X ^ n) = single (n : Γ) 1 
Arguments: {Γ : Type u_1} [StrictOrderedSemiring Γ] {R : Type u_3} [Semiring R] (n : ℕ)
Goal: (HahnSeries.ofPowerSeries Γ R) (PowerSeries.X ^ n) = (HahnSeries.single ↑n) 1
-- HahnSeries.toMvPowerSeries_apply
@[simps]
def toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R 
Arguments: {R : Type u_2} [Semiring R] {σ : Type u_3} [Finite σ] (f : HahnSeries (σ →₀ ℕ) R)
Goal: ∀ (a : σ →₀ ℕ), HahnSeries.toMvPowerSeries f a = f.coeff a
-- HahnSeries.toMvPowerSeries_symm_apply_coeff
@[simps]
def toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R 
Arguments: {R : Type u_2} [Semiring R] {σ : Type u_3} [Finite σ] (f : MvPowerSeries σ R)
Goal: (HahnSeries.toMvPowerSeries.symm f).coeff = f
-- HahnSeries.coeff_toMvPowerSeries
theorem coeff_toMvPowerSeries {f : HahnSeries (σ →₀ ℕ) R} {n : σ →₀ ℕ} :
    MvPowerSeries.coeff R n (toMvPowerSeries f) = f.coeff n 
Arguments: {R : Type u_2} [Semiring R] {σ : Type u_3} [Finite σ] {f : HahnSeries (σ →₀ ℕ) R} {n : σ →₀ ℕ}
Goal: (MvPowerSeries.coeff R n) (HahnSeries.toMvPowerSeries f) = f.coeff n
-- HahnSeries.coeff_toMvPowerSeries_symm
theorem coeff_toMvPowerSeries_symm {f : MvPowerSeries σ R} {n : σ →₀ ℕ} :
    (HahnSeries.toMvPowerSeries.symm f).coeff n = MvPowerSeries.coeff R n f 
Arguments: {R : Type u_2} [Semiring R] {σ : Type u_3} [Finite σ] {f : MvPowerSeries σ R} {n : σ →₀ ℕ}
Goal: (HahnSeries.toMvPowerSeries.symm f).coeff n = (MvPowerSeries.coeff R n) f
-- HahnSeries.toPowerSeriesAlg_symm_apply_coeff
@[simps!]
def toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A 
Arguments: (R : Type u_2) [CommSemiring R] {A : Type u_3} [Semiring A] [Algebra R A] (f : PowerSeries A) (n : ℕ)
Goal: ((HahnSeries.toPowerSeriesAlg R).symm f).coeff n = (PowerSeries.coeff A n) f
-- HahnSeries.toPowerSeriesAlg_apply
@[simps!]
def toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A 
Arguments: (R : Type u_2) [CommSemiring R] {A : Type u_3} [Semiring A] [Algebra R A] (f : HahnSeries ℕ A)
Goal: (HahnSeries.toPowerSeriesAlg R) f = PowerSeries.mk f.coeff
-- HahnSeries.ofPowerSeriesAlg_apply_coeff
@[simps!]
def ofPowerSeriesAlg : PowerSeries A →ₐ[R] HahnSeries Γ A 
Arguments: (Γ : Type u_1) (R : Type u_2) [CommSemiring R] {A : Type u_3} [Semiring A] [Algebra R A] [StrictOrderedSemiring Γ]
Goal: ∀ (a : PowerSeries A) (b : Γ),
  ((HahnSeries.ofPowerSeriesAlg Γ R) a).coeff b =
    if h : ∃ x, ¬(PowerSeries.coeff A x) a = 0 ∧ ↑x = b then (PowerSeries.coeff A (Classical.choose ⋯)) a else 0
-- HahnSeries.algebraMap_apply'
theorem algebraMap_apply' (x : S) :
    algebraMap S (HahnSeries Γ R) x = ofPowerSeries Γ R (algebraMap S (PowerSeries R) x) 
Arguments: (Γ : Type u_1) {R : Type u_2} [CommSemiring R] [StrictOrderedSemiring Γ] {S : Type u_4} [CommSemiring S] [Algebra S (PowerSeries R)] (x : S)
Goal: (algebraMap S (HahnSeries Γ R)) x = (HahnSeries.ofPowerSeries Γ R) ((algebraMap S (PowerSeries R)) x)
-- Polynomial.algebraMap_hahnSeries_apply
@[simp]
theorem _root_.Polynomial.algebraMap_hahnSeries_apply (f : R[X]) :
    algebraMap R[X] (HahnSeries Γ R) f = ofPowerSeries Γ R f 
Arguments: (Γ : Type u_1) {R : Type u_2} [CommSemiring R] [StrictOrderedSemiring Γ] (f : R[X])
Goal: (algebraMap R[X] (HahnSeries Γ R)) f = (HahnSeries.ofPowerSeries Γ R) ↑f
-- Polynomial.algebraMap_hahnSeries_injective
theorem _root_.Polynomial.algebraMap_hahnSeries_injective :
    Function.Injective (algebraMap R[X] (HahnSeries Γ R)) 
Arguments: (Γ : Type u_1) {R : Type u_2} [CommSemiring R] [StrictOrderedSemiring Γ]
Goal: Function.Injective ⇑(algebraMap R[X] (HahnSeries Γ R))
-- IsBezout.iff_span_pair_isPrincipal
theorem iff_span_pair_isPrincipal :
    IsBezout R ↔ ∀ x y : R, (Ideal.span {x, y} : Ideal R).IsPrincipal 
Arguments: {R : Type u} [CommRing R]
Goal: IsBezout R ↔ ∀ (x y : R), Submodule.IsPrincipal (Ideal.span {x, y})
-- Function.Surjective.isBezout
theorem _root_.Function.Surjective.isBezout {S : Type v} [CommRing S] (f : R →+* S)
    (hf : Function.Surjective f) [IsBezout R] : IsBezout S 
Arguments: {R : Type u} [CommRing R] {S : Type v} [CommRing S] (f : R →+* S) (hf : Function.Surjective ⇑f) [IsBezout R]
Goal: IsBezout S
-- IsBezout.TFAE
theorem TFAE [IsBezout R] [IsDomain R] :
    List.TFAE
    [IsNoetherianRing R, IsPrincipalIdealRing R, UniqueFactorizationMonoid R, WfDvdMonoid R] 
Arguments: {R : Type u} [CommRing R] [IsBezout R] [IsDomain R]
Goal: [IsNoetherianRing R, IsPrincipalIdealRing R, UniqueFactorizationMonoid R, WfDvdMonoid R].TFAE
-- RingHom.RespectsIso.cancel_left_isIso
theorem RespectsIso.cancel_left_isIso (hP : RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S)
    (g : S ⟶ T) [IsIso f] : P (f ≫ g) ↔ P g 
Arguments: {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} (hP : RingHom.RespectsIso P) {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) [CategoryTheory.IsIso f]
Goal: P (f ≫ g) ↔ P g
-- RingHom.RespectsIso.cancel_right_isIso
theorem RespectsIso.cancel_right_isIso (hP : RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S)
    (g : S ⟶ T) [IsIso g] : P (f ≫ g) ↔ P f 
Arguments: {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} (hP : RingHom.RespectsIso P) {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) [CategoryTheory.IsIso g]
Goal: P (f ≫ g) ↔ P f
-- RingHom.RespectsIso.is_localization_away_iff
theorem RespectsIso.is_localization_away_iff (hP : RingHom.RespectsIso @P) {R S : Type u}
    (R' S' : Type u) [CommRing R] [CommRing S] [CommRing R'] [CommRing S'] [Algebra R R']
    [Algebra S S'] (f : R →+* S) (r : R) [IsLocalization.Away r R'] [IsLocalization.Away (f r) S'] :
    P (Localization.awayMap f r) ↔ P (IsLocalization.Away.map R' S' f r) 
Arguments: {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} (hP : RingHom.RespectsIso P) {R S : Type u} (R' S' : Type u) [CommRing R] [CommRing S] [CommRing R'] [CommRing S'] [Algebra R R'] [Algebra S S'] (f : R →+* S) (r : R) [IsLocalization.Away r R'] [IsLocalization.Away (f r) S']
Goal: P (Localization.awayMap f r) ↔ P (IsLocalization.Away.map R' S' f r)
-- RingHom.StableUnderComposition.respectsIso
theorem StableUnderComposition.respectsIso (hP : RingHom.StableUnderComposition @P)
    (hP' : ∀ {R S : Type u} [CommRing R] [CommRing S] (e : R ≃+* S), P e.toRingHom) :
    RingHom.RespectsIso @P 
Arguments: {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} (hP : RingHom.StableUnderComposition P) (hP' : ∀ {R S : Type u} [inst : CommRing R] [inst_1 : CommRing S] (e : R ≃+* S), P e.toRingHom)
Goal: RingHom.RespectsIso P
-- RingHom.StableUnderBaseChange.mk
theorem StableUnderBaseChange.mk (h₁ : RespectsIso @P)
    (h₂ :
      ∀ ⦃R S T⦄ [CommRing R] [CommRing S] [CommRing T],
        ∀ [Algebra R S] [Algebra R T],
          P (algebraMap R T) →
            P (Algebra.TensorProduct.includeLeftRingHom : S →+* TensorProduct R S T)) :
    StableUnderBaseChange @P 
Arguments: (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (h₁ : RingHom.RespectsIso P) (h₂ :
  ∀ ⦃R S T : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] [inst_3 : Algebra R S]
    [inst_4 : Algebra R T], P (algebraMap R T) → P Algebra.TensorProduct.includeLeftRingHom)
Goal: RingHom.StableUnderBaseChange P
-- RingHom.StableUnderBaseChange.pushout_inl
theorem StableUnderBaseChange.pushout_inl (hP : RingHom.StableUnderBaseChange @P)
    (hP' : RingHom.RespectsIso @P) {R S T : CommRingCat} (f : R ⟶ S) (g : R ⟶ T) (H : P g) :
    P (pushout.inl _ _ : S ⟶ pushout f g) 
Arguments: (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (hP : RingHom.StableUnderBaseChange P) (hP' : RingHom.RespectsIso P) {R S T : CommRingCat} (f : R ⟶ S) (g : R ⟶ T) (H : P g)
Goal: P (CategoryTheory.Limits.pushout.inl f g)
-- RingHom.toMorphismProperty_respectsIso_iff
lemma toMorphismProperty_respectsIso_iff :
    RespectsIso P ↔ (toMorphismProperty P).RespectsIso 
Arguments: {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
Goal: (RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => P) ↔
  (RingHom.toMorphismProperty fun {R S} [CommRing R] [CommRing S] => P).RespectsIso
-- HahnSeries.add_coeff'
@[simp]
theorem add_coeff' {x y : HahnSeries Γ R} : (x + y).coeff = x.coeff + y.coeff 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] {x y : HahnSeries Γ R}
Goal: (x + y).coeff = x.coeff + y.coeff
-- HahnSeries.add_coeff
theorem add_coeff {x y : HahnSeries Γ R} {a : Γ} : (x + y).coeff a = x.coeff a + y.coeff a 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] {x y : HahnSeries Γ R} {a : Γ}
Goal: (x + y).coeff a = x.coeff a + y.coeff a
-- HahnSeries.addOppositeEquiv_symm_apply_coeff
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : (HahnSeries Γ R)ᵃᵒᵖ) (a : Γ)
Goal: (HahnSeries.addOppositeEquiv.symm x).coeff a = AddOpposite.op ((AddOpposite.unop x).coeff a)
-- HahnSeries.addOppositeEquiv_apply
@[simps (config := .lemmasOnly)]
def addOppositeEquiv : HahnSeries Γ (Rᵃᵒᵖ) ≃+ (HahnSeries Γ R)ᵃᵒᵖ 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : HahnSeries Γ Rᵃᵒᵖ)
Goal: HahnSeries.addOppositeEquiv x = AddOpposite.op { coeff := fun a => AddOpposite.unop (x.coeff a), isPWO_support' := ⋯ }
-- HahnSeries.addOppositeEquiv_support
@[simp]
lemma addOppositeEquiv_support (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.support = x.support 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : HahnSeries Γ Rᵃᵒᵖ)
Goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).support = x.support
-- HahnSeries.addOppositeEquiv_symm_support
@[simp]
lemma addOppositeEquiv_symm_support (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).support = x.unop.support 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : (HahnSeries Γ R)ᵃᵒᵖ)
Goal: (HahnSeries.addOppositeEquiv.symm x).support = (AddOpposite.unop x).support
-- HahnSeries.addOppositeEquiv_orderTop
@[simp]
lemma addOppositeEquiv_orderTop (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.orderTop = x.orderTop 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : HahnSeries Γ Rᵃᵒᵖ)
Goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).orderTop = x.orderTop
-- HahnSeries.addOppositeEquiv_symm_orderTop
@[simp]
lemma addOppositeEquiv_symm_orderTop (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).orderTop = x.unop.orderTop 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : (HahnSeries Γ R)ᵃᵒᵖ)
Goal: (HahnSeries.addOppositeEquiv.symm x).orderTop = (AddOpposite.unop x).orderTop
-- HahnSeries.addOppositeEquiv_leadingCoeff
@[simp]
lemma addOppositeEquiv_leadingCoeff (x : HahnSeries Γ (Rᵃᵒᵖ)) :
    (addOppositeEquiv x).unop.leadingCoeff = x.leadingCoeff.unop 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : HahnSeries Γ Rᵃᵒᵖ)
Goal: (AddOpposite.unop (HahnSeries.addOppositeEquiv x)).leadingCoeff = AddOpposite.unop x.leadingCoeff
-- HahnSeries.addOppositeEquiv_symm_leadingCoeff
@[simp]
lemma addOppositeEquiv_symm_leadingCoeff (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).leadingCoeff = .op x.unop.leadingCoeff 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] (x : (HahnSeries Γ R)ᵃᵒᵖ)
Goal: (HahnSeries.addOppositeEquiv.symm x).leadingCoeff = AddOpposite.op (AddOpposite.unop x).leadingCoeff
-- HahnSeries.support_add_subset
theorem support_add_subset {x y : HahnSeries Γ R} : support (x + y) ⊆ support x ∪ support y 
Arguments: {Γ : Type u_1} {R : Type u_2} [PartialOrder Γ] [AddMonoid R] {x y : HahnSeries Γ R}
Goal: (x + y).support ⊆ x.support ∪ y.support
-- HahnSeries.min_le_min_add
protected theorem min_le_min_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} (hx : x ≠ 0)
    (hy : y ≠ 0) (hxy : x + y ≠ 0) :
    min (Set.IsWF.min x.isWF_support (support_nonempty_iff.2 hx))
      (Set.IsWF.min y.isWF_support (support_nonempty_iff.2 hy)) ≤
      Set.IsWF.min (x + y).isWF_support (support_nonempty_iff.2 hxy) 
Arguments: {R : Type u_2} [AddMonoid R] {Γ : Type u_3} [LinearOrder Γ] {x y : HahnSeries Γ R} (hx : x ≠ 0) (hy : y ≠ 0) (hxy : x + y ≠ 0)
Goal: min (⋯.min ⋯) (⋯.min ⋯) ≤ ⋯.min ⋯
-- HahnSeries.min_orderTop_le_orderTop_add
theorem min_orderTop_le_orderTop_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
    min x.orderTop y.orderTop ≤ (x + y).orderTop 
Arguments: {R : Type u_2} [AddMonoid R] {Γ : Type u_3} [LinearOrder Γ] {x y : HahnSeries Γ R}
Goal: min x.orderTop y.orderTop ≤ (x + y).orderTop