ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem IsPreconnected.intermediate_value₂_eventually₂ {s : Set X} (hs : IsPreconnected s)
    {l₁ l₂ : Filter X} [NeBot l₁] [NeBot l₂] (hl₁ : l₁ ≤ 𝓟 s) (hl₂ : l₂ ≤ 𝓟 s) {f g : X → α}
    (hf : ContinuousOn f s) (hg : ContinuousOn g s) (he₁ : f ≤ᶠ[l₁] g) (he₂ : g ≤ᶠ[l₂] f) :
    ∃ x ∈ s, f x = g x
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle multiplied by the adjacent side equals
the opposite side. -/
theorem tan_angle_add_mul_norm_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) (h0 : x ≠ 0 ∨ y = 0) :
    Real.tan (angle x (x + y)) * ‖x‖ = ‖y‖
-- Mathlib/Data/ByteArray.lean
theorem Up.WF (ub) : WellFounded (Up ub)
-- Mathlib/Topology/Basic.lean
theorem interior_maximal (h₁ : t ⊆ s) (h₂ : IsOpen t) : t ⊆ interior s
-- Mathlib/Probability/Moments.lean
theorem mgf_neg : mgf (-X) μ t = mgf X μ (-t)
-- Mathlib/Probability/Cdf.lean
/-- The cdf is lower or equal to 1. -/
lemma cdf_le_one (x : ℝ) : cdf μ x ≤ 1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem mul_comm : ∀ (n m : Nat), n * m = m * n
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem nnnorm_map_eq (A : Matrix m n α) (f : α → β) (hf : ∀ a, ‖f a‖₊ = ‖a‖₊) :
    ‖A.map f‖₊ = ‖A‖₊
-- Mathlib/FieldTheory/RatFunc/Defs.lean
theorem mk_eq_mk {p q p' q' : K[X]} (hq : q ≠ 0) (hq' : q' ≠ 0) :
    RatFunc.mk p q = RatFunc.mk p' q' ↔ p * q' = p' * q
-- Mathlib/FieldTheory/SeparableDegree.lean
theorem natSepDegree_pow_of_ne_zero {n : ℕ} (hn : n ≠ 0) :
    (f ^ n).natSepDegree = f.natSepDegree
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem toMatrix_lmul_eq (x : S) :
    LinearMap.toMatrix b b (LinearMap.mulLeft R x) = leftMulMatrix b x
-- Mathlib/Topology/UniformSpace/CompareReals.lean
/-- The metric space uniform structure on ℚ (which presupposes the existence
of real numbers) agrees with the one coming directly from (abs : ℚ → ℚ). -/
theorem Rat.uniformSpace_eq :
    (AbsoluteValue.abs : AbsoluteValue ℚ ℚ).uniformSpace = PseudoMetricSpace.toUniformSpace
-- Mathlib/Deprecated/Subfield.lean
theorem IsSubfield.iInter {ι : Sort*} {S : ι → Set F} (h : ∀ y : ι, IsSubfield (S y)) :
    IsSubfield (Set.iInter S)
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrix_transpose_apply (f : M₁ →ₗ[R] M₂) (j : n) :
    (LinearMap.toMatrix v₁ v₂ f)ᵀ j = v₂.repr (f (v₁ j))
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_csSup (h₁ : BddAbove s) (h₂ : a ∈ s) : a ≤ sSup s
-- Mathlib/Algebra/DualNumber.lean
/-- Lifting `DualNumber.eps` itself gives the identity. -/
@[simp]
theorem lift_inlAlgHom_eps :
    lift ⟨(inlAlgHom _ _ _, ε), eps_mul_eps, fun _ => commute_eps_left _⟩ = AlgHom.id R A[ε]
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_X_pow [Nontrivial R] (s : σ) (n : ℕ) :
    (X s ^ n : MvPolynomial σ R).support = {Finsupp.single s n}
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem vecMul_one (v : m → α) : v ᵥ* 1 = v
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem centralizer_le (s t : Set A) (h : s ⊆ t) : centralizer R t ≤ centralizer R s
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
lemma comap_map_mk {I J : Ideal R} (h : I ≤ J) :
    Ideal.comap (Ideal.Quotient.mk I) (Ideal.map (Ideal.Quotient.mk I) J) = J
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
@[simp]
theorem derivation_C_mul (D : Derivation R (MvPolynomial σ R) A) (a : R) (f : MvPolynomial σ R) :
    C (σ := σ) a • D f = a • D f
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem translationNumber_mul_of_commute {f g : CircleDeg1Lift} (h : Commute f g) :
    τ (f * g) = τ f + τ g
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem ι_comp_map (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ) :
    (ι f₂ g₂).comp (map φ ψ hf hg) = φ.comp (ι f₁ g₁)
