ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivWithinAt.neg (h : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun x => -f x) (-f') s x
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem roots_one : (1 : R[X]).roots = ∅
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem coe_inf (p p' : Subgroup G) : ((p ⊓ p' : Subgroup G) : Set G) = (p : Set G) ∩ p'
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem toFinset_smul (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s • t)] :
    (s • t).toFinset = s.toFinset • t.toFinset
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem mk_isRelPrime_iff {a b : α} :
    IsRelPrime (Associates.mk a) (Associates.mk b) ↔ IsRelPrime a b
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem StableUnderCobaseChange.inr {P : MorphismProperty C} (hP : StableUnderCobaseChange P)
    {A B A' : C} (f : A ⟶ A') (g : A ⟶ B) [HasPushout f g] (H : P f) : P (pushout.inr f g)
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma term_congr {f g : ℕ → ℂ} (h : ∀ {n}, n ≠ 0 → f n = g n) (s : ℂ) (n : ℕ) :
    term f s n = term g s n
-- Mathlib/Data/Set/Subset.lean
lemma image_val_preimage_val_subset_self : ↑(A ↓∩ B) ⊆ B
-- Mathlib/Condensed/Discrete.lean
/--
The discrete condensed object associated to an object of `C` is the constant sheaf at that object.
-/
@[simps!]
noncomputable def Condensed.discrete : C ⥤ Condensed.{u} C
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem toProd_comp_inr : (toProd : M ∗ N →* M × N).comp inr = .inr _ _
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp, norm_cast]
theorem coe_insert (x y : ZFSet.{u}) : ↑(insert x y) = @insert ZFSet.{u} Class.{u} _ x y
-- Mathlib/Topology/Basic.lean
theorem subset_closure : s ⊆ closure s
-- Mathlib/Probability/Independence/Kernel.lean
@[to_additive]
lemma iIndepFun.indepFun_div_div (hf_indep : iIndepFun (fun _ ↦ m) f κ μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    IndepFun (f i / f j) (f k / f l) κ μ
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem le_pi_iff {I : Set η} {H : ∀ i, Subgroup (f i)} {J : Subgroup (∀ i, f i)} :
    J ≤ pi I H ↔ ∀ i : η, i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
/-- Middle component of the associator as a natural isomorphism. -/
@[simps!]
def associatorNatIsoMiddle (f : a ⟶ b) (h : c ⟶ d) :
    (precomposing ..).obj f ⋙ (postcomposing ..).obj h ≅
      (postcomposing ..).obj h ⋙ (precomposing ..).obj f
-- Mathlib/Data/ENNReal/Operations.lean
theorem pow_eq_top (n : ℕ) (h : a ^ n = ∞) : a = ∞
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem descFactorial_eq_factorial_mul_choose (n k : ℕ) : n.descFactorial k = k ! * n.choose k
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- An element a divides the sum a + b if and only if a divides b. -/
@[simp]
theorem dvd_add_self_left {a b : α} : a ∣ a + b ↔ a ∣ b
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma compl_ssubset_compl : sᶜ ⊂ tᶜ ↔ t ⊂ s
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sum_apply {ι₁ : Type u₁} [DecidableEq ι₁] {β₁ : ι₁ → Type v₁} [∀ i₁, Zero (β₁ i₁)]
    [∀ (i) (x : β₁ i), Decidable (x ≠ 0)] [∀ i, AddCommMonoid (β i)] {f : Π₀ i₁, β₁ i₁}
    {g : ∀ i₁, β₁ i₁ → Π₀ i, β i} {i₂ : ι} : (f.sum g) i₂ = f.sum fun i₁ b => g i₁ b i₂
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
theorem mk_eq_mk_of_basis' {ι' : Type w} (v : Basis ι R M) (v' : Basis ι' R M) : #ι = #ι'
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem mem_subalgebraOfSubsemiring {x : R} {S : Subsemiring R} :
    x ∈ subalgebraOfSubsemiring S ↔ x ∈ S
