ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/ULift.lean
@[simp] theorem up_inf [Inf α] (a b : α) : up (a ⊓ b) = up a ⊓ up b
-- Mathlib/GroupTheory/GroupAction/Period.lean
/-- If for some `n`, `m ^ n • a = a`, then `0 < period m a`. -/
@[to_additive "If for some `n`, `(n • m) +ᵥ a = a`, then `0 < period m a`."]
theorem period_pos_of_fixed {m : M} {a : α} {n : ℕ} (n_pos : 0 < n) (fixed : m ^ n • a = a) :
    0 < period m a
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
lemma δ_comp_zero_cochain {n₁ : ℤ} (z₁ : Cochain F G n₁) (z₂ : Cochain G K 0)
    (m₁ : ℤ) (h₁ : n₁ + 1 = m₁) :
    δ n₁ m₁ (z₁.comp z₂ (add_zero n₁)) =
      z₁.comp (δ 0 1 z₂) h₁ + (δ n₁ m₁ z₁).comp z₂ (add_zero m₁)
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[simp] lemma norm_ofDual (x : Eᵒᵈ) : ‖ofDual x‖ = ‖x‖
-- Mathlib/Order/SupIndep.lean
/-- If the elements of a set are independent, then any pair within that set is disjoint. -/
theorem SetIndependent.pairwiseDisjoint : s.PairwiseDisjoint id
-- Mathlib/Order/BooleanAlgebra.lean
theorem inf_sdiff_right_comm : x \ z ⊓ y = (x ⊓ y) \ z
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_add_toIocMod_zero (a b : α) :
    toIcoMod hp 0 (a - b) + toIocMod hp 0 (b - a) = p
-- Mathlib/Order/Fin/Tuple.lean
lemma StrictMono.vecCons (hf : StrictMono f) (ha : a < f 0) : StrictMono (vecCons a f)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_nonempty_self (s : Set α) : ⋃ _ : s.Nonempty, s = s
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Bool.of_not_eq_false : {b : Bool} → ¬ (b = false) → b = true
-- Mathlib/Logic/Function/ULift.lean
@[simp] theorem ULift.down_inj {α : Sort _} {a b : ULift α} : a.down = b.down ↔ a = b
-- Mathlib/CategoryTheory/Sites/IsSheafOneHypercover.lean
lemma fac {Y : C} (f : Y ⟶ X) (hf : S f) :
    lift hP hE le F ≫ P.map f.op = F.ι ⟨Y, f, hf⟩
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem MeasureTheory.measure_lt_one_eq_integral_div_gamma {p : ℝ} (hp : 0 < p) :
    μ {x : E | g x < 1} =
      .ofReal ((∫ (x : E), Real.exp (- (g x) ^ p) ∂μ) / Real.Gamma (finrank ℝ E / p + 1))
