ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
theorem quotient_map_comp_mkₐ {I : Ideal A} (J : Ideal B) (f : A →ₐ[R₁] B) (H : I ≤ J.comap f) :
    (quotientMapₐ J f H).comp (Quotient.mkₐ R₁ I) = (Quotient.mkₐ R₁ J).comp f
-- Mathlib/Data/Fin/Basic.lean
theorem pred_lt_castPred_iff {a b : Fin (n + 1)} (ha : a ≠ 0) (hb : b ≠ last n) :
    pred a ha < castPred b hb ↔ a ≤ b
-- Mathlib/Topology/PartitionOfUnity.lean
protected theorem point_finite (x : X) : { i | f i x ≠ 0 }.Finite
-- Mathlib/Data/Int/Defs.lean
protected lemma le_or_lt (a b : ℤ) : a ≤ b ∨ b < a
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem let_body_congr {α : Sort u} {β : α → Sort v} {b b' : (a : α) → β a}
    (a : α) (h : ∀ x, b x = b' x) : (let x := a; b x) = (let x := a; b' x)
-- Mathlib/GroupTheory/GroupAction/Pointwise.lean
theorem image_smul_setₛₗ :
    h '' (c • s) = σ c • h '' s
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem sUnion_diff_singleton_empty (s : Set (Set α)) : ⋃₀(s \ {∅}) = ⋃₀s
-- Mathlib/Data/Matrix/Basic.lean
theorem transpose_list_prod [CommSemiring α] [Fintype m] [DecidableEq m] (l : List (Matrix m m α)) :
    l.prodᵀ = (l.map transpose).reverse.prod
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem norm_sum_neg_one_pow_le (n : ℕ) : ‖∑ i ∈ range n, (-1 : ℝ) ^ i‖ ≤ 1
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem map_bot (f : K →+* L) : (⊥ : Subfield K).map f = ⊥
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
@[to_additive]
theorem hausdorffMeasure_smul {α : Type*} [SMul α X] [IsometricSMul α X] {d : ℝ} (c : α)
    (h : 0 ≤ d ∨ Surjective (c • · : X → X)) (s : Set X) : μH[d] (c • s) = μH[d] s
-- Mathlib/Order/Filter/Cocardinal.lean
theorem mem_cocountable {s : Set α} :
    s ∈ cocountable ↔ (sᶜ : Set α).Countable
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem comp_continuous_iff {α : Type*} [TopologicalSpace α] {g : α → E} :
    Continuous (f ∘ g) ↔ Continuous g
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- Every split mono `f` with a cokernel induces a binary bicone with `f` as its `inl` and
the cokernel map as its `snd`.
We will show in `is_bilimit_binary_bicone_of_split_mono_of_cokernel` that this binary bicone is in
fact already a biproduct. -/
@[simps]
def binaryBiconeOfIsSplitMonoOfCokernel {X Y : C} {f : X ⟶ Y} [IsSplitMono f] {c : CokernelCofork f}
    (i : IsColimit c) : BinaryBicone X c.pt
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
@[simp]
lemma id' (A : CommMon_ C) : (𝟙 A : A.toMon_ ⟶ A.toMon_) = 𝟙 (A.toMon_)
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem BddBelow.finite_of_bddAbove [Preorder α] [LocallyFiniteOrder α]
    {s : Set α} (h₀ : BddBelow s) (h₁ : BddAbove s) :
    s.Finite
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive]
theorem inl_injective : Injective (inl : M →* M ∗ N)
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc (attr := simp)]
theorem whiskerLeft_inv_hom (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h) :
    f ◁ η.inv ≫ f ◁ η.hom = 𝟙 (f ≫ h)