-- Mathlib/LinearAlgebra/Quotient.lean
theorem card_eq_card_quotient_mul_card (S : Submodule R M) :
    Nat.card M = Nat.card S * Nat.card (M ⧸ S)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem integrableOn_Ioc_of_intervalIntegral_norm_bounded_right {I a b₀ : ℝ}
    (hfi : ∀ i, IntegrableOn f <| Ioc a (b i)) (hb : Tendsto b l <| 𝓝 b₀)
    (h : ∀ᶠ i in l, (∫ x in Ioc a (b i), ‖f x‖) ≤ I) : IntegrableOn f (Ioc a b₀)
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem ULift.edist_eq (x y : ULift α) : edist x y = edist x.down y.down
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem iInf_sup_of_monotone {ι : Type*} [Preorder ι] [IsDirected ι (swap (· ≤ ·))] {f g : ι → α}
    (hf : Monotone f) (hg : Monotone g) : ⨅ i, f i ⊔ g i = (⨅ i, f i) ⊔ ⨅ i, g i
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Cotangent.lean
lemma Complex.cot_pi_eq_exp_ratio (z : ℂ) :
    cot (π * z) = (Complex.exp (2 * π * I * z) + 1) / (I * (1 - Complex.exp (2 * π * I * z)))
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem isTheta_const_smul_left [NormedSpace 𝕜 E'] {c : 𝕜} (hc : c ≠ 0) :
    (fun x ↦ c • f' x) =Θ[l] g ↔ f' =Θ[l] g
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[simp] -- Porting note (#10618): was @[simp]
theorem integral_comp_mul_left (hc : c ≠ 0) :
    (∫ x in a..b, f (c * x)) = c⁻¹ • ∫ x in c * a..c * b, f x
-- Mathlib/Algebra/Polynomial/Reverse.lean
theorem reflect_mul_induction (cf cg : ℕ) :
    ∀ N O : ℕ,
      ∀ f g : R[X],
        f.support.card ≤ cf.succ →
          g.support.card ≤ cg.succ →
            f.natDegree ≤ N →
              g.natDegree ≤ O → reflect (N + O) (f * g) = reflect N f * reflect O g
-- Mathlib/Topology/Inseparable.lean
theorem rfl : x ~ᵢ x
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem next_eq (f : Hom C₁ C₂) {i j : ι} (w : c.Rel i j) :
    f.next i = (C₁.xNextIso w).hom ≫ f.f j ≫ (C₂.xNextIso w).inv
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
    a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Algebra/Order/ToIntervalMod.lean
/-- `toIocMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIocMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ioc a (a + p)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotation by π is negation. -/
@[simp]
theorem rotation_pi : o.rotation π = LinearIsometryEquiv.neg ℝ
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem equiv'_symm_apply (f : M → M') (g : M' → M) (hf hg hgf hfg) (i : ι') :
    (b.equiv' b' f g hf hg hgf hfg).symm (b' i) = g (b' i)
-- Mathlib/Analysis/Convex/Hull.lean
@[simp]
theorem convexHull_empty : convexHull 𝕜 (∅ : Set E) = ∅
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem coe_orderAddMonoidHom_id : (OrderRingHom.id α : α →+o α) = OrderAddMonoidHom.id α
-- Mathlib/Data/Nat/Defs.lean
lemma succ_mul_pos (m : ℕ) (hn : 0 < n) : 0 < succ m * n
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- In a finite field of odd characteristic, not every element is a square. -/
theorem exists_nonsquare (hF : ringChar F ≠ 2) : ∃ a : F, ¬IsSquare a
-- Mathlib/Algebra/GroupWithZero/Pi.lean
/-- The multiplicative homomorphism including a single `MulZeroClass`
into a dependent family of `MulZeroClass`es, as functions supported at a point.

This is the `MulHom` version of `Pi.single`. -/
@[simps]
def _root_.MulHom.single (i : ι) : α i →ₙ* ∀ i, α i
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
/-- Given Localization maps `f : M →* N, k : P →* Q` for Submonoids `S, T` respectively, if a
`CommMonoid` homomorphism `g : M →* P` induces a `f.map hy k : N →* Q`, then for all `z : N`,
we have `f.map hy k z * k (g y) = k (g x)` where `x : M, y ∈ S` are such that
`z * f y = f x`. -/
@[to_additive
    "Given Localization maps `f : M →+ N, k : P →+ Q` for Submonoids `S, T` respectively, if an
`AddCommMonoid` homomorphism `g : M →+ P` induces a `f.map hy k : N →+ Q`, then for all `z : N`,
we have `f.map hy k z + k (g y) = k (g x)` where `x : M, y ∈ S` are such that
`z + f y = f x`."]
theorem map_mul_right (z) : f.map hy k z * k.toMap (g (f.sec z).2) = k.toMap (g (f.sec z).1)
-- Mathlib/Data/Matroid/Basic.lean
theorem not_finiteRk (M : Matroid α) [InfiniteRk M] : ¬ FiniteRk M
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[mono]
theorem monotone_eapprox (f : α → ℝ≥0∞) : Monotone (eapprox f)
-- Mathlib/LinearAlgebra/Prod.lean
theorem prodMap_comp (f₁₂ : M →ₗ[R] M₂) (f₂₃ : M₂ →ₗ[R] M₃) (g₁₂ : M₄ →ₗ[R] M₅)
    (g₂₃ : M₅ →ₗ[R] M₆) :
    f₂₃.prodMap g₂₃ ∘ₗ f₁₂.prodMap g₁₂ = (f₂₃ ∘ₗ f₁₂).prodMap (g₂₃ ∘ₗ g₁₂)
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
@[simp] theorem reverse_balance1 (l : RBNode α) (v : α) (r : RBNode α) :
    (balance1 l v r).reverse = balance2 r.reverse v l.reverse
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_of_ae_restrict_of_ae_restrict_compl (t : Set α) {p : α → Prop}
    (ht : ∀ᵐ x ∂μ.restrict t, p x) (htc : ∀ᵐ x ∂μ.restrict tᶜ, p x) : ∀ᵐ x ∂μ, p x
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_of_integrable_trim (hm : m ≤ m0) (hf_int : Integrable f (μ'.trim hm)) :
    Integrable f μ'
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[simp, norm_cast] lemma coe_pow (f : AddMonoid.End A) (n : ℕ) : (↑(f ^ n) : A → A) = f^[n]
-- Mathlib/Data/Finset/Basic.lean
theorem filter_ne [DecidableEq β] (s : Finset β) (b : β) :
    (s.filter fun a => b ≠ a) = s.erase b
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp]
theorem testAgainstNN_one (μ : FiniteMeasure Ω) : μ.testAgainstNN 1 = μ.mass
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem monomial_zero_one : monomial 0 (1 : R) = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem iota_succ : iota (i+1) = (i+1) :: iota i
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem inf_relindex_right : (H ⊓ K).relindex K = H.relindex K
-- Mathlib/NumberTheory/Divisors.lean
lemma left_ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
    p.1 ≠ 0
-- Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean
@[simp]
theorem obj_d_eq (X : SimplicialObject C) (n : ℕ) :
    (AlternatingFaceMapComplex.obj X).d (n + 1) n
      = ∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • X.δ i
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp]
theorem coe_ne_empty : (I : Set (ι → ℝ)) ≠ ∅
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma isOpen_iff_isUpperSet : IsOpen s ↔ IsUpperSet s
-- Mathlib/Analysis/Normed/Order/Lattice.lean
lemma continuous_negPart : Continuous (negPart : α → α)
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivQuotOfLE_comp_quotQuotMkₐ (h : I ≤ J) :
    AlgHom.comp (↑(quotQuotEquivQuotOfLEₐ R h)) (quotQuotMkₐ R I J) = Quotient.mkₐ R J
-- Mathlib/Data/List/Infix.lean
@[simp]
theorem inits_append : ∀ s t : List α, inits (s ++ t) = s.inits ++ t.inits.tail.map fun l => s ++ l
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem modelWithCornersSelf_prod : 𝓘(𝕜, E × F) = 𝓘(𝕜, E).prod 𝓘(𝕜, F)
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem frequently_false (f : Filter α) : ¬∃ᶠ _ in f, False
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_map (μ : Measure α) (s : Set β) :
    (μ.map f).restrict s = (μ.restrict <| f ⁻¹' s).map f
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem num_mem_carrier_iff (hm : 0 < m) (q : Spec.T A⁰_ f)
    (z : HomogeneousLocalization.NumDenSameDeg 𝒜 (.powers f)) :
    z.num.1 ∈ carrier f_deg q ↔ HomogeneousLocalization.mk z ∈ q.asIdeal
-- Mathlib/Data/DFinsupp/WellFounded.lean
/-- This key lemma says that if a finitely supported dependent function `x₀` is obtained by merging
  two such functions `x₁` and `x₂`, and if we evolve `x₀` down the `DFinsupp.Lex` relation one
  step and get `x`, we can always evolve one of `x₁` and `x₂` down the `DFinsupp.Lex` relation
  one step while keeping the other unchanged, and merge them back (possibly in a different way)
  to get back `x`. In other words, the two parts evolve essentially independently under
  `DFinsupp.Lex`. This is used to show that a function `x` is accessible if
  `DFinsupp.single i (x i)` is accessible for each `i` in the (finite) support of `x`
  (`DFinsupp.Lex.acc_of_single`). -/
theorem lex_fibration [∀ (i) (s : Set ι), Decidable (i ∈ s)] :
    Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s)
      fun x => piecewise x.2.1 x.2.2 x.1
-- Mathlib/Algebra/Module/Submodule/Map.lean
@[simp]
theorem map_equivMapOfInjective_symm_apply (f : F) (i : Injective f) (p : Submodule R M)
    (x : p.map f) : f ((equivMapOfInjective f i p).symm x) = x
-- Mathlib/Analysis/Convex/Jensen.lean
/-- **Minimum principle** for concave functions on an interval. If a function `f` is concave on the
interval `[x, y]`, then the eventual minimum of `f` on `[x, y]` is at `x` or `y`. -/
lemma ConcaveOn.min_le_of_mem_Icc {f : 𝕜 → β} {x y z : 𝕜} (hf : ConcaveOn 𝕜 (Icc x y) f)
    (hz : z ∈ Icc x y) : min (f x) (f y) ≤ f z
-- Mathlib/Analysis/Normed/Module/Dual.lean
@[simp]
theorem dual_def (x : E) (f : Dual 𝕜 E) : inclusionInDoubleDual 𝕜 E x f = f x
-- Mathlib/Data/Multiset/Basic.lean
theorem map_id (s : Multiset α) : map id s = s
-- Mathlib/Topology/Order/LeftRight.lean
theorem continuousAt_iff_continuous_left_right {a : α} {f : α → β} :
    ContinuousAt f a ↔ ContinuousWithinAt f (Iic a) a ∧ ContinuousWithinAt f (Ici a) a
-- Mathlib/RingTheory/Ideal/Pointwise.lean
theorem pointwise_smul_subset_iff {a : M} {S T : Ideal R} : a • S ≤ T ↔ S ≤ a⁻¹ • T
-- Mathlib/Order/Bounds/Basic.lean
/-- Adding a point to a set preserves its boundedness above. -/
@[simp]
theorem bddAbove_insert [IsDirected α (· ≤ ·)] {s : Set α} {a : α} :
    BddAbove (insert a s) ↔ BddAbove s
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem gc_lcs_ucs (k : ℕ) :
    GaloisConnection (fun N : LieSubmodule R L M => N.lcs k) fun N : LieSubmodule R L M =>
      N.ucs k
-- Mathlib/Data/Finset/NAry.lean
lemma sup_image₂_left (g : γ → δ) : sup (image₂ f s t) g = sup s fun x ↦ sup t (g <| f x ·)
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma inv_mem_units (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units) : x⁻¹ ∈ S.units
-- .lake/packages/lean4/src/lean/Init/Core.lean
/-- Iff can now be used to do substitutions in a calculation -/
theorem Iff.subst {a b : Prop} {p : Prop → Prop} (h₁ : a ↔ b) (h₂ : p a) : p b
-- Mathlib/GroupTheory/Perm/Support.lean
theorem support_swap_mul_swap {x y z : α} (h : List.Nodup [x, y, z]) :
    support (swap x y * swap y z) = {x, y, z}
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_pi {ι : Type u} (α : ι → Type v) : #(∀ i, α i) = prod fun i => #(α i)
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pwFilter_subset [DecidableRel (α := α) R] (l : List α) : pwFilter R l ⊆ l
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem lift_range_le {f : A →ₙₐ[R] C} {S : Subalgebra R C} :
    (lift f).range ≤ S ↔ NonUnitalAlgHom.range f ≤ S.toNonUnitalSubalgebra
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_le {l₁ l₂ : List α} : (l₁ : Multiset α) ≤ l₂ ↔ l₁ <+~ l₂
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.sup f = s₂.sup g
-- Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean
theorem exists_eq_pow_p_mul' (a : 𝕎 k) (ha : a ≠ 0) :
    ∃ (m : ℕ) (b : Units (𝕎 k)), a = (p : 𝕎 k) ^ m * b
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_inv_ofNat_smul [DivisionSemiring R] [AddCommMonoid α] [StarAddMonoid α]
    [Module R α] (c : ℕ) [c.AtLeastTwo] (M : Matrix m n α) :
    ((no_index (OfNat.ofNat c : R))⁻¹ • M)ᴴ = (OfNat.ofNat c : R)⁻¹ • Mᴴ
-- Mathlib/Algebra/Lie/Submodule.lean
theorem iSup_eq_top_iff_coe_toSubmodule {ι : Sort*} {N : ι → LieSubmodule R L M} :
    ⨆ i, N i = ⊤ ↔ ⨆ i, (N i : Submodule R M) = ⊤
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
@[simp]
theorem lintegral_const (c : ℝ≥0∞) : ∫⁻ _, c ∂μ = c * μ univ
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem coe_comp_pseudoEpimorphism (g : EsakiaHom β γ) (f : EsakiaHom α β) :
    (g.comp f : PseudoEpimorphism α γ) = (g : PseudoEpimorphism β γ).comp f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addU_ne_zero_of_Y_ne {P Q : Fin 3 → F} (hPz : P z ≠ 0) (hQz : Q z ≠ 0)
    (hy : P y * Q z ^ 3 ≠ Q y * P z ^ 3) : addU P Q ≠ 0
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem StronglyMeasurable.integral_kernel_prod_left' ⦃f : β × α → E⦄ (hf : StronglyMeasurable f) :
    StronglyMeasurable fun y => ∫ x, f (x, y) ∂κ y
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
/-- Build an isomorphism in the category `Module R` from a `LinearEquiv` between `Module`s. -/
@[simps]
def LinearEquiv.toModuleIso {g₁ : AddCommGroup X₁} {g₂ : AddCommGroup X₂} {m₁ : Module R X₁}
    {m₂ : Module R X₂} (e : X₁ ≃ₗ[R] X₂) : ModuleCat.of R X₁ ≅ ModuleCat.of R X₂
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem tmul_neg (m : M) (n : N) : m ⊗ₜ (-n) = -m ⊗ₜ[R] n
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem cycleType (h : IsThreeCycle σ) : σ.cycleType = {3}
-- Mathlib/Order/Cover.lean
/-- If `a < b` then there exist `a' > a` and `b' < b` such that `Set.Iio a'` is strictly to the left
of `Set.Ioi b'`. -/
lemma LT.lt.exists_disjoint_Iio_Ioi (h : a < b) :
    ∃ a' > a, ∃ b' < b, ∀ x < a', ∀ y > b', x < y
-- Mathlib/SetTheory/ZFC/Ordinal.lean
protected theorem IsTransitive.sUnion (h : x.IsTransitive) :
    (⋃₀ x : ZFSet).IsTransitive
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem of_apply [AddZeroClass G] (a : Multiplicative G) :
    of k G a = single (Multiplicative.toAdd a) 1
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem exists_compact_not_null [InnerRegular μ] : (∃ K, IsCompact K ∧ μ K ≠ 0) ↔ μ ≠ 0
-- Mathlib/Order/Filter/CountableSeparatingOn.lean
theorem of_eventually_mem_of_forall_separating_mem_iff (p : Set β → Prop) {s : Set β}
    [h' : HasCountableSeparatingOn β p s] (hf : ∀ᶠ x in l, f x ∈ s) (hg : ∀ᶠ x in l, g x ∈ s)
    (h : ∀ U : Set β, p U → ∀ᶠ x in l, f x ∈ U ↔ g x ∈ U) : f =ᶠ[l] g
-- Mathlib/LinearAlgebra/Pi.lean
theorem apply_single [AddCommMonoid M] [Module R M] [DecidableEq ι] (f : (i : ι) → φ i →ₗ[R] M)
    (i j : ι) (x : φ i) : f j (Pi.single i x j) = (Pi.single i (f i x) : ι → M) j
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_eq_zero_iff_empty (α : Type*) : card α = 0 ↔ IsEmpty α
-- Mathlib/GroupTheory/Submonoid/Center.lean
@[to_additive (attr := simp) AddSubmonoid.center_toAddSubsemigroup]
theorem center_toSubsemigroup : (center M).toSubsemigroup = Subsemigroup.center M
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
@[simp]
theorem unop_top : (⊤ : Subsemiring Rᵐᵒᵖ).unop = ⊤
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@[simp]
theorem finsuppTensorFinsuppLid_apply_apply (f : ι →₀ R) (g : κ →₀ N) (a : ι) (b : κ) :
    finsuppTensorFinsuppLid R N ι κ (f ⊗ₜ[R] g) (a, b) = f a • g b
-- Mathlib/Algebra/Lie/Free.lean
theorem liftAux_map_add (f : X → L) (a b : lib R X) :
    liftAux R f (a + b) = liftAux R f a + liftAux R f b
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem iterate_derivative_at_0_ne_zero [CharZero R] (n ν : ℕ) (h : ν ≤ n) :
    (Polynomial.derivative^[ν] (bernsteinPolynomial R n ν)).eval 0 ≠ 0
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
/-- If `s` has the unique differential property, `f` is differentiable on `s` and its derivative
at every point of `s` has dense range, then `f '' s` has the unique differential property. -/
theorem UniqueMDiffOn.image_denseRange (hs : UniqueMDiffOn I s) {f : M → M'}
    (hf : MDifferentiableOn I I' f s) (hd : ∀ x ∈ s, DenseRange (mfderivWithin I I' f s x)) :
    UniqueMDiffOn I' (f '' s)
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma disjointSigma_indep_iff {h I} :
    (Matroid.disjointSigma M h).Indep I ↔
      (∀ i, (M i).Indep (I ∩ (M i).E)) ∧ I ⊆ ⋃ i, (M i).E
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma comap_loopyOn (f : α → β) (E : Set β) : comap (loopyOn E) f = loopyOn (f ⁻¹' E)
-- Mathlib/Probability/StrongLaw.lean
theorem _root_.MeasureTheory.AEStronglyMeasurable.memℒp_truncation [IsFiniteMeasure μ]
    (hf : AEStronglyMeasurable f μ) {A : ℝ} {p : ℝ≥0∞} : Memℒp (truncation f A) p μ
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
/-- A crude lemma estimating the difference between `log (1-x)` and its Taylor series at `0`,
where the main point of the bound is that it tends to `0`. The goal is to deduce the series
expansion of the logarithm, in `hasSum_pow_div_log_of_abs_lt_1`.

Porting note (#11215): TODO: use one of generic theorems about Taylor's series
to prove this estimate.
-/
theorem abs_log_sub_add_sum_range_le {x : ℝ} (h : |x| < 1) (n : ℕ) :
    |(∑ i ∈ range n, x ^ (i + 1) / (i + 1)) + log (1 - x)| ≤ |x| ^ (n + 1) / (1 - |x|)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem sub_add_min_cancel (n m : Nat) : n - m + min n m = n
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- Given a closed set `s`, a point belongs to `s` iff its infimum distance to this set vanishes. -/
theorem _root_.IsClosed.not_mem_iff_infDist_pos (h : IsClosed s) (hs : s.Nonempty) :
    x ∉ s ↔ 0 < infDist x s
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Auxiliary lemma in the proof of `integral_eq_sub_of_hasDeriv_right_of_le`: real version -/
theorem integral_eq_sub_of_hasDeriv_right_of_le_real (hab : a ≤ b)
    (hcont : ContinuousOn g (Icc a b)) (hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x)
    (g'int : IntegrableOn g' (Icc a b)) : ∫ y in a..b, g' y = g b - g a
-- Mathlib/Topology/Sober.lean
theorem isGenericPoint_iff_forall_closed (hS : IsClosed S) (hxS : x ∈ S) :
    IsGenericPoint x S ↔ ∀ Z : Set α, IsClosed Z → x ∈ Z → S ⊆ Z
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem toOuterMeasure_uniformOfFinset_apply :
    (uniformOfFinset s hs).toOuterMeasure t = (s.filter (· ∈ t)).card / s.card
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- The bijection of `Trident.IsLimit.homIso` is natural in `Z`. -/
theorem Trident.IsLimit.homIso_natural [Nonempty J] {t : Trident f} (ht : IsLimit t) {Z Z' : C}
    (q : Z' ⟶ Z) (k : Z ⟶ t.pt) :
    (Trident.IsLimit.homIso ht _ (q ≫ k) : Z' ⟶ X) =
      q ≫ (Trident.IsLimit.homIso ht _ k : Z ⟶ X)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp]
lemma ofZeros_g' (hf : S.f = 0) (hg : S.g = 0) :
    (ofZeros S hf hg).g' = 0
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma whiskerRight_mapId_inv (f : a ⟶ b) : (F.mapId a).inv ▷ F.map f =
    (λ_ (F.map f)).hom ≫ F.map₂ (λ_ f).inv ≫ (F.mapComp (𝟙 a) f).hom
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLen_sublist_of_sublist (n) {l₁ l₂ : List α} (h : l₁ <+ l₂) :
    sublistsLen n l₁ <+ sublistsLen n l₂
-- Mathlib/Data/Nat/Factorial/SuperFactorial.lean
@[simp]
theorem superFactorial_one : sf 1 = 1
-- Mathlib/Control/Traversable/Basic.lean
@[simp]
theorem id_comp (η : ApplicativeTransformation F G) : idTransformation.comp η = η
-- Mathlib/Order/Interval/Finset/Nat.lean
@[simp]
theorem card_Icc : (Icc a b).card = b + 1 - a
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem biUnion_coe_eq_coe (I : WithBot (Box ι)) :
    ⋃ (J : Box ι) (_ : ↑J = I), (J : Set (ι → ℝ)) = I
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem sumDiffSubset_apply_inr {α} {s t : Set α} (h : s ⊆ t) [DecidablePred (· ∈ s)]
    (x : (t \ s : Set α)) : Equiv.Set.sumDiffSubset h (Sum.inr x) = inclusion diff_subset x
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem epi_iff_range_eq_top : Epi f ↔ f.range = ⊤
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem invOf_submatrix_equiv_eq (A : Matrix m m α) (e₁ e₂ : n ≃ m) [Invertible A]
    [Invertible (A.submatrix e₁ e₂)] : ⅟ (A.submatrix e₁ e₂) = (⅟ A).submatrix e₂ e₁
-- Mathlib/LinearAlgebra/Span.lean
theorem apply_mem_span_image_of_mem_span [RingHomSurjective σ₁₂] (f : F) {x : M}
    {s : Set M} (h : x ∈ Submodule.span R s) : f x ∈ Submodule.span R₂ (f '' s)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem range_cos_infinite : (range Real.cos).Infinite