-- Mathlib/Combinatorics/SimpleGraph/Prod.lean
/-- The embedding of `G` into `G □ H` given by `b`. -/
@[simps]
def boxProdLeft (b : β) : G ↪g G □ H
-- Mathlib/Order/Filter/Basic.lean
theorem map_injective {m : α → β} (hm : Injective m) : Injective (map m)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
/-- If a function vanishes almost everywhere on `sᶜ`, then its integral on `s`
coincides with its integral on the whole space. -/
theorem setIntegral_eq_integral_of_ae_compl_eq_zero (h : ∀ᵐ x ∂μ, x ∉ s → f x = 0) :
    ∫ x in s, f x ∂μ = ∫ x, f x ∂μ
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem one_minus_pos (x : Ioo (0 : β) 1) : 0 < 1 - (x : β)
-- Mathlib/Data/Sym/Basic.lean
@[ext] theorem ext {s₁ s₂ : Sym α n} (h : (s₁ : Multiset α) = ↑s₂) : s₁ = s₂
-- Mathlib/Data/Nat/Choose/Basic.lean
@[simp]
theorem choose_symm {n k : ℕ} (hk : k ≤ n) : choose n (n - k) = choose n k
-- Mathlib/Data/Seq/Computation.lean
theorem LiftRel.symm (R : α → α → Prop) (H : Symmetric R) : Symmetric (LiftRel R)
-- Mathlib/Data/List/Prime.lean
/-- Prime `p` divides the product of a list `L` iff it divides some `a ∈ L` -/
theorem Prime.dvd_prod_iff {p : M} {L : List M} (pp : Prime p) : p ∣ L.prod ↔ ∃ a ∈ L, p ∣ a
-- Mathlib/CategoryTheory/Galois/Decomposition.lean
/-- In a Galois category, every object is the sum of connected objects. -/
theorem has_decomp_connected_components' (X : C) :
    ∃ (ι : Type) (_ : Finite ι) (f : ι → C) (_ : ∐ f ≅ X), ∀ i, IsConnected (f i)
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_univ (u : α → Set β) : ⋂ x ∈ @univ α, u x = ⋂ x, u x
-- Mathlib/Topology/EMetricSpace/Basic.lean
@[simp]
theorem edist_pos {x y : γ} : 0 < edist x y ↔ x ≠ y
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
/-- `WithLp.equiv` as a linear equivalence. -/
@[simps (config := .asFn)]
protected def linearEquiv : WithLp p V ≃ₗ[K] V
-- Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
/-- If the vector passed to `secondInter` is given by a subtraction involving the point in
`secondInter`, the result lies in the span of the two points. -/
theorem Sphere.secondInter_vsub_mem_affineSpan (s : Sphere P) (p₁ p₂ : P) :
    s.secondInter p₁ (p₂ -ᵥ p₁) ∈ line[ℝ, p₁, p₂]
-- Mathlib/GroupTheory/NoncommCoprod.lean
/-- Coproduct of two `MulHom`s with the same codomain with `Commute` assumption:
  `f.noncommCoprod g _ (p : M × N) = f p.1 * g p.2`.
  (For the commutative case, use `MulHom.coprod`) -/
