ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_hasBinaryCoproduct' [HasBinaryCoproduct X Y] [HasInitial C] :
    IsPushout (initial.to _) (initial.to _) (coprod.inl : X ⟶ _) (coprod.inr : Y ⟶ _)
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_one : ((1 : ℤ[i]) : ℂ) = 1
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
lemma IsRightDerivedFunctor.isLeftKanExtension
    [L.IsLocalization W] [RF.IsRightDerivedFunctor α W] :
    RF.IsLeftKanExtension α
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem coeff_C_mul_X_pow (x : R) (k n : ℕ) :
    coeff (C x * X ^ k : R[X]) n = if n = k then x else 0
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem HasMFDerivAt.neg (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f') :
    HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f')
-- Mathlib/Topology/Instances/Nat.lean
theorem closedBall_eq_Icc (x : ℕ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉₊ ⌊↑x + r⌋₊
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem _root_.LinearEquiv.toAddEquiv_toNatLinearEquiv (e : M ≃ₗ[ℕ] M₂) :
    AddEquiv.toNatLinearEquiv ↑e = e
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- Generalization of `Finset.prod_comm` to the case when the inner `Finset`s depend on the outer
variable. -/
@[to_additive "Generalization of `Finset.sum_comm` to the case when the inner `Finset`s depend on
the outer variable."]
theorem prod_comm' {s : Finset γ} {t : γ → Finset α} {t' : Finset α} {s' : α → Finset γ}
    (h : ∀ x y, x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t') {f : γ → α → β} :
    (∏ x ∈ s, ∏ y ∈ t x, f x y) = ∏ y ∈ t', ∏ x ∈ s' y, f x y
-- Mathlib/Data/Int/GCD.lean
theorem gcd_pos_iff {i j : ℤ} : 0 < gcd i j ↔ i ≠ 0 ∨ j ≠ 0
-- Mathlib/Topology/Algebra/Constructions.lean
@[to_additive]
theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
private lemma expCoeff_cast (n : ℕ) : (expCoeff n : ℚ) = if Even n then (n / 2 : ℚ) else n
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
lemma mapComp_id_right (f : a ⟶ b) : (F.mapComp f (𝟙 b)) = F.map₂Iso (ρ_ f) ≪≫
    (ρ_ (F.map f)).symm ≪≫ (whiskerLeftIso (F.map f) (F.mapId b)).symm
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem union_diff_left {s t : Set α} : (s ∪ t) \ s = t \ s
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem funMap_sum_inr {n : ℕ} (f : L₂.Functions n) :
    @funMap (L₁.sum L₂) S _ n (Sum.inr f) = funMap f
-- Mathlib/CategoryTheory/Localization/LocalizerMorphism.lean
/-- The opposite localizer morphism `LocalizerMorphism W₁.op W₂.op` deduced
from `Φ : LocalizerMorphism W₁ W₂`. -/
@[simps]
def op : LocalizerMorphism W₁.op W₂.op
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem taylor_coeff_one : (taylor r f).coeff 1 = f.derivative.eval r
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem HasFDerivAtFilter.neg (h : HasFDerivAtFilter f f' x L) :
    HasFDerivAtFilter (fun x => -f x) (-f') x L
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
/-- A vector space has dimension at most `1` if and only if there is a
single vector of which all vectors are multiples. -/
theorem rank_le_one_iff [Module.Free K V] :
    Module.rank K V ≤ 1 ↔ ∃ v₀ : V, ∀ v, ∃ r : K, r • v₀ = v
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : α) : WithTop α) = 1
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_le_iff_of_lt [IsWellOrder ι (· < ·)] {m : ι} (i : ι) (hi : i < m) :
    hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem tprod_le_tprod_of_inj {g : κ → α} (e : ι → κ) (he : Injective e)
    (hs : ∀ c, c ∉ Set.range e → 1 ≤ g c) (h : ∀ i, f i ≤ g (e i)) (hf : Multipliable f)
    (hg : Multipliable g) : tprod f ≤ tprod g
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
/-- Interpret a `RingHom` `f` as an `f`-semilinear map. -/
@[simps]
def _root_.RingHom.toSemilinearMap (f : R →+* S) : R →ₛₗ[f] S
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
protected theorem IsCycleOn.apply_ne (hf : f.IsCycleOn s) (hs : s.Nontrivial) (ha : a ∈ s) :
    f a ≠ a
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
/-- Equality of linear maps out of an adic completion can be checked on Cauchy sequences. -/
@[ext]
theorem map_ext' {f g : AdicCompletion I M →ₗ[AdicCompletion I R] T}
    (h : ∀ (a : AdicCauchySequence I M),
      f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
    f = g
-- Mathlib/GroupTheory/Complement.lean
theorem equiv_snd_eq_self_iff_mem {g : G} (h1 : 1 ∈ S) :
    ((hST.equiv g).snd : G) = g ↔ g ∈ T
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma changeLevel_self_toUnitHom : (changeLevel (dvd_refl n) χ).toUnitHom = χ.toUnitHom
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
lemma top_preconnected : (⊤ : SimpleGraph V).Preconnected
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem toDual_toDual : b.dualBasis.toDual.comp b.toDual = Dual.eval R M
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_sdiff_left : a ∆ b \ a = b \ a
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem tan_eq_sin_div_cos : tan x = sin x / cos x
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_comap_eq (H : Subgroup N) : map f (comap f H) = f.range ⊓ H
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem truncate_wittVector_truncate {m : ℕ} (hm : n ≤ m) (x : 𝕎 R) :
    truncate hm (WittVector.truncate m x) = WittVector.truncate n x
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_Ici_atTop [SemilatticeSup α] {a : α} {f : β → Ici a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop
-- Mathlib/ModelTheory/ElementaryMaps.lean
/-- The canonical elementary embedding of an `L`-structure into any model of its elementary diagram
-/
@[simps]
def ElementaryEmbedding.ofModelsElementaryDiagram (N : Type*) [L.Structure N] [L[[M]].Structure N]
    [(lhomWithConstants L M).IsExpansionOn N] [N ⊨ L.elementaryDiagram M] : M ↪ₑ[L] N
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive (attr := simp)]
theorem pure_one : pure (1 : α) = 1
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- If the union of a.e.-disjoint null-measurable sets has finite measure, then there are only
finitely many members of the union whose measure exceeds any given positive number. -/
theorem finite_const_le_meas_of_disjoint_iUnion₀ {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {ε : ℝ≥0∞} (ε_pos : 0 < ε) {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) (Union_As_finite : μ (⋃ i, As i) ≠ ∞) :
    Set.Finite { i : ι | ε ≤ μ (As i) }
-- Mathlib/Topology/Order/Category/AlexDisc.lean
@[simp] lemma coe_forgetToTop (X : AlexDisc) : ↥((forget₂ _ TopCat).obj X) = X
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
@[to_additive]
theorem continuous_comp_right (f : ContinuousMonoidHom B C) :
    Continuous fun g : ContinuousMonoidHom A B => f.comp g
-- Mathlib/Probability/Kernel/IntegralCompProd.lean
theorem hasFiniteIntegral_compProd_iff ⦃f : β × γ → E⦄ (h1f : StronglyMeasurable f) :
    HasFiniteIntegral f ((κ ⊗ₖ η) a) ↔
      (∀ᵐ x ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))) ∧
        HasFiniteIntegral (fun x => ∫ y, ‖f (x, y)‖ ∂η (a, x)) (κ a)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.def (h : f =o[l] g) (hc : 0 < c) : ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Data/Set/Image.lean
theorem image_inter_on {f : α → β} {s t : Set α} (h : ∀ x ∈ t, ∀ y ∈ s, f x = f y → x = y) :
    f '' (s ∩ t) = f '' s ∩ f '' t
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- Evaluation as a `RingHom` -/
@[simps!] def evalRingHom [Semiring Y] (x : X) : LocallyConstant X Y →+* Y
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem apply_eq_one_iff (p : PMF α) (a : α) : p a = 1 ↔ p.support = {a}
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem aroots_monomial [CommRing S] [IsDomain S] [Algebra T S]
    [NoZeroSMulDivisors T S] {a : T} (ha : a ≠ 0) (n : ℕ) :
    (monomial n a).aroots S = n • ({0} : Multiset S)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- A point-free means of proving membership in the center, for a non-associative ring.

This can be helpful when working with types that have ext lemmas for `R →+ R`. -/
lemma _root_.Set.mem_center_iff_addMonoidHom (a : R) :
    a ∈ Set.center R ↔
      AddMonoidHom.mulLeft a = .mulRight a ∧
      AddMonoidHom.compr₂ .mul (.mulLeft a) = .comp .mul (.mulLeft a) ∧
      AddMonoidHom.comp .mul (.mulRight a) = .compl₂ .mul (.mulLeft a) ∧
      AddMonoidHom.compr₂ .mul (.mulRight a) = .compl₂ .mul (.mulRight a)
-- Mathlib/CategoryTheory/Shift/CommShift.lean
@[simp, reassoc]
lemma map_shiftFunctorCompIsoId_hom_app [F.CommShift A] (X : C) (a b : A) (h : a + b = 0) :
    F.map ((shiftFunctorCompIsoId C a b h).hom.app X) =
      (F.commShiftIso b).hom.app (X⟦a⟧) ≫ ((F.commShiftIso a).hom.app X)⟦b⟧' ≫
        (shiftFunctorCompIsoId D a b h).hom.app (F.obj X)
-- Mathlib/Topology/Instances/Int.lean
theorem closedBall_eq_Icc (x : ℤ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉ ⌊↑x + r⌋
-- Mathlib/CategoryTheory/Localization/Predicate.lean
theorem essSurj (W) [L.IsLocalization W] : L.EssSurj
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem homothety_def (c : P1) (r : k) :
    homothety c r = r • (id k P1 -ᵥ const k P1 c) +ᵥ const k P1 c
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem leadingCoeff_add_of_degree_eq (h : degree p = degree q)
    (hlc : leadingCoeff p + leadingCoeff q ≠ 0) :
    leadingCoeff (p + q) = leadingCoeff p + leadingCoeff q
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem false_eq_decide_iff {p : Prop} [h : Decidable p] : false = decide p ↔ ¬p
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
lemma mem_orbit_subMul_iff {p : SubMulAction R M} {x m : p} :
    x ∈ MulAction.orbit R m ↔ (x : M) ∈ MulAction.orbit R (m : M)
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem mk_neg (z : ℂ) (hz : abs (-z) < 1) : mk (-z) hz = -mk z (abs.map_neg z ▸ hz)
-- Mathlib/RingTheory/Polynomial/Eisenstein/IsIntegral.lean
theorem mem_adjoin_of_dvd_coeff_of_dvd_aeval {A B : Type*} [CommSemiring A] [CommRing B]
    [Algebra A B] [NoZeroSMulDivisors A B] {Q : A[X]} {p : A} {x z : B} (hp : p ≠ 0)
    (hQ : ∀ i ∈ range (Q.natDegree + 1), p ∣ Q.coeff i) (hz : aeval x Q = p • z) :
    z ∈ adjoin A ({x} : Set B)
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.eq_top : Codisjoint a b → a ⊔ b = ⊤
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem abelianizationCongr_symm : e.abelianizationCongr.symm = e.symm.abelianizationCongr
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem mem_map {I : FractionalIdeal S P} {g : P →ₐ[R] P'} {y : P'} :
    y ∈ I.map g ↔ ∃ x, x ∈ I ∧ g x = y
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem catalan_three : catalan 3 = 5
-- Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
/-- Taking the `MultilinearMap.alternatization` of the `MultilinearMap.domCoprod` of two
`AlternatingMap`s gives a scaled version of the `AlternatingMap.coprod` of those maps.
-/
theorem MultilinearMap.domCoprod_alternization_eq [DecidableEq ιa] [DecidableEq ιb]
    (a : Mᵢ [⋀^ιa]→ₗ[R'] N₁) (b : Mᵢ [⋀^ιb]→ₗ[R'] N₂) :
    MultilinearMap.alternatization
      (MultilinearMap.domCoprod a b : MultilinearMap R' (fun _ : ιa ⊕ ιb => Mᵢ) (N₁ ⊗ N₂)) =
      ((Fintype.card ιa).factorial * (Fintype.card ιb).factorial) • a.domCoprod b
-- Mathlib/Data/Multiset/Sum.lean
theorem disjSum_mono (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂) : s₁.disjSum t₁ ≤ s₂.disjSum t₂
-- Mathlib/AlgebraicGeometry/Restrict.lean
lemma Scheme.map_basicOpen' (r : Γ(U, ⊤)) :
    U.ι ''ᵁ (U.toScheme.basicOpen r) = X.basicOpen
      (X.presheaf.map (eqToHom U.openEmbedding_obj_top.symm).op r)
-- Mathlib/Data/Real/Pointwise.lean
theorem Real.iInf_mul_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (⨅ i, f i) * r = ⨅ i, f i * r
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- The diameter of a singleton vanishes -/
@[simp]
theorem diam_singleton : diam ({x} : Set α) = 0
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@[simp]
lemma finsuppLeft_symm_apply_single (i : ι) (m : M) (n : N) :
    (finsuppLeft R M N ι).symm (Finsupp.single i (m ⊗ₜ[R] n)) =
      Finsupp.single i m ⊗ₜ[R] n
-- Mathlib/GroupTheory/Complement.lean
theorem IsComplement'.card_mul (h : IsComplement' H K) :
    Nat.card H * Nat.card K = Nat.card G
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
/-- Implementation of `CommMon_.equivLaxBraidedFunctorPunit`. -/
@[simps]
def commMonToLaxBraided : CommMon_ C ⥤ LaxBraidedFunctor (Discrete PUnit.{u + 1}) C
-- Mathlib/Algebra/Ring/Center.lean
@[simp]
theorem intCast_mem_center [NonAssocRing M] (n : ℤ) : (n : M) ∈ Set.center M
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem map_monotone {G' : SimpleGraph W} (f : G →g G') : Monotone (Subgraph.map f)
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem partiallyWellOrderedOn_union :
    (s ∪ t).PartiallyWellOrderedOn r ↔ s.PartiallyWellOrderedOn r ∧ t.PartiallyWellOrderedOn r
-- Mathlib/Order/Filter/Lift.lean
theorem lift_mono' (hg : ∀ s ∈ f, g₁ s ≤ g₂ s) : f.lift g₁ ≤ f.lift g₂
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem lcm_dvd [GCDMonoid α] {a b c : α} (hab : a ∣ b) (hcb : c ∣ b) : lcm a c ∣ b
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivAt.const_rpow (hf : HasFDerivAt f f' x) (hc : 0 < c) :
    HasFDerivAt (fun x => c ^ f x) ((c ^ f x * Real.log c) • f') x
-- Mathlib/CategoryTheory/Category/Preorder.lean
theorem homOfLE_leOfHom {x y : X} (h : x ⟶ y) : h.le.hom = h
-- Mathlib/Data/DFinsupp/NeLocus.lean
theorem neLocus_comm : f.neLocus g = g.neLocus f
-- Mathlib/Topology/DenseEmbedding.lean
theorem comap_nhds_neBot (di : DenseInducing i) (b : β) : NeBot (comap i (𝓝 b))
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive]
theorem codisjoint_range_inl_range_inr :
    Codisjoint (MonoidHom.range (inl : G →* G ∗ H)) (MonoidHom.range inr)
-- Mathlib/ModelTheory/Satisfiability.lean
theorem sup_semanticallyEquivalent_not_inf_not :
    T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp] theorem rTensor_symm_tmul : (f.rTensor M).symm (p ⊗ₜ m) = f.symm p ⊗ₜ m
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
lemma self_zpow₀ (a : G₀) (n : ℤ) : Commute a (a ^ n)
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem isLocalization_of_eq_basicOpen {V : X.Opens} (i : V ⟶ U) (e : V = X.basicOpen f) :
    @IsLocalization.Away _ _ f Γ(X, V) _ (X.presheaf.map i.op).toAlgebra
-- Mathlib/LinearAlgebra/Dimension/Free.lean
/-- The rank of a free module `M` over an infinite scalar ring `R` is the cardinality of `M`
whenever `#R < #M`. -/
lemma rank_eq_mk_of_infinite_lt [Infinite R] (h_lt : lift.{v} #R < lift.{u} #M) :
    Module.rank R M = #M
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem neg_def (xs : IntList) : - xs = xs.map fun x => -x
-- Mathlib/Probability/Kernel/Basic.lean
@[simp] lemma nsmul_apply (n : ℕ) (κ : Kernel α β) (a : α) : (n • κ) a = n • κ a
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_eq_self_iff_disjoint' : x \ y = x ↔ Disjoint x y
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.ae_eq {f g : α → E} (hfg : f =ᵐ[μ] g) (hf_Lp : Memℒp f p μ) : Memℒp g p μ
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem neg_get (xs : IntList) (i : Nat) : (- xs).get i = - xs.get i
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
theorem AnalyticAt.differentiableWithinAt (h : AnalyticAt 𝕜 f x) : DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem IsCompact.exists_isMinOn_mem_subset [ClosedIicTopology α] {f : β → α} {s t : Set β}
    {z : β} (ht : IsCompact t) (hf : ContinuousOn f t) (hz : z ∈ t)
    (hfz : ∀ z' ∈ t \ s, f z < f z') : ∃ x ∈ s, IsMinOn f t x
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_toEquiv (e : P₁ ≃ᵃ[k] P₂) : ⇑e.toEquiv = e
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem toPlus_mk {X : C} {P : Cᵒᵖ ⥤ D} (S : J.Cover X) (x : P.obj (op X)) :
    (J.toPlus P).app _ x = mk (Meq.mk S x)
-- Mathlib/Order/Cover.lean
/-- An `iff` version of `WCovBy.eq_or_eq` and `wcovBy_of_eq_or_eq`. -/
theorem wcovBy_iff_le_and_eq_or_eq : a ⩿ b ↔ a ≤ b ∧ ∀ c, a ≤ c → c ≤ b → c = a ∨ c = b
-- Mathlib/AlgebraicGeometry/Noetherian.lean
lemma noetherianSpace_of_isAffine [IsAffine X] [IsNoetherianRing Γ(X, ⊤)] :
    NoetherianSpace X
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem none_eq_top : (none : ℝ≥0∞) = ∞
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem continuous_CC'₁ : Continuous (CC'₁ C hsC ho)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem map_update_sum {α : Type*} [DecidableEq ι] (t : Finset α) (i : ι) (g : α → M) (m : ι → M) :
    f (update m i (∑ a ∈ t, g a)) = ∑ a ∈ t, f (update m i (g a))
-- Mathlib/Probability/Kernel/Composition.lean
lemma fst_map_id_prod (κ : Kernel α β) {γ : Type*} {mγ : MeasurableSpace γ}
    {f : β → γ} (hf : Measurable f) :
    fst (map κ (fun a ↦ (a, f a)) (measurable_id.prod_mk hf)) = κ
-- Mathlib/Analysis/Calculus/LogDeriv.lean
@[simp]
lemma logDeriv_zpow (x : 𝕜) (n : ℤ) : logDeriv (· ^ n) x = n / x
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem cos_three_mul : cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem sSup_eq_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    sSup (brange o f) = bsup.{_, v} o f
-- Mathlib/Algebra/Ring/Int.lean
lemma units_eq_one_or (u : ℤˣ) : u = 1 ∨ u = -1
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
protected theorem isFractional (I : FractionalIdeal S P) : IsFractional S (I : Submodule R P)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- If a filter is converging, its limsup coincides with its limit. -/
theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.limsInf = a
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
@[simp]
theorem whisker_extension (t : LeftExtension f g) {x : B} (h : c ⟶ x) :
    (t.whisker h).extension = t.extension ≫ h
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
theorem trailingDegree_C (ha : a ≠ 0) : trailingDegree (C a) = (0 : ℕ∞)
-- Mathlib/Data/Multiset/Basic.lean
@[symm]
theorem Disjoint.symm {s t : Multiset α} (d : Disjoint s t) : Disjoint t s
-- Mathlib/Topology/Bornology/Hom.lean
@[simp]
theorem coe_id : ⇑(LocallyBoundedMap.id α) = id
-- Mathlib/Data/PNat/Factors.lean
theorem factorMultiset_pow (n : ℕ+) (m : ℕ) :
    factorMultiset (n ^ m) = m • factorMultiset n
-- Mathlib/Order/Bounds/Basic.lean
/-- If `s` is bounded, then so is `s ∩ t` -/
theorem BddAbove.inter_of_left (h : BddAbove s) : BddAbove (s ∩ t)
-- Mathlib/Algebra/Polynomial/Taylor.lean
/-- `Polynomial.taylor` as an `AlgHom` for commutative semirings -/
@[simps!]
def taylorAlgHom {R} [CommSemiring R] (r : R) : R[X] →ₐ[R] R[X]
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem mul_inl_eq_op_smul [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M]
    (x : tsze R M) (r : R) :
    x * inl r = x <• r
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Uniform converence implies pointwise convergence. -/
theorem TendstoUniformlyOn.tendsto_at (h : TendstoUniformlyOn F f p s) {x : α} (hx : x ∈ s) :
    Tendsto (fun n => F n x) p <| 𝓝 (f x)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
protected theorem div_le_of_le_mul {m n : Nat} : ∀ {k}, m ≤ k * n → m / k ≤ n
-- Mathlib/Logic/Function/Conjugate.lean
theorem isAssociative_left [Std.Associative gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
    Std.Associative ga
-- Mathlib/Topology/Order/LeftRightNhds.lean
/-- A set is a neighborhood of `a` within `(-∞, a)` if and only if it contains an interval `(l, a)`
with `l < a`. -/
theorem mem_nhdsWithin_Iio_iff_exists_Ioo_subset [NoMinOrder α] {a : α} {s : Set α} :
    s ∈ 𝓝[<] a ↔ ∃ l ∈ Iio a, Ioo l a ⊆ s
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma smul_fin3 {R : Type u} [CommRing R] (P : Fin 3 → R) (u : Rˣ) :
    u • P = ![u * P x, u * P y, u * P z]
-- Mathlib/RingTheory/Polynomial/Quotient.lean
@[simp]
theorem polynomialQuotientEquivQuotientPolynomial_map_mk (I : Ideal R) (f : R[X]) :
    I.polynomialQuotientEquivQuotientPolynomial (f.map <| Quotient.mk I) =
    Quotient.mk (map C I : Ideal R[X]) f
-- Mathlib/LinearAlgebra/Ray.lean
/-- Negating a nonzero vector commutes with coercion to the underlying module. -/
@[simp, norm_cast]
theorem coe_neg {R : Type*} (v : RayVector R M) : ↑(-v) = -(v : M)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean
theorem charmatrix_apply :
    charmatrix M i j = (Matrix.diagonal fun _ : n => X) i j - C (M i j)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
protected lemma IsOfFinOrder.mem_powers_iff_mem_range_orderOf [DecidableEq G]
    (hx : IsOfFinOrder x) :
    y ∈ Submonoid.powers x ↔ y ∈ (Finset.range (orderOf x)).image (x ^ ·)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem integral_cexp_neg_sum_mul_add {ι : Type*} [Fintype ι] {b : ι → ℂ}
    (hb : ∀ i, 0 < (b i).re) (c : ι → ℂ) :
    ∫ v : ι → ℝ, cexp (- ∑ i, b i * (v i : ℂ) ^ 2 + ∑ i, c i * v i)
      = ∏ i, (π / b i) ^ (1 / 2 : ℂ) * cexp (c i ^ 2 / (4 * b i))
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem mem_uniformity_of_uniformContinuous_invariant [UniformSpace α] [UniformSpace β]
    {s : Set (β × β)} {f : α → α → β} (hf : UniformContinuous fun p : α × α => f p.1 p.2)
    (hs : s ∈ 𝓤 β) : ∃ u ∈ 𝓤 α, ∀ a b c, (a, b) ∈ u → (f a c, f b c) ∈ s
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp]
theorem const_one : const 1 = 1
-- .lake/packages/lean4/src/lean/Init/WF.lean
class WellFoundedRelation (α : Sort u) where
  rel : α → α → Prop
  wf  : WellFounded rel
-- Mathlib/Analysis/Normed/Group/Basic.lean
/-- **Triangle inequality** for the norm. -/
@[to_additive norm_add_le "**Triangle inequality** for the norm."]
theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
@[simp]
theorem mapL_id : mapL (fun i ↦ ContinuousLinearMap.id 𝕜 (E i)) = ContinuousLinearMap.id _ _
-- Mathlib/Algebra/Associated/Basic.lean
theorem mk_surjective [Monoid α] : Function.Surjective (@Associates.mk α _)
-- Mathlib/Data/Set/Lattice.lean
theorem sSup_sUnion (s : Set (Set β)) : sSup (⋃₀ s) = ⨆ t ∈ s, sSup t
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem boundedBy_eq_ofFunction (m_empty : m ∅ = 0) (s : Set α) :
    boundedBy m s = OuterMeasure.ofFunction m m_empty s
-- Mathlib/CategoryTheory/Generator.lean
/-- An ingredient of the proof of the Special Adjoint Functor Theorem: a complete well-powered
    category with a small coseparating set has an initial object.

    In fact, it follows from the Special Adjoint Functor Theorem that `C` is already cocomplete,
    see `hasColimits_of_hasLimits_of_isCoseparating`. -/
theorem hasInitial_of_isCoseparating [WellPowered C] [HasLimits C] {𝒢 : Set C} [Small.{v₁} 𝒢]
    (h𝒢 : IsCoseparating 𝒢) : HasInitial C
-- Mathlib/Data/Finset/Basic.lean
lemma erase_sdiff_erase (hab : a ≠ b) (hb : b ∈ s) : s.erase a \ s.erase b = {b}
-- Mathlib/Data/Real/Sqrt.lean
@[simp]
theorem sqrt_inv (x : ℝ) : √x⁻¹ = (√x)⁻¹
-- Mathlib/Order/Filter/NAry.lean
protected theorem NeBot.map₂ (hf : f.NeBot) (hg : g.NeBot) : (map₂ m f g).NeBot
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_natCast (n : ℕ) : round (n : α) = n
-- Mathlib/Order/ULift.lean
@[simp] theorem down_compare [Ord α] (a b : ULift α) :
  compare (down a) (down b) = compare a b
-- Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean
/-- The coefficient of a monomial in a product `f * g` that can be reached in at most one way
as a product of monomials in the supports of `f` and `g` is a product. -/
theorem mul_apply_mul_eq_mul_of_uniqueMul [Mul A] {f g : MonoidAlgebra R A} {a0 b0 : A}
    (h : UniqueMul f.support g.support a0 b0) :
    (f * g) (a0 * b0) = f a0 * g b0
-- Mathlib/Order/Defs.lean
theorem lt_or_le (a b : α) : a < b ∨ b ≤ a
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_two_mul (a : α) : Even (2 * a)