-- Mathlib/Data/PNat/Xgcd.lean
theorem step_isSpecial (hs : u.IsSpecial) : u.step.IsSpecial
-- Mathlib/Data/Real/Archimedean.lean
/--
As `0` is the default value for `Real.sSup` of the empty set or sets which are not bounded above, it
suffices to show that `f i` is nonnegative to show that `0 ≤ ⨆ i, f i`.
-/
protected theorem iSup_nonneg {ι : Sort*} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ ⨆ i, f i
-- Mathlib/Data/Seq/Seq.lean
theorem le_stable (s : Seq α) {m n} (h : m ≤ n) : s.get? m = none → s.get? n = none
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- Nested intervals lemma: if `[f n, g n]` is an antitone sequence of nonempty
closed intervals, then `⨆ n, f n` belongs to all the intervals `[f n, g n]`. -/
theorem ciSup_mem_iInter_Icc_of_antitone_Icc [SemilatticeSup β] {f g : β → α}
    (h : Antitone fun n => Icc (f n) (g n)) (h' : ∀ n, f n ≤ g n) :
    (⨆ n, f n) ∈ ⋂ n, Icc (f n) (g n)
-- Mathlib/Order/Ideal.lean
theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
lemma chromaticNumber_eq_iInf {G : SimpleGraph V} :
    G.chromaticNumber = ⨅ n : {m | G.Colorable m}, (n : ℕ∞)
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem order_single (h : r ≠ 0) : (single a r).order = a
-- Mathlib/Data/Quot.lean
@[elab_as_elim]
protected theorem induction_on₂ {δ : Quot r → Quot s → Prop} (q₁ : Quot r) (q₂ : Quot s)
    (h : ∀ a b, δ (Quot.mk r a) (Quot.mk s b)) : δ q₁ q₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem lt_antisymm' [LT α]
    (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y)
    {l₁ l₂ : List α} (h₁ : ¬l₁ < l₂) (h₂ : ¬l₂ < l₁) : l₁ = l₂
-- Mathlib/Analysis/Calculus/Monotone.lean
/-- A real function which is monotone on a set is differentiable Lebesgue-almost everywhere on
this set. This version assumes that `s` is measurable and uses `volume.restrict s`.
For a formulation without measurability assumption,
see `MonotoneOn.ae_differentiableWithinAt_of_mem`. -/
theorem MonotoneOn.ae_differentiableWithinAt {f : ℝ → ℝ} {s : Set ℝ} (hf : MonotoneOn f s)
    (hs : MeasurableSet s) : ∀ᵐ x ∂volume.restrict s, DifferentiableWithinAt ℝ f s x
-- Mathlib/Data/Ordmap/Ordset.lean
@[simp]
theorem toList_node (s l x r) : toList (@node α s l x r) = toList l ++ x :: toList r
-- Mathlib/RingTheory/Polynomial/Content.lean
@[simp]
theorem content_X : content (X : R[X]) = 1
-- Mathlib/Topology/Separation.lean
/-- In an R₀ space, the closure of a finite set is a compact set. -/
theorem Set.Finite.isCompact_closure {s : Set X} (hs : s.Finite) : IsCompact (closure s)
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- We say that the action of `M` on `α` has `MeasurableVAdd₂` if the map
`(c, x) ↦ c +ᵥ x` is a measurable function. -/
class MeasurableVAdd₂ (M α : Type*) [VAdd M α] [MeasurableSpace M] [MeasurableSpace α] :
    Prop where
  measurable_vadd : Measurable (Function.uncurry (· +ᵥ ·) : M × α → α)
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem ord_compl_dvd (n p : ℕ) : ord_compl[p] n ∣ n
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem isConj_of_cycleType_eq {σ τ : Perm α} (h : cycleType σ = cycleType τ) : IsConj σ τ
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem id_linear : (id k P1).linear = LinearMap.id
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation maps closed balls to closed balls and scales the radius by `ratio f`. -/
theorem mapsTo_closedBall (x : α) (r' : ℝ) :
    MapsTo (f : α → β) (Metric.closedBall x r') (Metric.closedBall (f x) (ratio f * r'))
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem lt_total (f g : CauSeq α abs) : f < g ∨ f ≈ g ∨ g < f
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem dvd_gcd {a b c : R} : c ∣ a → c ∣ b → c ∣ gcd a b
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_of_add_bdd_above_right' (C) (hC : ∀ᶠ x in l, g x ≤ C)
    (h : Tendsto (fun x => f x + g x) l atTop) : Tendsto f l atTop
-- Mathlib/Topology/Order/Monotone.lean
theorem IsClosed.csSup_mem {s : Set α} (hc : IsClosed s) (hs : s.Nonempty) (B : BddAbove s) :
    sSup s ∈ s
-- Mathlib/Data/Fintype/Card.lean
theorem Fintype.card_empty : Fintype.card Empty = 0
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem univ_nonempty : ∀ [Nonempty α], (univ : Set α).Nonempty
-- Mathlib/Data/Stream/Init.lean
theorem map_eq_apply (f : α → β) (s : Stream' α) : map f s = pure f ⊛ s
-- Mathlib/Analysis/Complex/Polynomial/UnitTrinomial.lean
/-- A unit trinomial is irreducible if it has no complex roots in common with its mirror. -/
theorem irreducible_of_coprime' (hp : IsUnitTrinomial p)
    (h : ∀ z : ℂ, ¬(aeval z p = 0 ∧ aeval z (mirror p) = 0)) : Irreducible p
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_le_dist_coe_div_sqrt (z w : ℍ) : dist z w ≤ dist (z : ℂ) w / √(z.im * w.im)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iInter_univ : (⋂ _ : ι, univ : Set α) = univ
-- Mathlib/Data/Nat/Log.lean
theorem lt_pow_iff_log_lt {b : ℕ} (hb : 1 < b) {x y : ℕ} (hy : y ≠ 0) : y < b ^ x ↔ log b y < x
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem op_sSup (S : Set (Submonoid M)) : (sSup S).op = sSup (.unop ⁻¹' S)
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp] lemma bot_mul (hb : b ≠ 0) : ⊥ * b = ⊥
-- Mathlib/Data/Nat/Defs.lean
protected lemma div_pow (h : a ∣ b) : (b / a) ^ c = b ^ c / a ^ c
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem length_insert_of_not_mem {l : List α} (h : a ∉ l) :
    length (l.insert a) = length l + 1
-- Mathlib/Topology/IsLocalHomeomorph.lean
/-- Continuous local sections of a local homeomorphism are open embeddings. -/
theorem openEmbedding_of_comp (hf : IsLocalHomeomorph g) (hgf : OpenEmbedding (g ∘ f))
    (cont : Continuous f) : OpenEmbedding f
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem mem_closure {x : M} : x ∈ closure s ↔ ∀ S : Subsemigroup M, s ⊆ S → x ∈ S
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_eq_single {s : Finset α} {f : α → β} (a : α) (h₀ : ∀ b ∈ s, b ≠ a → f b = 1)
    (h₁ : a ∉ s → f a = 1) : ∏ x ∈ s, f x = f a
-- Mathlib/Algebra/Algebra/Operations.lean
theorem iSup_mul (s : ι → Submodule R A) (t : Submodule R A) : (⨆ i, s i) * t = ⨆ i, s i * t
-- Mathlib/Topology/Algebra/Constructions/DomMulAct.lean
@[to_additive (attr := continuity, fun_prop)]
theorem continuous_mk : Continuous (@mk M)
-- Mathlib/CategoryTheory/Simple.lean
/-- We don't want the definition of 'simple' to include the zero object, so we check that here. -/
theorem zero_not_simple [Simple (0 : C)] : False
-- Mathlib/Topology/Order/Basic.lean
theorem pi_Ici_mem_nhds (ha : ∀ i, a i < x i) : Ici a ∈ 𝓝 x
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem lintegral_nnnorm_add_right (f : α → β) {g : α → γ} (hg : AEStronglyMeasurable g μ) :
    ∫⁻ a, ‖f a‖₊ + ‖g a‖₊ ∂μ = (∫⁻ a, ‖f a‖₊ ∂μ) + ∫⁻ a, ‖g a‖₊ ∂μ
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.eq_bot_of_le (hab : Disjoint a b) (h : a ≤ b) : a = ⊥
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
/-- The product `x * r`, `r : ℚ`, `r ≠ 0`, is a Liouville number with exponent `p` if and only if
`x` satisfies the same condition. -/
theorem mul_rat_iff (hr : r ≠ 0) : LiouvilleWith p (x * r) ↔ LiouvilleWith p x
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
theorem eq_cyclotomic_iff {R : Type*} [CommRing R] {n : ℕ} (hpos : 0 < n) (P : R[X]) :
    P = cyclotomic n R ↔
    (P * ∏ i ∈ Nat.properDivisors n, Polynomial.cyclotomic i R) = X ^ n - 1
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_zsmul_sub_toIocMod (a b : α) : toIocDiv hp a b • p + toIocMod hp a b = b
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma sq_lt_sq' (h1 : -b < a) (h2 : a < b) : a ^ 2 < b ^ 2
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ [s + n]
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
protected theorem indicator [Zero β] (hfm : AEStronglyMeasurable f μ) {s : Set α}
    (hs : MeasurableSet s) : AEStronglyMeasurable (s.indicator f) μ
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem tangentMapWithin_prod_fst {s : Set (M × M')} {p : TangentBundle (I.prod I') (M × M')}
    (hs : UniqueMDiffWithinAt (I.prod I') s p.proj) :
    tangentMapWithin (I.prod I') I Prod.fst s p = ⟨p.proj.1, p.2.1⟩
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive (attr := simp)]
theorem Units.coe_unop_opEquiv {M} [Monoid M] (u : Mᵐᵒᵖˣ) :
    ((Units.opEquiv u).unop : M) = unop (u : Mᵐᵒᵖ)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- If `f : G → H` is an additive homomorphism between two additive monoids, then
`Finsupp.mapDomain f` is a ring homomorphism between their add monoid algebras. -/
@[simps]
def mapDomainRingHom (k : Type*) [Semiring k] {H F : Type*} [AddMonoid G] [AddMonoid H]
    [FunLike F G H] [AddMonoidHomClass F G H] (f : F) : k[G] →+* k[H]
-- Mathlib/Algebra/Tropical/BigOperators.lean
/-- Note we cannot use `i ∈ s` instead of `i : s` here
as it is simply not true on conditionally complete lattices! -/
theorem Finset.untrop_sum [ConditionallyCompleteLinearOrder R] (s : Finset S)
    (f : S → Tropical (WithTop R)) : untrop (∑ i ∈ s, f i) = ⨅ i : s, untrop (f i)
-- Mathlib/Topology/MetricSpace/PiNat.lean
/-- Any nonempty complete second countable metric space is the continuous image of the
fundamental space `ℕ → ℕ`. For a version of this theorem in the context of Polish spaces, see
`exists_nat_nat_continuous_surjective_of_polishSpace`. -/
theorem exists_nat_nat_continuous_surjective_of_completeSpace (α : Type*) [MetricSpace α]
    [CompleteSpace α] [SecondCountableTopology α] [Nonempty α] :
    ∃ f : (ℕ → ℕ) → α, Continuous f ∧ Surjective f
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_involutive : Function.Involutive (mirror : R[X] → R[X])
-- Mathlib/Data/List/Nodup.lean
theorem nodup_singleton (a : α) : Nodup [a]
-- Mathlib/Order/Hom/Bounded.lean
/-- The type of `⊥`-preserving functions from `α` to `β`. -/
structure BotHom (α β : Type*) [Bot α] [Bot β] where
  /-- The underlying function. The preferred spelling is `DFunLike.coe`. -/
  toFun : α → β
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
-- Mathlib/Data/Multiset/FinsetOps.lean
@[simp]
theorem coe_ndinter (l₁ l₂ : List α) : @ndinter α _ l₁ l₂ = (l₁ ∩ l₂ : List α)
-- Mathlib/Data/Set/Function.lean
@[simp]
lemma image_fst_graphOn (f : α → β) (s : Set α) : Prod.fst '' graphOn f s = s
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toFinsupp_zero [Zero M] [∀ m : M, Decidable (m ≠ 0)] : toFinsupp 0 = (0 : ι →₀ M)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma Affine.CoordinateRing.mk_ψ (n : ℤ) : mk W (W.ψ n) = mk W (W.Ψ n)
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
/-- This is `Orthonormal.isHilbertSum` in the case of actual inclusions from subspaces. -/
theorem IsHilbertSum.mkInternal [∀ i, CompleteSpace <| F i]
    (hFortho : OrthogonalFamily 𝕜 (fun i => F i) fun i => (F i).subtypeₗᵢ)
    (hFtotal : ⊤ ≤ (⨆ i, F i).topologicalClosure) :
    IsHilbertSum 𝕜 (fun i => F i) fun i => (F i).subtypeₗᵢ
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
lemma edge_self_eq_bot : edge s s = ⊥
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp] lemma mop_braiding (X Y : C) : (β_ X Y).mop = β_ (mop Y) (mop X)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem specialLinearGroup_apply {R : Type*} [CommRing R] [Algebra R ℝ] (g : SL(2, R)) (z : ℍ) :
    g • z =
      mk
        (((algebraMap R ℝ (↑ₘ[R] g 0 0) : ℂ) * z + (algebraMap R ℝ (↑ₘ[R] g 0 1) : ℂ)) /
          ((algebraMap R ℝ (↑ₘ[R] g 1 0) : ℂ) * z + (algebraMap R ℝ (↑ₘ[R] g 1 1) : ℂ)))
        (g • z).property
-- Mathlib/Algebra/Quaternion.lean
theorem smul_coe : x • (y : ℍ[R,c₁,c₂]) = ↑(x * y)
-- Mathlib/Data/Bool/Basic.lean
theorem or_inr {a b : Bool} (H : b) : a || b
-- Mathlib/Data/Set/Prod.lean
theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → β) :
    (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅
-- Mathlib/SetTheory/Game/Impartial.lean
/-- In an impartial game, either the first player always wins, or the second player always wins. -/
theorem equiv_or_fuzzy_zero : (G ≈ 0) ∨ G ‖ 0
-- Mathlib/MeasureTheory/Group/Action.lean
@[to_additive]
theorem measure_preimage_smul_of_nullMeasurableSet (hs : NullMeasurableSet s μ) (c : G) :
    μ ((c • ·) ⁻¹' s) = μ s
-- Mathlib/Order/Minimal.lean
theorem minimals_of_symm [IsSymm α r] : minimals r s = s
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- If two finite measures `μ` and `ν` are not mutually singular, there exists some `ε > 0` and
a measurable set `E`, such that `ν(E) > 0` and `E` is positive with respect to `μ - εν`.

This lemma is useful for the Lebesgue decomposition theorem. -/
theorem exists_positive_of_not_mutuallySingular (μ ν : Measure α) [IsFiniteMeasure μ]
    [IsFiniteMeasure ν] (h : ¬μ ⟂ₘ ν) :
    ∃ ε : ℝ≥0, 0 < ε ∧
      ∃ E : Set α,
        MeasurableSet E ∧ 0 < ν E ∧ 0 ≤[E] μ.toSignedMeasure - (ε • ν).toSignedMeasure
-- Mathlib/Topology/ContinuousFunction/Polynomial.lean
/-- The algebra map from `R[X]` to continuous functions `C(X, R)`, for any subset `X` of `R`.
-/
@[simps]
def toContinuousMapOnAlgHom (X : Set R) : R[X] →ₐ[R] C(X, R)
-- Mathlib/Data/Set/Sups.lean
theorem sups_inter_subset_left : (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t
-- Mathlib/Topology/Separation.lean
/-- Given an open finite set `S` in a T₀ space, there is some `x ∈ S` such that `{x}` is open. -/
theorem exists_isOpen_singleton_of_isOpen_finite [T0Space X] {s : Set X} (hfin : s.Finite)
    (hne : s.Nonempty) (ho : IsOpen s) : ∃ x ∈ s, IsOpen ({x} : Set X)
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem ext' (x y : M F) (H : ∀ i : ℕ, x.approx i = y.approx i) : x = y
-- Mathlib/Data/Nat/Bitwise.lean
theorem xor_right_injective {n : ℕ} : Function.Injective (HXor.hXor n : ℕ → ℕ)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem mkOfBound_coe {f} {C} {h} : (mkOfBound f C h : α → β) = (f : α → β)
-- Mathlib/Probability/Integration.lean
/-- The product of two independent, integrable, real-valued random variables is integrable. -/
theorem IndepFun.integrable_mul {β : Type*} [MeasurableSpace β] {X Y : Ω → β}
    [NormedDivisionRing β] [BorelSpace β] (hXY : IndepFun X Y μ) (hX : Integrable X μ)
    (hY : Integrable Y μ) : Integrable (X * Y) μ
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem ExponentExists.isOfFinOrder (h : ExponentExists G) {g : G} : IsOfFinOrder g
-- Mathlib/RingTheory/Nilpotent/Defs.lean
lemma eq_zero_of_nilpotencyClass_eq_one (hx : nilpotencyClass x = 1) :
    x = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem Equiv.tprod_eq (e : γ ≃ β) (f : β → α) : ∏' c, f (e c) = ∏' b, f b
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem tendsto_const_smul_iff {f : β → α} {l : Filter β} {a : α} (c : G) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a)
-- Mathlib/Data/Setoid/Basic.lean
@[symm]
theorem symm' (r : Setoid α) : ∀ {x y}, r.Rel x y → r.Rel y x
-- Mathlib/Order/Filter/Archimedean.lean
/-- If a function tends to infinity along a filter, then this function multiplied by a positive
constant (on the right) also tends to infinity. The archimedean assumption is convenient to get a
statement that works on `ℕ`, `ℤ` and `ℝ`, although not necessary (a version in ordered fields is
given in `Filter.Tendsto.atTop_mul_const`). -/
theorem Tendsto.atTop_mul_const' (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atTop
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem MeasureTheory.volume_sum_rpow_lt [Nonempty ι] {p : ℝ} (hp : 1 ≤ p) (r : ℝ) :
    volume {x : ι → ℝ | (∑ i, |x i| ^ p) ^ (1 / p) < r} = (.ofReal r) ^ card ι *
      .ofReal ((2 * Gamma (1 / p + 1)) ^ card ι / Gamma (card ι / p + 1))
-- Mathlib/Data/List/Rotate.lean
theorem IsRotated.eqv : Equivalence (@IsRotated α)
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
/-- The functional equation for the derivative of the Jacobi theta function, relating
`jacobiTheta₂' z τ` to `jacobiTheta₂' (z / τ) (-1 / τ)`. This is the key lemma behind the proof of
the functional equation for L-series of odd Dirichlet characters. -/
theorem jacobiTheta₂'_functional_equation (z τ : ℂ) :
    jacobiTheta₂' z τ = 1 / (-I * τ) ^ (1 / 2 : ℂ) * cexp (-π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem colimit.ι_pre (k : K) : colimit.ι (E ⋙ F) k ≫ colimit.pre F E = colimit.ι F (E.obj k)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
@[symm]
theorem IsEquivalent.symm (h : u ~[l] v) : v ~[l] u
-- Mathlib/Order/Filter/Pi.lean
theorem eventually_pi [Finite ι] (hf : ∀ i, ∀ᶠ x in f i, p i x) :
    ∀ᶠ x : ∀ i, α i in pi f, ∀ i, p i (x i)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- A linear isometry preserves the property of being orthonormal. -/
theorem LinearIsometry.orthonormal_comp_iff {v : ι → E} (f : E →ₗᵢ[𝕜] E') :
    Orthonormal 𝕜 (f ∘ v) ↔ Orthonormal 𝕜 v
-- Mathlib/Topology/NhdsSet.lean
/-- A proposition is true on a set neighborhood of `s`
iff it is eventually true near each point in the set. -/
theorem eventually_nhdsSet_iff_forall {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ s, p x) ↔ ∀ x, x ∈ s → ∀ᶠ y in 𝓝 x, p y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem not_lt_zero (a : Fin (n + 1)) : ¬a < 0
-- Mathlib/Topology/Maps/Basic.lean
theorem IsClosedMap.closure_image_eq_of_continuous
    (f_closed : IsClosedMap f) (f_cont : Continuous f) (s : Set X) :
    closure (f '' s) = f '' closure s
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The angle between two nonzero vectors is `θ` if and only if the second vector is the first
rotated by `θ` and scaled by a positive real. -/
theorem oangle_eq_iff_eq_pos_smul_rotation_of_ne_zero {x y : V} (hx : x ≠ 0) (hy : y ≠ 0)
    (θ : Real.Angle) : o.oangle x y = θ ↔ ∃ r : ℝ, 0 < r ∧ y = r • o.rotation θ x
-- Mathlib/Data/Part.lean
theorem some_inter_some [Inter α] (a b : α) : some a ∩ some b = some (a ∩ b)
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem count_tail : ∀ (l : List α) (a : α) (h : l ≠ []),
      l.tail.count a = l.count a - if a = l.head h then 1 else 0
-- Mathlib/Algebra/Associated/Basic.lean
theorem le_mul_right {a b : Associates α} : a ≤ a * b
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem symm_cast {a₁ a₂ b₁ b₂ : X} (γ : Path a₂ b₂) (ha : a₁ = a₂) (hb : b₁ = b₂) :
    (γ.cast ha hb).symm = γ.symm.cast hb ha
-- Mathlib/Algebra/Ring/Units.lean
theorem add_eq_mul_one_add_div [Semiring R] {a : Rˣ} {b : R} : ↑a + b = a * (1 + ↑a⁻¹ * b)
-- Mathlib/Order/Filter/Pointwise.lean
theorem mul_add_subset : f * (g + h) ≤ f * g + f * h
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem SimpleGraph.fromRel_adj {V : Type u} (r : V → V → Prop) (v w : V) :
    (SimpleGraph.fromRel r).Adj v w ↔ v ≠ w ∧ (r v w ∨ r w v)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_subtype_range {ι} {f : ι → M} (hf : Injective f) :
    LinearIndependent R ((↑) : range f → M) ↔ LinearIndependent R f
-- Mathlib/Topology/MetricSpace/Holder.lean
theorem edist_le (h : HolderWith C r f) (x y : X) :
    edist (f x) (f y) ≤ (C : ℝ≥0∞) * edist x y ^ (r : ℝ)
-- Mathlib/Data/Finmap.lean
@[simp]
theorem keys_singleton (a : α) (b : β a) : (singleton a b).keys = {a}
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem monomial_one_dvd_monomial_one [Nontrivial R] {i j : σ →₀ ℕ} :
    monomial i (1 : R) ∣ monomial j 1 ↔ i ≤ j
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
@[to_additive]
theorem toContinuousMap_injective : Injective (toContinuousMap : _ → C(A, B))
-- Mathlib/NumberTheory/Cyclotomic/PID.lean
/-- If `IsCyclotomicExtension {5} ℚ K` then `𝓞 K` is a principal ideal domain. -/
theorem five_pid [IsCyclotomicExtension {5} ℚ K] : IsPrincipalIdealRing (𝓞 K)
-- Mathlib/Data/Set/Sups.lean
theorem sups_union_left : (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
@[simp]
theorem cylinder_eq_empty_iff [h_nonempty : Nonempty (∀ i, α i)] (s : Finset ι)
    (S : Set (∀ i : s, α i)) :
    cylinder s S = ∅ ↔ S = ∅
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem compl_toMeasurable_compl_ae_eq (h : NullMeasurableSet s μ) : (toMeasurable μ sᶜ)ᶜ =ᵐ[μ] s
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
length `> i`. Version designed to rewrite from the big list to the small list. -/
@[deprecated getElem_take (since := "2024-06-12")]
theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
    get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩
-- Mathlib/Topology/Compactness/Compact.lean
/-- If a filter has a unique cluster point `y` in a compact topological space,
then the filter is less than or equal to `𝓝 y`. -/
lemma le_nhds_of_unique_clusterPt [CompactSpace X] {l : Filter X} {y : X}
    (h : ∀ x, ClusterPt x l → x = y) : l ≤ 𝓝 y
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem IsUniform.symm : Symmetric (IsUniform G ε)