@[to_additive (attr := simps)
    "Coproduct of two `AddHom`s with the same codomain with `AddCommute` assumption:
    `f.noncommCoprod g _ (p : M × N) = f p.1 + g p.2`.
    (For the commutative case, use `AddHom.coprod`)"]
def noncommCoprod (comm : ∀ m n, Commute (f m) (g n)) : M × N →ₙ* P
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toNatOrdinal_max (a b : Ordinal) :
    toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b)
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.exists_insert_of_not_base (hI : M.Indep I) (hI' : ¬M.Base I) (hB : M.Base B) :
    ∃ e ∈ B \ I, M.Indep (insert e I)
-- Mathlib/Order/BoundedOrder.lean
theorem min_bot_left [OrderBot α] (a : α) : min ⊥ a = ⊥
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma setLIntegral_rnDeriv' [HaveLebesgueDecomposition μ ν] (hμν : μ ≪ ν) {s : Set α}
    (hs : MeasurableSet s) :
    ∫⁻ x in s, μ.rnDeriv ν x ∂ν = μ s
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem comap_injective {f : A →⋆ₐ[R] B} (hf : Function.Surjective f) :
    Function.Injective (comap f)
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem one_apply [∀ i, One <| f i] : (1 : ∀ i, f i) i = 1
-- Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean
/-- The maps `hσ' q n m hnm` are natural on the simplicial object -/
theorem hσ'_naturality (q : ℕ) (n m : ℕ) (hnm : c.Rel m n) {X Y : SimplicialObject C} (f : X ⟶ Y) :
    f.app (op [n]) ≫ hσ' q n m hnm = hσ' q n m hnm ≫ f.app (op [m])
-- Mathlib/Geometry/RingedSpace/Stalks.lean
@[elementwise, reassoc]
theorem stalkMap_germ {X Y : PresheafedSpace.{_, _, v} C} (α : X ⟶ Y) (U : Opens Y)
    (x : (Opens.map α.base).obj U) :
    Y.presheaf.germ ⟨α.base x.1, x.2⟩ ≫ α.stalkMap ↑x = α.c.app (op U) ≫ X.presheaf.germ x
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_comap_le (H : Subgroup N) : map f (comap f H) ≤ H
-- Mathlib/Data/Sym/Basic.lean
theorem replicate_right_inj {a b : α} {n : ℕ} (h : n ≠ 0) : replicate n a = replicate n b ↔ a = b
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toOrdinal_one : toOrdinal 1 = 1
-- Mathlib/Topology/UniformSpace/Equiv.lean
/-- Uniform isomorphism between `α` and `β` -/
--@[nolint has_nonempty_instance] -- Porting note(#5171): linter not yet ported
structure UniformEquiv (α : Type*) (β : Type*) [UniformSpace α] [UniformSpace β] extends
  α ≃ β where
  /-- Uniform continuity of the function -/
  uniformContinuous_toFun : UniformContinuous toFun
  /-- Uniform continuity of the inverse -/
  uniformContinuous_invFun : UniformContinuous invFun
-- Mathlib/Order/Filter/Basic.lean
lemma _root_.Finset.eventuallyEq_iUnion {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i)
-- Mathlib/Analysis/Convex/Side.lean
theorem wOppSide_pointReflection {s : AffineSubspace R P} {x : P} (y : P) (hx : x ∈ s) :
    s.WOppSide y (pointReflection R x y)
-- Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean
/-- **Ruzsa's triangle inequality**. Mul-div-div version. -/
@[to_additive "**Ruzsa's triangle inequality**. Add-sub-sub version."]
theorem ruzsa_triangle_inequality_mul_div_div (A B C : Finset α) :
    (A * C).card * B.card ≤ (A / B).card * (B / C).card
-- Mathlib/Topology/Basic.lean
theorem all_mem_nhds (x : X) (P : Set X → Prop) (hP : ∀ s t, s ⊆ t → P s → P t) :
    (∀ s ∈ 𝓝 x, P s) ↔ ∀ s, IsOpen s → x ∈ s → P s
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem of_symm_smul_of_eq_mul [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    (HahnModule.of R).symm (x • HahnModule.of R y) = x * y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem forall_iff {p : Fin n → Prop} : (∀ i, p i) ↔ ∀ i h, p ⟨i, h⟩
-- Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
theorem adjointDomainMkCLM_apply (y : T.adjointDomain) (x : T.domain) :
    adjointDomainMkCLM T y x = ⟪(y : F), T x⟫
-- Mathlib/RingTheory/Valuation/Integers.lean
/--
This is the special case of `Valuation.Integers.isUnit_of_one` when the valuation is defined
over a field. Let `v` be a valuation on some field `F` and `O` be its integers. For every element
`x` in `O`, `x` is a unit in `O` if and only if the image of `x` in `F` has valuation 1.
-/
theorem isUnit_of_one' (hv : Integers v O) {x : O} (hvx : v (algebraMap O F x) = 1) : IsUnit x
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem hasIntegral_const (c : E) : HasIntegral I l (fun _ => c) vol (vol I c)
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) : a < a * b
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 }
-- Mathlib/Topology/Specialization.lean
@[simp] lemma ofEquiv_toEquiv (a : α) : ofEquiv (toEquiv a) = a
-- Mathlib/LinearAlgebra/Eigenspace/Zero.lean
lemma charpoly_constantCoeff_eq_zero_iff (φ : Module.End K M) :
    constantCoeff φ.charpoly = 0 ↔ ∃ (m : M), m ≠ 0 ∧ φ m = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_iff_get? {a} {l : List α} : a ∈ l ↔ ∃ n, l.get? n = some a
-- Mathlib/Data/ENNReal/Basic.lean
@[simp]
theorem ofReal_toReal_eq_iff : ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤
-- Mathlib/RingTheory/WittVector/Identities.lean
theorem p_nonzero [Nontrivial R] [CharP R p] : (p : 𝕎 R) ≠ 0
-- Mathlib/Tactic/NormNum/GCD.lean
theorem isInt_gcd : {x y nx ny : ℤ} → {z : ℕ} →
    IsInt x nx → IsInt y ny → Int.gcd nx ny = z → IsNat (Int.gcd x y) z
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem comap_mono (h : K ≤ L) : comap f K ≤ comap f L
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
protected theorem IsHermitian.isSelfAdjoint {A : Matrix n n α} (h : A.IsHermitian) :
    IsSelfAdjoint A
-- Mathlib/CategoryTheory/SingleObj.lean
theorem comp_as_mul {x y z : SingleObj M} (f : x ⟶ y) (g : y ⟶ z) : f ≫ g = g * f
-- Mathlib/Data/List/FinRange.lean
theorem ofFn_id (n) : ofFn id = finRange n
-- Mathlib/Combinatorics/SimpleGraph/Prod.lean
theorem boxProd_adj_right {a : α} {b₁ b₂ : β} : (G □ H).Adj (a, b₁) (a, b₂) ↔ H.Adj b₁ b₂
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem sup_apply (f g : SupHom α β) (a : α) : (f ⊔ g) a = f a ⊔ g a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- Coercion from `G' : Subgraph G` to a `SimpleGraph G'.verts`. -/
@[simps]
protected def coe (G' : Subgraph G) : SimpleGraph G'.verts
-- Mathlib/CategoryTheory/Monoidal/Transport.lean
/-- The unit isomorphism upgrades to a monoidal isomorphism. -/
@[simps! hom inv]
def transportedMonoidalUnitIso (e : C ≌ D) :
    LaxMonoidalFunctor.id C ≅
      (toTransported e).toLaxMonoidalFunctor ⊗⋙ (fromTransported e).toLaxMonoidalFunctor
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
theorem of_terminatedAt_n_iff_succ_nth_intFractPair_stream_eq_none :
    (of v).TerminatedAt n ↔ IntFractPair.stream v (n + 1) = none
-- Mathlib/Data/Set/Accumulate.lean
theorem monotone_accumulate [Preorder α] : Monotone (Accumulate s)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp, norm_cast] lemma coe_neg [∀ i, AddGroup (β i)] (g : Π₀ i, β i) : ⇑(-g) = -g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_antiperiodic : Function.Antiperiodic sin π
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem strictMonoOn_sin : StrictMonoOn sin (Icc (-(π / 2)) (π / 2))
-- Mathlib/CategoryTheory/Pi/Basic.lean
@[simp]
theorem eqToHom_proj {x x' : ∀ i, C i} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i)
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem integral_exp : ∫ x in a..b, exp x = exp b - exp a
-- Mathlib/Order/Height.lean
@[simp]
theorem singleton_mem_subchain_iff : [a] ∈ s.subchain ↔ a ∈ s
-- Mathlib/Order/Circular.lean
theorem btw_rfl_right {a b : α} : btw a b b
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem Ioo_ae_eq_Ioc' (hb : μ {b} = 0) : Ioo a b =ᵐ[μ] Ioc a b
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem ωSup_eq_none {c : Chain (Part α)} (h : ¬∃ a, some a ∈ c) : Part.ωSup c = none
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive MeasureTheory.addFundamentalInterior_subset]
theorem fundamentalInterior_subset : fundamentalInterior G s ⊆ s
-- Mathlib/Order/Chain.lean
theorem ChainClosure.total (hc₁ : ChainClosure r c₁) (hc₂ : ChainClosure r c₂) :
    c₁ ⊆ c₂ ∨ c₂ ⊆ c₁
-- Mathlib/Data/List/NodupEquivFin.lean
/-- An element `x : α` of `l : List α` is a duplicate iff it can be found
at two distinct indices `n m : ℕ` inside the list `l`.
-/
@[deprecated duplicate_iff_exists_distinct_get (since := "2023-01-19")]
theorem duplicate_iff_exists_distinct_nthLe {l : List α} {x : α} :
    l.Duplicate x ↔
      ∃ (n : ℕ) (hn : n < l.length) (m : ℕ) (hm : m < l.length) (_ : n < m),
        x = l.nthLe n hn ∧ x = l.nthLe m hm
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
theorem lintegral_rnDeriv_mul [HaveLebesgueDecomposition μ ν] (hμν : μ ≪ ν) {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) : ∫⁻ x, μ.rnDeriv ν x * f x ∂ν = ∫⁻ x, f x ∂μ
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive coe_prod]
theorem coe_prod (H : Subgroup G) (K : Subgroup N) :
    (H.prod K : Set (G × N)) = (H : Set G) ×ˢ (K : Set N)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffWithinAt.prod_map (hf : ContMDiffWithinAt I I' n f s x)
    (hg : ContMDiffWithinAt J J' n g r y) :
    ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) (x, y)
-- Mathlib/Data/Matrix/DMatrix.lean
theorem map_add [∀ i j, AddMonoid (α i j)] {β : m → n → Type w} [∀ i j, AddMonoid (β i j)]
    (f : ∀ ⦃i j⦄, α i j →+ β i j) (M N : DMatrix m n α) :
    ((M + N).map fun i j => @f i j) = (M.map fun i j => @f i j) + N.map fun i j => @f i j
-- Mathlib/Algebra/Order/CompleteField.lean
/-- Preparatory lemma for `inducedOrderRingHom`. -/
theorem exists_mem_cutMap_mul_self_of_lt_inducedMap_mul_self (ha : 0 < a) (b : β)
    (hba : b < inducedMap α β a * inducedMap α β a) : ∃ c ∈ cutMap β (a * a), b < c
-- Mathlib/Algebra/Category/Grp/Biproducts.lean
/-- We verify that the biproduct in `AddCommGrp` is isomorphic to
the cartesian product of the underlying types:
-/
@[simps! hom_apply]
noncomputable def biprodIsoProd (G H : AddCommGrp.{u}) :
    (G ⊞ H : AddCommGrp) ≅ AddCommGrp.of (G × H)
-- Mathlib/Data/Rat/Cast/Order.lean
/-- Coercion from `ℚ` as an order embedding. -/
@[simps!]
def castOrderEmbedding : ℚ≥0 ↪o K
-- Mathlib/Algebra/Tropical/Basic.lean
theorem add_self (x : Tropical R) : x + x = x
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem nonuniformWitness_spec (h₁ : s ≠ t) (h₂ : ¬G.IsUniform ε s t) : ε ≤ |G.edgeDensity
    (G.nonuniformWitness ε s t) (G.nonuniformWitness ε t s) - G.edgeDensity s t|
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extend_nhdsWithin_eq_image {y : M} (hy : y ∈ f.source) :
    map (f.extend I) (𝓝[s] y) = 𝓝[f.extend I '' ((f.extend I).source ∩ s)] f.extend I y
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
theorem integral_exp_Iic (c : ℝ) : ∫ x : ℝ in Iic c, exp x = exp c
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
theorem summable_of_isBigO' {ι E F : Type*} [NormedAddCommGroup E] [CompleteSpace E]
    [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] {f : ι → E} {g : ι → F}
    (hg : Summable g) (h : f =O[cofinite] g) : Summable f
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_inf_le (f : F) {p q : Submodule R M} :
    (p ⊓ q).map f ≤ p.map f ⊓ q.map f
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem coe_modNat (i : Fin (m * n)) : (i.modNat : ℕ) = i % n
-- Mathlib/Analysis/Complex/Circle.lean
@[simp]
theorem expMapCircle_sub (x y : ℝ) : expMapCircle (x - y) = expMapCircle x / expMapCircle y
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp] theorem toCoalgebraCatIso_trans (e : X ≃ₗc[R] Y) (f : Y ≃ₗc[R] Z) :
    toCoalgebraCatIso (e.trans f) = toCoalgebraCatIso e ≪≫ toCoalgebraCatIso f
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem pNilradical_eq_bot_of_frobenius_inj (R : Type*) [CommRing R] (p : ℕ) [ExpChar R p]
    (h : Function.Injective (frobenius R p)) : pNilradical R p = ⊥
