ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Valuation/Integers.lean
/--
Let `O` be the integers of the valuation `v` on some commutative ring `R`. For every element `x` in
`O`, `x` is a unit in `O` if and only if the image of `x` in `R` is a unit and has valuation 1.
-/
theorem isUnit_of_one (hv : Integers v O) {x : O} (hx : IsUnit (algebraMap O R x))
    (hvx : v (algebraMap O R x) = 1) : IsUnit x
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafification.lean
lemma toSheaf_map_sheafificationHomEquiv_symm
    {P : PresheafOfModules.{v} R₀} {F : SheafOfModules.{v} R}
    (g : P ⟶ (restrictScalars α).obj ((SheafOfModules.forget _).obj F)) :
    (SheafOfModules.toSheaf _).map ((sheafificationHomEquiv α).symm g) =
      (((sheafificationAdjunction J AddCommGrp).homEquiv
        P.presheaf ((SheafOfModules.toSheaf R).obj F)).symm g.hom)
-- Mathlib/Topology/Basic.lean
@[simp]
theorem interior_eq_univ : interior s = univ ↔ s = univ
-- Mathlib/RingTheory/Localization/Submodule.lean
@[mono]
theorem coeSubmodule_strictMono : StrictMono (coeSubmodule K : Ideal R → Submodule R K)
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem vecMulVec_cons (v : m' → α) (x : α) (w : Fin n → α) :
    vecMulVec v (vecCons x w) = of fun i => v i • vecCons x w
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem star_snd (a : 𝓜(𝕜, A)) (b : A) : (star a).snd b = star (a.fst (star b))
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_ker {x : L} : x ∈ ker f ↔ f x = 0
-- Mathlib/Data/Nat/Count.lean
theorem count_add (a b : ℕ) : count p (a + b) = count p a + count (fun k ↦ p (a + k)) b
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem IsClosed.vadd_right_of_isCompact {s : Set V} {t : Set P} (hs : IsClosed s)
    (ht : IsCompact t) : IsClosed (s +ᵥ t)
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
theorem AEStronglyMeasurable.ae_integrable_condKernel_iff {f : α × Ω → F}
    (hf : AEStronglyMeasurable f ρ) :
    (∀ᵐ a ∂ρ.fst, Integrable (fun ω ↦ f (a, ω)) (ρ.condKernel a)) ∧
      Integrable (fun a ↦ ∫ ω, ‖f (a, ω)‖ ∂ρ.condKernel a) ρ.fst ↔ Integrable f ρ
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
theorem embedding_inr [Zero R] : Embedding (inr : M → tsze R M)
-- Mathlib/Algebra/Order/Ring/Finset.lean
theorem sup_mul_le_mul_sup_of_nonneg [OrderBot R] (s : Finset ι) (ha : ∀ i ∈ s, 0 ≤ a i)
    (hb : ∀ i ∈ s, 0 ≤ b i) : s.sup (a * b) ≤ s.sup a * s.sup b
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
lemma smul_naturality {M N : ModuleCat.{v} R} (f : M ⟶ N) (r : R) :
    (forget₂ (ModuleCat R) AddCommGrp).map f ≫ N.smul r =
      M.smul r ≫ (forget₂ (ModuleCat R) AddCommGrp).map f
-- Mathlib/Computability/TuringMachine.lean
theorem tr_supports {S} (ss : TM2.Supports M S) : TM1.Supports (tr M) (trSupp M S)
-- Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean
/-- If `M` is nondegenerate and `w * M * v = 0` for all `w`, then `v = 0`. -/
theorem Nondegenerate.eq_zero_of_ortho {M : Matrix m m R} (hM : Nondegenerate M) {v : m → R}
    (hv : ∀ w, Matrix.dotProduct v (M *ᵥ w) = 0) : v = 0
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.mono {f : α → β} {g : α → γ} (hg : HasFiniteIntegral g μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ ‖g a‖) : HasFiniteIntegral f μ
-- Mathlib/Geometry/Manifold/InteriorBoundary.lean
lemma isInteriorPoint_iff {x : M} :
    I.IsInteriorPoint x ↔ extChartAt I x x ∈ interior (extChartAt I x).target
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mul_le_left : I * J ≤ J
-- Mathlib/Topology/Category/TopCat/Basic.lean
theorem comp_app {X Y Z : TopCat.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
    (f ≫ g : X → Z) x = g (f x)
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem IsLocal.le_jacobson {I J : Ideal R} (hi : IsLocal I) (hij : I ≤ J) (hj : J ≠ ⊤) :
    J ≤ jacobson I
-- Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean
lemma dualSubmodule_dualSubmodule_flip_of_basis {ι : Type*} [Finite ι]
    (hB : B.Nondegenerate) (b : Basis ι S M) :
    B.dualSubmodule (B.flip.dualSubmodule (Submodule.span R (Set.range b))) =
      Submodule.span R (Set.range b)
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem mem_support_derivative [NoZeroSMulDivisors ℕ R] (p : R[X]) (n : ℕ) :
    n ∈ (derivative p).support ↔ n + 1 ∈ p.support
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem eq_bot_of_card_eq (h : card S = 1) : S = ⊥
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem coeComplex_one : ((1 : ℂ) : ℍ) = 1
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem unop_sSup (S : Set (Submonoid Mᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S)
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- The topology of a `NormedSpace 𝕜 E` is induced by the seminorm `normSeminorm 𝕜 E`. -/
theorem norm_withSeminorms (𝕜 E) [NormedField 𝕜] [SeminormedAddCommGroup E] [NormedSpace 𝕜 E] :
    WithSeminorms fun _ : Fin 1 => normSeminorm 𝕜 E
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem closure.isSubgroup (s : Set G) : IsSubgroup (closure s)
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem toCoalgEquiv_eq_coe (f : A ≃ₐc[R] B) : f.toCoalgEquiv = f
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_lt_tsum {f g : α → ℝ≥0} {i : α} (h : ∀ a : α, f a ≤ g a) (hi : f i < g i)
    (hg : Summable g) : ∑' n, f n < ∑' n, g n
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma formula2 :
    S.Y ^ 3 + S.u₄ * S.Z ^ 3 = S.u₅ * (λ ^ (S.multiplicity - 1) * S.X) ^ 3
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
theorem isHermitian_transpose_add_self (A : Matrix n n α) : (Aᴴ + A).IsHermitian
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem mono_set' (hf : IntervalIntegrable f μ a b) (hsub : Ι c d ⊆ Ι a b) :
    IntervalIntegrable f μ c d
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem tendsto_inv_nhdsWithin_Ici {a : H} : Tendsto Inv.inv (𝓝[≥] a) (𝓝[≤] a⁻¹)
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem U_neg_two : U R (-2) = -1
-- Mathlib/Combinatorics/HalesJewett.lean
lemma coe_injective [Nontrivial α] : Injective ((⇑) : Line α ι → α → ι → α)
-- Mathlib/Order/Basic.lean
/-- A version of `ne_iff_lt_or_gt` with LHS and RHS reversed. -/
@[simp]
theorem lt_or_lt_iff_ne [LinearOrder α] {x y : α} : x < y ∨ y < x ↔ x ≠ y
-- Mathlib/Computability/Reduce.lean
theorem OneOneEquiv.to_many_one {α β} [Primcodable α] [Primcodable β] {p : α → Prop}
    {q : β → Prop} : OneOneEquiv p q → ManyOneEquiv p q
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda'_inv_comp_π [HasLimitsOfShape I (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda' F A).inv ≫ (coyoneda.map (colimit.ι F ⟨i⟩).op).app A
      = limit.π (F.rightOp ⋙ yoneda.obj A) i
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem uniformIntegrable_congr_ae {g : ι → α → β} (hfg : ∀ n, f n =ᵐ[μ] g n) :
    UniformIntegrable f p μ ↔ UniformIntegrable g p μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem fderivWithin_csin (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
    fderivWithin ℂ (fun x => Complex.sin (f x)) s x = Complex.cos (f x) • fderivWithin ℂ f s x
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem traverse_pure' : traverse F ∘ pure = fun x ↦ (pure <$> F x : m (FreeMagma β))
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
/-- `R` is integrally closed iff all integral elements of its fraction field `K`
are also elements of `R`. -/
theorem isIntegrallyClosed_iff :
    IsIntegrallyClosed R ↔ ∀ {x : K}, IsIntegral R x → ∃ y, algebraMap R K y = x
-- Mathlib/Data/ZMod/Units.lean
lemma unitsMap_def (hm : n ∣ m) : unitsMap hm = Units.map (castHom hm (ZMod n))
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem snoc_last : snoc p x (last n) = x
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem encode_false : encode false = 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isLittleO_zero_right_iff : (f'' =o[l] fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0
-- Mathlib/Data/Finset/PImage.lean
theorem pimage_subset {t : Finset β} : s.pimage f ⊆ t ↔ ∀ x ∈ s, ∀ y ∈ f x, y ∈ t
-- Mathlib/SetTheory/Lists.lean
theorem mem_equiv_left {l : Lists' α true} : ∀ {a a'}, a ~ a' → (a ∈ l ↔ a' ∈ l)
-- Mathlib/Topology/Order.lean
theorem IsClosed.mono (hs : IsClosed[t₂] s) (h : t₁ ≤ t₂) : IsClosed[t₁] s
-- Mathlib/Data/PNat/Interval.lean
theorem map_subtype_embedding_Ioc : (Ioc a b).map (Embedding.subtype _) = Ioc ↑a ↑b
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem one_le_iff_pos {o : Ordinal} : 1 ≤ o ↔ 0 < o
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma exists_abs_lt {α : Type*} [LinearOrderedRing α] (a : α) : ∃ b > 0, |a| < b
-- Mathlib/Data/Fin/Basic.lean
/-- `Fin.castSucc` as an `Embedding`, `castSuccEmb i` embeds `i : Fin n` in `Fin (n+1)`. -/
@[simps! apply]
def castSuccEmb : Fin n ↪ Fin (n + 1)
-- Mathlib/Topology/Order/PartialSups.lean
protected lemma partialSups (hf : ∀ k ≤ n, Tendsto (f k) l (𝓝 (g k))) :
    Tendsto (partialSups f n) l (𝓝 (partialSups g n))
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem comap_equiv_eq_map_symm (f : R ≃+* S) (K : Subring S) :
    K.comap (f : R →+* S) = K.map f.symm
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma add_of_Y_eq {x₁ x₂ y₁ y₂ : F} {h₁ : W.Nonsingular x₁ y₁} {h₂ : W.Nonsingular x₂ y₂}
    (hx : x₁ = x₂) (hy : y₁ = W.negY x₂ y₂) : some h₁ + some h₂ = 0
-- Mathlib/RingTheory/FiniteType.lean
/-- An element of `R[M]` is in the subalgebra generated by its support. -/
theorem mem_adjoin_support (f : R[M]) : f ∈ adjoin R (of' R M '' f.support)
-- Mathlib/FieldTheory/IntermediateField.lean
/-- An intermediate field is closed under division. -/
protected theorem div_mem {x y : L} : x ∈ S → y ∈ S → x / y ∈ S
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
/-- The reduction of the graph `G` along partition `P` has edges between `ε`-uniform pairs of parts
that have edge density at least `δ`. -/
@[simps] def regularityReduced (ε δ : 𝕜) : SimpleGraph α
-- Mathlib/NumberTheory/LSeries/HurwitzZeta.lean
lemma differentiableAt_expZeta (a : UnitAddCircle) (s : ℂ) (hs : s ≠ 1 ∨ a ≠ 0) :
    DifferentiableAt ℂ (expZeta a) s
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
@[simp]
theorem sum_right {ι : Type*} [Countable ι] {ν : ι → Measure α} : μ ⟂ₘ sum ν ↔ ∀ i, μ ⟂ₘ ν i
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
theorem bddBelow_measureOfNegatives : BddBelow s.measureOfNegatives
-- Mathlib/Topology/Algebra/Module/Cardinality.lean
/-- A complete nontrivially normed field has cardinality at least continuum. -/
theorem continuum_le_cardinal_of_nontriviallyNormedField
    (𝕜 : Type*) [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] : 𝔠 ≤ #𝕜
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive]
theorem IsLowerSet.mul_left (ht : IsLowerSet t) : IsLowerSet (s * t)
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
    x ≤ a
-- Mathlib/LinearAlgebra/Span.lean
theorem toSpanSingleton_one (x : M) : toSpanSingleton R M x 1 = x
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem pow_apply (f : G →+c[a, a] G) (n : ℕ) (x : G) : (f ^ n) x = f^[n] x
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem compl_mem_hyperfilter_of_finite {s : Set α} (hf : Set.Finite s) : sᶜ ∈ hyperfilter α
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem add_sigma (s t : Multiset α) (u : ∀ a, Multiset (σ a)) :
    (s + t).sigma u = s.sigma u + t.sigma u
-- Mathlib/Logic/Equiv/Defs.lean
protected theorem nonempty (e : α ≃ β) [Nonempty β] : Nonempty α
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma mem_orbit_of_mem_orbit_subgroup {H : Subgroup G} {a b : α} (h : a ∈ orbit H b) :
    a ∈ orbit G b
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem measurableSet_support [MeasurableSpace α] (f : α →ₛ β) : MeasurableSet (support f)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
/-- The restriction of `Proj π J` to a subset, mapping to its image. -/
@[simps!]
def ProjRestrict : C → π C J
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem _root_.ContinuousLinearEquiv.compContinuousAlternatingMap_coe
    (e : N ≃L[R] N') (f : M [⋀^ι]→L[R] N) : ⇑(e.compContinuousAlternatingMap f) = e ∘ f
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- A generalized eigenvalue for some exponent `k` is also
    a generalized eigenvalue for exponents larger than `k`. -/
theorem hasGenEigenvalue_of_hasGenEigenvalue_of_le {f : End R M} {μ : R} {k : ℕ}
    {m : ℕ} (hm : k ≤ m) (hk : f.HasGenEigenvalue μ k) :
    f.HasGenEigenvalue μ m
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem toAffineEquiv_refl : (refl 𝕜 P).toAffineEquiv = AffineEquiv.refl 𝕜 P
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem nhds_basis_eball : (𝓝 x).HasBasis (fun ε : ℝ≥0∞ => 0 < ε) (ball x)
-- Mathlib/Data/Complex/Module.lean
@[simp, norm_cast]
theorem Complex.coe_smul {E : Type*} [AddCommGroup E] [Module ℂ E] (x : ℝ) (y : E) :
    (x : ℂ) • y = x • y
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
/-- A version of `FractionalIdeal.den_mul_self_eq_num` in terms of fractional ideals. -/
theorem den_mul_self_eq_num' (I : FractionalIdeal S P) :
    spanSingleton S (algebraMap R P I.den) * I = I.num
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If `f` is `C^1` within a convex set `s` at `x`, then it is Lipschitz on a neighborhood of `x`
within `s`. -/
theorem ContDiffWithinAt.exists_lipschitzOnWith {E F : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F] {f : E → F} {s : Set E} {x : E}
    (hf : ContDiffWithinAt ℝ 1 f s x) (hs : Convex ℝ s) :
    ∃ K : ℝ≥0, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
-- Mathlib/Tactic/NormNum/BigOperators.lean
lemma Finset.univ_eq_elems {α : Type*} [Fintype α] (elems : Finset α)
    (complete : ∀ x : α, x ∈ elems) :
    Finset.univ = elems
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.le_set {f o} (H : IsNormal f) (p : Set Ordinal) (p0 : p.Nonempty) (b)
    (H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f a ≤ o
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Evaluation of continuous maps at a point, bundled as a star algebra homomorphism. -/
@[simps!]
def ContinuousMap.evalStarAlgHom [StarRing R] [ContinuousStar R] (x : X) :
    C(X, R) →⋆ₐ[S] R
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem mk_le_mk {S S' : NonUnitalSubsemiring R} (h h') :
    (⟨S, h⟩ : NonUnitalSubring R) ≤ (⟨S', h'⟩ : NonUnitalSubring R) ↔ S ≤ S'
-- Mathlib/Data/Real/Pi/Leibniz.lean
/-- **Leibniz's series for `π`**. The alternating sum of odd number reciprocals is `π / 4`,
proved by using Abel's limit theorem to extend the Maclaurin series of `arctan` to 1. -/
theorem tendsto_sum_pi_div_four :
    Tendsto (fun k => ∑ i ∈ range k, (-1 : ℝ) ^ i / (2 * i + 1)) atTop (𝓝 (π / 4))
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem map_eq_mapTR : @map = @mapTR
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem Ici_iSup (f : ι → α) : Ici (⨆ i, f i) = ⨆ i, Ici (f i)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The inner product between a multiple of a vector and a `π / 2` rotation of that vector is
zero. -/
@[simp]
theorem inner_rotation_pi_div_two_right_smul (x : V) (r : ℝ) :
    ⟪r • x, o.rotation (π / 2 : ℝ) x⟫ = 0
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
/-- The product of tensor products made of a single vector is the same as a single product of
all the vectors. -/
theorem _root_.TensorPower.list_prod_gradedMonoid_mk_single (n : ℕ) (x : Fin n → M) :
    ((List.finRange n).map fun a =>
          (GradedMonoid.mk _ (PiTensorProduct.tprod R fun _ : Fin 1 => x a) :
            GradedMonoid fun n => ⨂[R]^n M)).prod =
      GradedMonoid.mk n (PiTensorProduct.tprod R x)
-- Mathlib/Order/Grade.lean
/-- An `𝕆`-graded order where maximal elements have maximal grades. -/
class GradeMaxOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
  /-- Maximal elements have maximal grades. -/
  isMax_grade ⦃a : α⦄ : IsMax a → IsMax (grade a)
-- Mathlib/MeasureTheory/Constructions/EventuallyMeasurable.lean
theorem Measurable.eventuallyMeasurable (hf : Measurable f) : EventuallyMeasurable m l f
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem eqOn_mulIndicator : EqOn (mulIndicator s f) f s
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem continuousOn_zpow₀ (m : ℤ) : ContinuousOn (fun x : G₀ => x ^ m) {0}ᶜ
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem edist_toL1_toL1 (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    edist (hf.toL1 f) (hg.toL1 g) = ∫⁻ a, edist (f a) (g a) ∂μ
-- Mathlib/Algebra/Lie/Weights/Chain.lean
@[simp] lemma chainBot_zero : chainBot 0 β = β
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive]
lemma MulAction.IsPretransitive.of_isScalarTower (M : Type*) {N α : Type*} [Monoid N] [SMul M N]
    [MulAction N α] [SMul M α] [IsScalarTower M N α] [IsPretransitive M α] : IsPretransitive N α
-- Mathlib/Data/BitVec.lean
lemma toFin_zsmul (z : ℤ) (x : BitVec w)  : toFin (z • x) = z • x.toFin
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem foldrM_reverse [Monad m] (l : List α) (f : α → β → m β) (b) :
    l.reverse.foldrM f b = l.foldlM (fun x y => f y x) b
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem zero (v : VectorMeasure α N) : (0 : VectorMeasure α M) ≪ᵥ v
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma integrable_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν] (n : ℕ)
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Integrable (fun x ↦ densityProcess κ ν n a x s) (ν a)
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem pow_sub_lt_descFactorial' {n : ℕ} :
    ∀ {k : ℕ}, k + 2 ≤ n → (n - (k + 1)) ^ (k + 2) < n.descFactorial (k + 2)
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem WellFounded.finite_of_independent (hwf : WellFounded ((· > ·) : α → α → Prop)) {ι : Type*}
    {t : ι → α} (ht : Independent t) (h_ne_bot : ∀ i, t i ≠ ⊥) : Finite ι
-- Mathlib/Order/Basic.lean
theorem Preorder.dual_dual (α : Type*) [H : Preorder α] : OrderDual.instPreorder αᵒᵈ = H
-- Mathlib/GroupTheory/Nilpotent.lean
/-- The nilpotency class of a nilpotent `G` is equal to the length of the lower central series. -/
theorem lowerCentralSeries_length_eq_nilpotencyClass :
    Nat.find (nilpotent_iff_lowerCentralSeries.mp hG) = Group.nilpotencyClass (G := G)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ f x / r` tends to negative infinity if and only if `r < 0. `-/
lemma tendsto_div_const_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ r < 0
-- Mathlib/NumberTheory/Divisors.lean
@[to_additive (attr := simp)]
theorem prod_properDivisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α}
    (h : p.Prime) : (∏ x ∈ (p ^ k).properDivisors, f x) = ∏ x ∈ range k, f (p ^ x)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_diff_Iic : Ioc a b \ Iic c = Ioc (max a c) b
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- When a function has a limit at infinity, and its derivative is nonpositive, then the derivative
is automatically integrable on `(a, +∞)`. Version assuming differentiability
on `(a, +∞)` and continuity at `a⁺`. -/
theorem integrableOn_Ioi_deriv_of_nonpos (hcont : ContinuousWithinAt g (Ici a) a)
    (hderiv : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (g'neg : ∀ x ∈ Ioi a, g' x ≤ 0)
    (hg : Tendsto g atTop (𝓝 l)) : IntegrableOn g' (Ioi a)
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
theorem AlgHom.closure_ker_inter {F S K A : Type*} [CommRing K] [Ring A] [Algebra K A]
    [TopologicalSpace K] [T1Space K] [TopologicalSpace A] [ContinuousSub A] [ContinuousSMul K A]
    [FunLike F A K] [AlgHomClass F K A K] [SetLike S A] [OneMemClass S A] [AddSubgroupClass S A]
    [SMulMemClass S K A] (φ : F) (hφ : Continuous φ) (s : S) :
    closure (s ∩ RingHom.ker φ) = closure s ∩ (ker φ : Set A)
-- Mathlib/LinearAlgebra/AffineSpace/Ordered.lean
/-- Given `c = lineMap a b r`, `a < c < b`, the point `(c, f c)` is non-strictly above the
segment `[(a, f a), (b, f b)]` if and only if `slope f c b ≤ slope f a c`. -/
theorem lineMap_le_map_iff_slope_le_slope (hab : a < b) (h₀ : 0 < r) (h₁ : r < 1) :
    lineMap (f a) (f b) r ≤ f c ↔ slope f c b ≤ slope f a c
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem bot_toSubalgebra : (⊥ : IntermediateField F E).toSubalgebra = ⊥
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[reassoc (attr := simp)]
theorem hom_comp_ι (K₁ K₂ : Multifork I) (f : K₁ ⟶ K₂) (j : I.L) : f.hom ≫ K₂.ι j = K₁.ι j
-- Mathlib/Algebra/Algebra/Equiv.lean
theorem ofAlgHom_symm (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    (ofAlgHom f g h₁ h₂).symm = ofAlgHom g f h₂ h₁
-- Mathlib/Algebra/Quaternion.lean
@[norm_cast]
theorem coe_intCast (z : ℤ) : ↑(z : R) = (z : ℍ[R])
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem intCast_imJ (z : ℤ) : (z : ℍ[R,c₁,c₂]).imJ = 0
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem encode_sigma_val (a b) : @encode (Sigma γ) _ ⟨a, b⟩ = pair (encode a) (encode b)
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem insepDegree_self : insepDegree F F = 1
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Ioc (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioc a b = Ioc (a / c) (b / c)
-- Mathlib/Data/Multiset/Basic.lean
theorem nsmul_replicate {a : α} (n m : ℕ) : n • replicate m a = replicate (n * m) a
-- Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean
lemma exp_log (a : A) (ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x) (ha₁ : IsSelfAdjoint a := by cfc_tac) :
    NormedSpace.exp ℝ (log a) = a
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_mul [DecidableEq σ] :
    coeff R n (φ * ψ) = ∑ p ∈ antidiagonal n, coeff R p.1 φ * coeff R p.2 ψ
-- Mathlib/Data/Finset/Basic.lean
/-- Useful in proofs by induction. -/
theorem forall_of_forall_insert [DecidableEq α] {p : α → Prop} {a : α} {s : Finset α}
    (H : ∀ x, x ∈ insert a s → p x) (x) (h : x ∈ s) : p x
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodUnique_symm_apply [Unique β] (x : α) :
    (prodUnique α β).symm x = (x, default)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem ae_eq_zero_of_eLpNorm'_eq_zero {f : α → E} (hq0 : 0 ≤ q) (hf : AEStronglyMeasurable f μ)
    (h : eLpNorm' f q μ = 0) : f =ᵐ[μ] 0
-- Mathlib/Data/Finset/Lattice.lean
protected theorem disjoint_sup_right : Disjoint a (s.sup f) ↔ ∀ ⦃i⦄, i ∈ s → Disjoint a (f i)
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem AntivaryOn.subset (hst : s ⊆ t) (h : AntivaryOn f g t) : AntivaryOn f g s
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_union_eq_left_of_forall₀ {f : X → E} (ht : NullMeasurableSet t μ)
    (ht_eq : ∀ x ∈ t, f x = 0) : ∫ x in s ∪ t, f x ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem unit_smul_eq_smul (a : A) (r : Rˣ) : σ (r • a) = r • σ a
-- Mathlib/Combinatorics/Additive/ErdosGinzburgZiv.lean
/-- The **Erdős–Ginzburg–Ziv theorem** for `ℤ/nℤ` for multiset.

Any multiset of at least `2 * n - 1` elements of `ℤ` contains a submultiset of `n` elements whose
sum is divisible by `n`. -/
theorem ZMod.erdos_ginzburg_ziv_multiset (s : Multiset (ZMod n))
    (hs : 2 * n - 1 ≤ Multiset.card s) : ∃ t ≤ s, Multiset.card t = n ∧ t.sum = 0
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
@[reassoc]
lemma comp_add (f : X' ⟶ Y') (g₁ g₂ : Y' ⟶ Z') :
    f ≫ add W eY eZ g₁ g₂ = add W eX eZ (f ≫ g₁) (f ≫ g₂)
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.vecMul_injective_iff {R : Type*} [CommRing R] {M : Matrix m n R} :
    Function.Injective M.vecMul ↔ LinearIndependent R (fun i ↦ M i)
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem eq_bot_of_subsingleton [Subsingleton p] : p = ⊥
-- Mathlib/RingTheory/Perfection.lean
theorem hom_ext [PerfectRing R p] {S : Type u₂} [CommSemiring S] [CharP S p] {P : Type u₃}
    [CommSemiring P] [CharP P p] [PerfectRing P p] (π : P →+* S) (m : PerfectionMap p π)
    {f g : R →+* P} (hfg : ∀ x, π (f x) = π (g x)) : f = g
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem average_congr {f g : α → E} (h : f =ᵐ[μ] g) : ⨍ x, f x ∂μ = ⨍ x, g x ∂μ