-- Mathlib/Topology/Maps/Basic.lean
theorem isOpenMap_iff_interior : IsOpenMap f ↔ ∀ s, f '' interior s ⊆ interior (f '' s)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem fderivWithin_iteratedFDerivWithin {s : Set E} {n : ℕ} :
    fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 n f s) s =
      (continuousMultilinearCurryLeftEquiv 𝕜 (fun _ : Fin (n + 1) => E) F).symm ∘
        iteratedFDerivWithin 𝕜 (n + 1) f s
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem mem_mk {hx : x.1 ≤ x.2} : a ∈ mk x hx ↔ x.1 ≤ a ∧ a ≤ x.2
-- Mathlib/Topology/Maps/Basic.lean
/-- A continuous surjective open map is a quotient map. -/
theorem to_quotientMap (open_map : IsOpenMap f) (cont : Continuous f) (surj : Surjective f) :
    QuotientMap f
-- Mathlib/Topology/Constructions.lean
theorem Pi.continuous_precomp' {ι' : Type*} (φ : ι' → ι) :
    Continuous (fun (f : (∀ i, π i)) (j : ι') ↦ f (φ j))
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_eq_one {x : S} : (x : A) = 1 ↔ x = 1
-- Mathlib/Analysis/Convex/AmpleSet.lean
/-- Images of ample sets under continuous affine equivalences are ample. -/
theorem image {s : Set E} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L '' s)
-- Mathlib/Tactic/NormNum/Ineq.lean
theorem isInt_lt_true [OrderedRing α] [Nontrivial α] : {a b : α} → {a' b' : ℤ} →
    IsInt a a' → IsInt b b' → decide (a' < b') → a < b
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P
-- Mathlib/Data/Nat/Choose/Sum.lean
theorem four_pow_le_two_mul_add_one_mul_central_binom (n : ℕ) :
    4 ^ n ≤ (2 * n + 1) * choose (2 * n) n
-- Mathlib/Algebra/MvPolynomial/Supported.lean
@[simp]
theorem supportedEquivMvPolynomial_symm_X (s : Set σ) (i : s) :
    (↑((supportedEquivMvPolynomial s).symm (X i : MvPolynomial s R)) : MvPolynomial σ R) = X ↑i
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma _root_.Commute.sum_right [NonUnitalNonAssocSemiring α] (s : Finset ι) (f : ι → α) (b : α)
    (h : ∀ i ∈ s, Commute b (f i)) : Commute b (∑ i ∈ s, f i)
-- Mathlib/Data/NNReal/Basic.lean
@[norm_cast]
theorem coe_multiset_prod (s : Multiset ℝ≥0) : ((s.prod : ℝ≥0) : ℝ) = (s.map (↑)).prod
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[continuity, fun_prop]
theorem continuous_cosh : Continuous cosh
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_mul_eq_zero_of_right (p : R[X]) (hq : q.eval₂ f x = 0) : (p * q).eval₂ f x = 0
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
lemma toNNReal_le_natCast {r : ℝ} {n : ℕ} : r.toNNReal ≤ n ↔ r ≤ n
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[simp]
theorem _root_.aemeasurable_iUnion_iff [Countable ι] {s : ι → Set α} :
    AEMeasurable f (μ.restrict (⋃ i, s i)) ↔ ∀ i, AEMeasurable f (μ.restrict (s i))
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
/-- Converse to the mean value inequality: if `f` is `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`.
Version using `deriv`. -/
theorem norm_deriv_le_of_lipschitzOn {f : 𝕜 → F} {x₀ : 𝕜} {s : Set 𝕜} (hs : s ∈ 𝓝 x₀)
    {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖deriv f x₀‖ ≤ C
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp)]
protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
theorem kernel_not_iso_of_nonzero (w : f ≠ 0) : IsIso (kernel.ι f) → False
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem coe_center : ↑(center R) = Set.center R
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `S ∈ 𝔖`, then the restriction to `S` is a uniformly continuous map from `α →ᵤ[𝔖] β` to
`↥S →ᵤ β`. -/
protected theorem uniformContinuous_restrict (h : s ∈ 𝔖) :
    UniformContinuous (UniformFun.ofFun ∘ (s.restrict : (α → β) → s → β) ∘ toFun 𝔖)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem denom_zero : denom (0 : RatFunc K) = 1
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Given a monoid homomorphism `f`, the induced homomorphism on the quotient by `f`'s kernel has
    the same image as `f`. -/
@[to_additive (attr := simp) "Given an `AddMonoid` homomorphism `f`, the induced homomorphism
on the quotient by `f`'s kernel has the same image as `f`."]
theorem kerLift_range_eq : MonoidHom.mrange (kerLift f) = MonoidHom.mrange f
-- Mathlib/Order/LiminfLimsup.lean
theorem liminf_min [ConditionallyCompleteLinearOrder β] {f : Filter α} {u v : α → β}
    (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₂ : f.IsCoboundedUnder (· ≥ ·) v := by isBoundedDefault)
    (h₃ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₄ : f.IsBoundedUnder (· ≥ ·) v := by isBoundedDefault) :
    liminf (fun a ↦ min (u a) (v a)) f = min (liminf u f) (liminf v f)
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
/-- A pointed Galois object is a Galois object with a fixed point of its fiber. -/
structure PointedGaloisObject : Type (max u₁ u₂) where
  /-- The underlying object of `C`. -/
  obj : C
  /-- An element of the fiber of `obj`. -/
  pt : F.obj obj
  /-- `obj` is Galois. -/
  isGalois : IsGalois obj := by infer_instance
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem pure_seq {f : α → β} {x : FreeSemigroup α} : pure f <*> x = f <$> x
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem oadd_lt_oadd_1 {e₁ n₁ o₁ e₂ n₂ o₂} (h₁ : NF (oadd e₁ n₁ o₁)) (h : e₁ < e₂) :
    oadd e₁ n₁ o₁ < oadd e₂ n₂ o₂
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_ciInf_iff [Nonempty ι] {f : ι → α} {a : α} (hf : BddBelow (range f)) :
    a ≤ iInf f ↔ ∀ i, a ≤ f i
-- Mathlib/CategoryTheory/Monoidal/Center.lean
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorObj (X Y : Center C) : Center C
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem head_cons (a : α) (s : Stream' α) : head (a::s) = a
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_top : ⇑(⊤ : InfTopHom α β) = ⊤
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp, norm_cast] lemma ofENat_one : ofENat 1 = 1
-- Mathlib/NumberTheory/Cyclotomic/Discriminant.lean
/-- If `p` is an odd prime and `IsCyclotomicExtension {p} K L`, then
`discr K (hζ.powerBasis K).basis = (-1) ^ ((p - 1) / 2) * p ^ (p - 2)` if
`Irreducible (cyclotomic p K)`. -/
theorem discr_odd_prime [IsCyclotomicExtension {p} K L] [hp : Fact (p : ℕ).Prime]
    (hζ : IsPrimitiveRoot ζ p) (hirr : Irreducible (cyclotomic p K)) (hodd : p ≠ 2) :
    discr K (hζ.powerBasis K).basis = (-1) ^ (((p : ℕ) - 1) / 2) * p ^ ((p : ℕ) - 2)
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem measure_union₀' (hs : NullMeasurableSet s μ) (hd : AEDisjoint μ s t) :
    μ (s ∪ t) = μ s + μ t
-- Mathlib/LinearAlgebra/Basis.lean
theorem groupSMul_apply {G : Type*} [Group G] [DistribMulAction G R] [DistribMulAction G M]
    [IsScalarTower G R M] [SMulCommClass G R M] {v : Basis ι R M} {w : ι → G} (i : ι) :
    v.groupSMul w i = (w • (v : ι → M)) i
-- Mathlib/Data/Set/Subsingleton.lean
protected theorem Subsingleton.strictMonoOn (h : s.Subsingleton) : StrictMonoOn f s
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma _root_.MeasurableEmbedding.map_withDensity_rnDeriv (hf : MeasurableEmbedding f)
    (μ ν : Measure α) [SigmaFinite μ] [SigmaFinite ν] :
    (ν.withDensity (μ.rnDeriv ν)).map f = (ν.map f).withDensity ((μ.map f).rnDeriv (ν.map f))
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inclusion_mk {h : s ⊆ t} (a : α) (ha : a ∈ s) : inclusion h ⟨a, ha⟩ = ⟨a, h ha⟩
-- Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
@[simp]
theorem antidiagonalTuple_zero_zero : antidiagonalTuple 0 0 = {![]}
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffineLift_of_Z_ne_zero {P : Fin 3 → F} {hP : W.NonsingularLift ⟦P⟧} (hPz : P z ≠ 0) :
    toAffineLift ⟨hP⟩ = .some ((nonsingular_of_Z_ne_zero hPz).mp hP)
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma inv_mul_eq_one (h : IsUnit a) : a⁻¹ * b = 1 ↔ a = b
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isGreatest_univ_iff : IsGreatest univ a ↔ IsTop a
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
@[simp]
theorem norm_eq_norm (x : K) :
    mixedEmbedding.norm (mixedEmbedding K x) = |Algebra.norm ℚ x|
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_toAffineEquiv (e : P ≃ᵃⁱ[𝕜] P₂) : ⇑e.toAffineEquiv = e
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
@[simp] theorem coe_toEquiv (e : X ≃ᵈ Y) : ⇑e.toEquiv = e
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_sub_pos : 0 < |a - b| ↔ a ≠ b
-- Mathlib/Data/Finset/Fold.lean
theorem fold_disjiUnion {ι : Type*} {s : Finset ι} {t : ι → Finset α} {b : ι → β} {b₀ : β} (h) :
    (s.disjiUnion t h).fold op (s.fold op b₀ b) f = s.fold op b₀ fun i => (t i).fold op (b i) f
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem LocallyIntegrableOn.mono_set (hf : LocallyIntegrableOn f s μ) {t : Set X}
    (hst : t ⊆ s) : LocallyIntegrableOn f t μ
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem contDiff_exp : ∀ {n}, ContDiff 𝕜 n exp
-- Mathlib/Order/SuccPred/Basic.lean
theorem Icc_succ_left_of_not_isMax (ha : ¬IsMax a) : Icc (succ a) b = Ioc a b
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem order_eq_find' [DecidablePred fun n => p n ≠ 0] (hp : p ≠ 0) :
    p.order = Nat.find (FormalMultilinearSeries.ne_iff.mp hp)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem ciInf_pos {p : Prop} {f : p → α} (hp : p) : ⨅ h : p, f h = f hp
-- Mathlib/Data/List/Destutter.lean
theorem mem_destutter' (a) : a ∈ l.destutter' R a
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem smul (r : R) (hφ : IsSymmetric φ) : IsSymmetric (r • φ)
-- Mathlib/Data/Nat/Size.lean
theorem size_le_size {m n : ℕ} (h : m ≤ n) : size m ≤ size n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_of_mem_cons_of_mem : ∀ {a b : α} {l : List α}, a ∈ b :: l → b ∈ l → a ∈ l
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[simp]
theorem Cocone.ofCotrident_ι {F : WalkingParallelFamily J ⥤ C}
    (t : Cotrident fun j => F.map (line j)) (j) :
    (Cocone.ofCotrident t).ι.app j = eqToHom (by cases j <;> aesop_cat) ≫ t.ι.app j
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Set.finite_iff_bddBelow_bddAbove [Nonempty α] [Lattice α] [LocallyFiniteOrder α] :
    s.Finite ↔ BddBelow s ∧ BddAbove s
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
theorem C_inv (r : k) : (C σ k r)⁻¹ = C σ k r⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[deprecated getElem?_take_eq_none (since := "2024-06-12")]
theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
    (l.take n).get? m = none
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
/-- `Function.const` as a `MulHom`. -/
@[to_additive (attr := simps) "`Function.const` as an `AddHom`."]
def Pi.constMulHom (α β : Type*) [Mul β] :
    β →ₙ* α → β
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.coprime_of_no_prime_ge {I J : Ideal R} (h : ∀ P, I ≤ P → J ≤ P → ¬IsPrime P) :
    IsCoprime I J
-- Mathlib/Data/PNat/Factors.lean
@[simp]
theorem coe_coeNatMonoidHom : (coeNatMonoidHom : PrimeMultiset → Multiset ℕ) = Coe.coe
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- Variant of `IsPullback.of_right` where `h₁₁` is induced from a morphism `h₁₃ : X₁₁ ⟶ X₁₃`, and
the universal property of the right square.

The objects fit in the following diagram:
```
X₁₁ - h₁₁ -> X₁₂ - h₁₂ -> X₁₃
|            |            |
v₁₁          v₁₂          v₁₃
↓            ↓            ↓
X₂₁ - h₂₁ -> X₂₂ - h₂₂ -> X₂₃
```
-/
theorem of_right' {X₁₁ X₁₂ X₁₃ X₂₁ X₂₂ X₂₃ : C} {h₁₂ : X₁₂ ⟶ X₁₃} {h₂₁ : X₂₁ ⟶ X₂₂}
    {h₂₂ : X₂₂ ⟶ X₂₃} {h₁₃ : X₁₁ ⟶ X₁₃} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₁₃ : X₁₃ ⟶ X₂₃}
    (s : IsPullback h₁₃ v₁₁ v₁₃ (h₂₁ ≫ h₂₂)) (t : IsPullback h₁₂ v₁₂ v₁₃ h₂₂) :
    IsPullback (t.lift h₁₃ (v₁₁ ≫ h₂₁) (by rw [s.w, Category.assoc])) v₁₁ v₁₂ h₂₁
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp]
theorem set_smul_subset_set_smul_iff₀ (ha : a ≠ 0) {A B : Set β} : a • A ⊆ a • B ↔ A ⊆ B
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem denom_one : denom (1 : RatFunc K) = 1
-- Mathlib/CategoryTheory/Subobject/Comma.lean
/-- Technical lemma for `lift_projectQuotient`. -/
@[simp]
theorem unop_left_comp_underlyingIso_hom_unop {A : CostructuredArrow S T}
    {P : (CostructuredArrow S T)ᵒᵖ} (f : P ⟶ op A) [Mono f.unop.left.op] :
    f.unop.left ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop =
      (Subobject.mk f.unop.left.op).arrow.unop
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Auxiliary lemma for `biproduct.uniqueUpToIso`. -/
theorem biproduct.conePointUniqueUpToIso_hom (f : J → C) [HasBiproduct f] {b : Bicone f}
    (hb : b.IsBilimit) :
    (hb.isLimit.conePointUniqueUpToIso (biproduct.isLimit _)).hom = biproduct.lift b.π