-- Mathlib/Data/Finset/Basic.lean
theorem Nonempty.to_type {s : Finset α} : s.Nonempty → Nonempty α
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_mul_right {L : Type*} [RCLike L] (r : L) (f : α → L) :
    ∫ a, f a * r ∂μ = (∫ a, f a ∂μ) * r
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.congr (h : f₁ =O[l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =O[l] g₂
-- Mathlib/Algebra/Order/Floor.lean
private theorem int_ceil_pos [LinearOrderedRing α] [FloorRing α] {a : α} : 0 < a → 0 < ⌈a⌉
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma stieltjesOfMeasurableRat_unit_prod (hf : Measurable f) (a : α) :
    stieltjesOfMeasurableRat (fun (p : Unit × α) ↦ f p.2) (hf.comp measurable_snd) ((), a)
      = stieltjesOfMeasurableRat f hf a
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- Hilbert basis theorem: a polynomial ring over a noetherian ring is a noetherian ring. -/
protected theorem Polynomial.isNoetherianRing [inst : IsNoetherianRing R] : IsNoetherianRing R[X]
-- Mathlib/Algebra/Algebra/Hom.lean
/-- Defining the homomorphism in the category R-Alg. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): linter not ported yet
structure AlgHom (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends RingHom A B where
  commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
-- Mathlib/Topology/Instances/ENNReal.lean
/-- A series of non-negative real numbers converges to `r` in the sense of `HasSum` if and only if
the sequence of partial sum converges to `r`. -/
theorem hasSum_iff_tendsto_nat {f : ℕ → ℝ≥0} {r : ℝ≥0} :
    HasSum f r ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
-- Mathlib/Topology/UniformSpace/Separation.lean
theorem Filter.HasBasis.inseparable_iff_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)}
    (h : (𝓤 α).HasBasis p s) {x y : α} : Inseparable x y ↔ ∀ i, p i → (x, y) ∈ s i
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
@[simp]
theorem PInfty_f_0 : (PInfty.f 0 : X _[0] ⟶ X _[0]) = 𝟙 _
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
lemma map'_map'  (f : α →* β) (g : β →* γ) (x) : map' g (map' f x) = map' (g.comp f) x
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ext_of_generateFrom_of_cover {S T : Set (Set α)} (h_gen : ‹_› = generateFrom S)
    (hc : T.Countable) (h_inter : IsPiSystem S) (hU : ⋃₀ T = univ) (htop : ∀ t ∈ T, μ t ≠ ∞)
    (ST_eq : ∀ t ∈ T, ∀ s ∈ S, μ (s ∩ t) = ν (s ∩ t)) (T_eq : ∀ t ∈ T, μ t = ν t) : μ = ν
-- Mathlib/CategoryTheory/GradedObject/Trifunctor.lean
/-- The natural isomorphism `mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃`
induced by a natural isomorphism `F ≅ F` of trifunctors. -/
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem map_inl (n : N) : map f₁ f₂ h (inl n) = inl (f₁ n)
-- Mathlib/Control/Traversable/Lemmas.lean
theorem map_traverse' (g : α → G β) (h : β → γ) :
    traverse (map h ∘ g) = (map (map h) ∘ traverse g : t α → G (t γ))
-- Mathlib/Data/Real/ConjExponents.lean
protected lemma inv_inv (ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b = 1) :
    a⁻¹.IsConjExponent b⁻¹
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem finSuccEquiv_comp_C_eq_C {R : Type u} [CommSemiring R] (n : ℕ) :
    (↑(MvPolynomial.finSuccEquiv R n).symm : Polynomial (MvPolynomial (Fin n) R) →+* _).comp
        (Polynomial.C.comp MvPolynomial.C) =
      (MvPolynomial.C : R →+* MvPolynomial (Fin n.succ) R)
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
lemma Λ_eq : P.Λ = mellin P.f
-- Mathlib/Topology/Gluing.lean
theorem rel_equiv : Equivalence D.Rel
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem apply_symm_apply (e : α ≃ᵐ β) (y : β) : e (e.symm y) = y
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem involute_involute : ∀ a : CliffordAlgebra Q, involute (involute a) = a
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp] theorem toCoalgHom_comp {M N U : CoalgebraCat.{v} R} (f : M ⟶ N) (g : N ⟶ U) :
    (f ≫ g).toCoalgHom = g.toCoalgHom.comp f.toCoalgHom
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
@[simp]
theorem attachBound_apply_coe (f : C(X, ℝ)) (x : X) : ((attachBound f) x : ℝ) = f x
-- Mathlib/Data/DFinsupp/Basic.lean
theorem filter_single (p : ι → Prop) [DecidablePred p] (i : ι) (x : β i) :
    (single i x).filter p = if p i then single i x else 0
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem modEq_of_xn_modEq {i j n} (ipos : 0 < i) (hin : i ≤ n)
    (h : xn a1 j ≡ xn a1 i [MOD xn a1 n]) :
    j ≡ i [MOD 4 * n] ∨ j + i ≡ 0 [MOD 4 * n]