-- Mathlib/Order/Bounds/Basic.lean
theorem lub_Iio_le (a : α) (hb : IsLUB (Iio a) b) : b ≤ a
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma one_eq_ofENat {m : ℕ∞} : 1 = (m : Cardinal) ↔ m = 1
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma leadingCoeff_preΨ₄ (h : (2 : R) ≠ 0) : W.preΨ₄.leadingCoeff = 2
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Iic : (some : α → WithTop α) ⁻¹' Iic a = Iic a
-- Mathlib/Data/Opposite.lean
@[simp]
theorem equivToOpposite_symm_coe : (equivToOpposite.symm : αᵒᵖ → α) = unop
-- Mathlib/Data/Nat/Defs.lean
lemma self_add_pred (n : ℕ) : n + pred n = (2 * n).pred
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
lemma card_mul_le : Nat.card (s * t) ≤ Nat.card s * Nat.card t
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem dropLast_eq_take (l : List α) : l.dropLast = l.take l.length.pred
-- Mathlib/Deprecated/Submonoid.lean
theorem Multiplicative.isSubmonoid {s : Set A} :
    IsAddSubmonoid s → @IsSubmonoid (Multiplicative A) _ s
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/-- Construct an affine scheme from a scheme and the information that it is affine.
Also see `AffineScheme.of` for a typeclass version. -/
@[simps]
def AffineScheme.mk (X : Scheme) (_ : IsAffine X) : AffineScheme
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
protected theorem congr_arg {f : MulEquiv M N} {x x' : M} : x = x' → f x = f x'
-- Mathlib/Algebra/Algebra/Field.lean
@[norm_cast]
theorem coe_ratCast (q : ℚ) : ↑(q : R) = (q : A)
-- Mathlib/RingTheory/Polynomial/Nilpotent.lean
lemma isNilpotent_aeval_sub_of_isNilpotent_sub (h : IsNilpotent (a - b)) :
    IsNilpotent (aeval a P - aeval b P)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
theorem lcm_assoc (m n k : Nat) : lcm (lcm m n) k = lcm m (lcm n k)
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.sigma {σ : α → Type*} {l₂ : ∀ a , List (σ a)} (d₁ : Nodup l₁)
    (d₂ : ∀ a , Nodup (l₂ a)) : (l₁.sigma l₂).Nodup
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem conformalAt_const_smul {c : ℝ} (h : c ≠ 0) (x : X) : ConformalAt (fun x' : X => c • x') x
-- Mathlib/Topology/NoetherianSpace.lean
/-- [Stacks: Lemma 0052 (2)](https://stacks.math.columbia.edu/tag/0052) -/
theorem NoetherianSpace.finite_irreducibleComponents [NoetherianSpace α] :
    (irreducibleComponents α).Finite
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem natTrailingDegree_mul_mirror :
    (p * p.mirror).natTrailingDegree = 2 * p.natTrailingDegree
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_map [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α)
    : (f <$> x).run = Except.map f <$> x.run
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda' F).hom ≫ limit.π (F.rightOp ⋙ coyoneda) i
      = coyoneda.map (colimit.ι F ⟨i⟩).op
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem coe_toEquiv (f : M ≃* N) : ⇑(f : M ≃ N) = f
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
/-- **Fermat's Theorem**: the derivative of a function at a local extremum equals zero. -/
theorem IsLocalExtr.hasDerivAt_eq_zero (h : IsLocalExtr f a) : HasDerivAt f f' a → f' = 0
-- Mathlib/RingTheory/FreeCommRing.lean
theorem isSupported_one : IsSupported 1 s
-- Mathlib/Analysis/Complex/Basic.lean
theorem norm_real (r : ℝ) : ‖(r : ℂ)‖ = ‖r‖
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.aestronglyMeasurable {β : Type*} [TopologicalSpace β] [PseudoMetrizableSpace β]
    [l.IsCountablyGenerated] [l.NeBot] {f : α → β} {φ : ι → Set α} (hφ : AECover μ l φ)
    (hfm : ∀ i, AEStronglyMeasurable f (μ.restrict <| φ i)) : AEStronglyMeasurable f μ
-- Mathlib/Topology/Defs/Basic.lean
@[simp] theorem isOpen_univ : IsOpen (univ : Set X)
-- Mathlib/RingTheory/Binomial.lean
@[simp]
theorem choose_one_right' (r : R) : choose r 1 = r ^ 1
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- The preimage of the normalizer is equal to the normalizer of the preimage of a surjective
  function. -/
@[to_additive
      "The preimage of the normalizer is equal to the normalizer of the preimage of
      a surjective function."]
theorem comap_normalizer_eq_of_surjective (H : Subgroup G) {f : N →* G}
    (hf : Function.Surjective f) : H.normalizer.comap f = (H.comap f).normalizer
-- Mathlib/NumberTheory/NumberField/Basic.lean
@[norm_cast]
theorem eq_iff {x y : 𝓞 K} : (x : K) = (y : K) ↔ x = y
-- Mathlib/NumberTheory/WellApproximable.lean
@[to_additive]
theorem smul_subset_of_coprime (han : (orderOf a).Coprime n) :
    a • approxOrderOf A n δ ⊆ approxOrderOf A (orderOf a * n) δ
-- Mathlib/RingTheory/IntegralClosure/Algebra/Basic.lean
theorem RingHom.IsIntegralElem.sub {x y : S} (hx : f.IsIntegralElem x) (hy : f.IsIntegralElem y) :
    f.IsIntegralElem (x - y)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma aeval_derivative_mem_differentIdeal [NoZeroSMulDivisors A B]
    (x : B) (hx : Algebra.adjoin K {algebraMap B L x} = ⊤) :
    aeval x (derivative (minpoly A x)) ∈ differentIdeal A B
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem mk_coe (e : A₁ ≃ₐ[R] A₂) (e' h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨e, e', h₁, h₂⟩, h₃, h₄, h₅⟩ : A₁ ≃ₐ[R] A₂) = e
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_lt_pow_succ (h : 1 < a) : a ^ n < a ^ (n + 1)
-- Mathlib/Algebra/Group/Opposite.lean
/-- A semigroup homomorphism `f : M →ₙ* N` such that `f x` commutes with `f y` for all `x, y`
defines a semigroup homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive semigroup homomorphism `f : AddHom M N` such that `f x` additively
      commutes with `f y` for all `x, y` defines an additive semigroup homomorphism to `Sᵃᵒᵖ`."]
def MulHom.toOpposite {M N : Type*} [Mul M] [Mul N] (f : M →ₙ* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →ₙ* Nᵐᵒᵖ
-- Mathlib/Order/SymmDiff.lean
protected theorem Codisjoint.bihimp_left (ha : Codisjoint a c) (hb : Codisjoint b c) :
    Codisjoint (a ⇔ b) c
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem X_dvd_monomial {i : σ} {j : σ →₀ ℕ} {r : R} :
    (X i : MvPolynomial σ R) ∣ monomial j r ↔ r = 0 ∨ j i ≠ 0
-- Mathlib/Logic/Embedding/Basic.lean
/-- The embedding of `α` into the sum `α ⊕ β`. -/
@[simps]
def inl {α β : Type*} : α ↪ α ⊕ β
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropWithinAt_self {f : H → H'} {s : Set H} {x : H} :
    LiftPropWithinAt P f s x ↔ ContinuousWithinAt f s x ∧ P f s x
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma tendsto_densityProcess_limitProcess (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∀ᵐ x ∂(ν a), Tendsto (fun n ↦ densityProcess κ ν n a x s) atTop
      (𝓝 ((countableFiltration γ).limitProcess
      (fun n x ↦ densityProcess κ ν n a x s) (ν a) x))
-- Mathlib/CategoryTheory/EpiMono.lean
/-- A constructor for `IsSplitMono f` taking a `SplitMono f` as an argument -/
theorem IsSplitMono.mk' {X Y : C} {f : X ⟶ Y} (sm : SplitMono f) : IsSplitMono f
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
@[simp] lemma map'_coe (f : α →* β) (x : α) : map' f (x : WithZero α) = f x