-- Mathlib/Order/Sublattice.lean
lemma comap_equiv_eq_map_symm (f : β ≃o α) (L : Sublattice α) :
    L.comap f = L.map (f.symm : LatticeHom α β)
-- Mathlib/NumberTheory/Divisors.lean
theorem fst_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
    x.fst ∈ divisors n
-- Mathlib/Tactic/FunProp/ContDiff.lean
theorem contDiffOn_pi' (hΦ : ∀ i, ContDiffOn K n (fun x => Φ x i) s) : ContDiffOn K n Φ s
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousMultilinearMap.curry0_norm (x : G') :
    ‖ContinuousMultilinearMap.curry0 𝕜 G x‖ = ‖x‖
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive]
lemma IsMulFreimanHom.prod (h₁ : IsMulFreimanHom n A₁ B₁ f₁) (h₂ : IsMulFreimanHom n A₂ B₂ f₂) :
    IsMulFreimanHom n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂)
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
/-- The object in the category of `R`-coalgebras associated to an `R`-coalgebra. -/
@[simps]
def of (X : Type v) [AddCommGroup X] [Module R X] [Coalgebra R X] :
    CoalgebraCat R
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem specializes_closedPoint (x : PrimeSpectrum R) : x ⤳ closedPoint R
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsGLB.exists_seq_strictAnti_tendsto_of_not_mem {t : Set α} {x : α}
    [IsCountablyGenerated (𝓝 x)] (htx : IsGLB t x) (not_mem : x ∉ t) (ht : t.Nonempty) :
    ∃ u : ℕ → α, StrictAnti u ∧ (∀ n, x < u n) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ n, u n ∈ t
-- Mathlib/Data/Set/Pointwise/BigOperators.lean
@[to_additive]
theorem multiset_prod_singleton {M : Type*} [CommMonoid M] (s : Multiset M) :
    (s.map fun i ↦ ({i} : Set M)).prod = {s.prod}
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem LindelofSpace.elim_nhds_subcover [LindelofSpace X] (U : X → Set X) (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, U x = univ
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem pre_le (hs : diam s ≤ r) : pre m r s ≤ m s
-- Mathlib/Topology/Maps/Basic.lean
theorem of_comp (f : X → Y) (hg : OpenEmbedding g)
    (h : OpenEmbedding (g ∘ f)) : OpenEmbedding f
-- Mathlib/Algebra/GroupWithZero/Defs.lean
/-- If `α` has no zero divisors, then the product of two elements is nonzero iff both of them
are nonzero. -/
theorem mul_ne_zero_iff : a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem singularPart_zero (μ : Measure α) : (0 : SignedMeasure α).singularPart μ = 0
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem iff_isOpen_fiber_apply {f : X → Y} : IsLocallyConstant f ↔ ∀ x, IsOpen (f ⁻¹' {f x})
-- Mathlib/Computability/DFA.lean
@[simp]
theorem evalFrom_singleton (s : σ) (a : α) : M.evalFrom s [a] = M.step s a