ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Sym/Sym2.lean
theorem other_ne {a : α} {z : Sym2 α} (hd : ¬IsDiag z) (h : a ∈ z) : Mem.other h ≠ a
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_emptyCollection (α : Type u) : #(∅ : Set α) = 0
-- Mathlib/Data/List/Duplicate.lean
theorem nodup_iff_forall_not_duplicate : Nodup l ↔ ∀ x : α, ¬x ∈+ l
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
/-- Construct a pseudofunctor from a lax functor whose `mapId` and `mapComp` are isomorphisms. -/
@[simps!]
noncomputable def mkOfLax' (F : LaxFunctor B C) [∀ a, IsIso (F.mapId a)]
    [∀ {a b c} (f : a ⟶ b) (g : b ⟶ c), IsIso (F.mapComp f g)] : Pseudofunctor B C
-- Mathlib/Deprecated/Group.lean
theorem Additive.isAddGroupHom [Group α] [Group β] {f : α → β} (hf : IsGroupHom f) :
    @IsAddGroupHom (Additive α) (Additive β) _ _ f
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ediv_eq_ediv_of_mul_eq_mul {a b c d : Int}
    (H2 : d ∣ c) (H3 : b ≠ 0) (H4 : d ≠ 0) (H5 : a * d = b * c) : a / b = c / d
-- Mathlib/Data/Matroid/Restrict.lean
theorem Restriction.trans {M₁ M₂ M₃ : Matroid α} (h : M₁ ≤r M₂) (h' : M₂ ≤r M₃) : M₁ ≤r M₃
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem LinearMap.toMatrix'_algebraMap (x : R) :
    LinearMap.toMatrix' (algebraMap R (Module.End R (n → R)) x) = scalar n x
-- Mathlib/Data/Set/Subsingleton.lean
/-- `s`, coerced to a type, is a nontrivial type if and only if `s` is a nontrivial set. -/
@[simp, norm_cast]
theorem nontrivial_coe_sort {s : Set α} : Nontrivial s ↔ s.Nontrivial
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem toStepSucc.exists_root {n} {f : Polynomial (Step k n)} (hfm : f.Monic)
    (hfi : Irreducible f) : ∃ x : Step k (n + 1), f.eval₂ (toStepSucc k n) x = 0
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_sum (α : Type u) (β : Type v) : #(α ⊕ β) = lift.{v, u} #α + lift.{u, v} #β
-- Mathlib/CategoryTheory/Closed/Ideal.lean
theorem reflective_products [HasFiniteProducts C] [Reflective i] : HasFiniteProducts D
-- Mathlib/GroupTheory/SchurZassenhaus.lean
theorem isComplement'_stabilizer_of_coprime {α : H.QuotientDiff}
    (hH : Nat.Coprime (Nat.card H) H.index) : IsComplement' H (stabilizer G α)
-- Mathlib/Geometry/Euclidean/Triangle.lean
/-- **Apollonius's Theorem**. -/
theorem dist_sq_add_dist_sq_eq_two_mul_dist_midpoint_sq_add_half_dist_sq (a b c : P) :
    dist a b ^ 2 + dist a c ^ 2 = 2 * (dist a (midpoint ℝ b c) ^ 2 + (dist b c / 2) ^ 2)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma div_div_div_cancel_right (a : G₀) (hc : c ≠ 0) : a / c / (b / c) = a / b
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseRightKanExtension.hasRightKanExtension :
    HasRightKanExtension L F
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem nodup_rotate {l : List α} {n : ℕ} : Nodup (l.rotate n) ↔ Nodup l
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
theorem flip_flip :
    flipHom.trans flipHom = LinearEquiv.refl R (BilinForm R M)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Icc_subset_Icc_right (h : b₁ ≤ b₂) : Icc a b₁ ⊆ Icc a b₂
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Iic : (some : α → WithBot α) ⁻¹' Iic a = Iic a
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_smul_measure (r : ℝ≥0∞) (f : α → ℝ≥0∞) :
    (r • μ).withDensity f = r • μ.withDensity f
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
lemma Differentiable.add_iff_left (hg : Differentiable 𝕜 g) :
    Differentiable 𝕜 (fun y => f y + g y) ↔ Differentiable 𝕜 f
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
theorem aestronglyMeasurable_const {α β} {_ : MeasurableSpace α} {μ : Measure α}
    [TopologicalSpace β] {b : β} : AEStronglyMeasurable (fun _ : α => b) μ
-- Mathlib/RingTheory/Polynomial/Vieta.lean
theorem esymm_neg (s : Multiset R) (k : ℕ) : (map Neg.neg s).esymm k = (-1) ^ k * esymm s k
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalNonAssocSemiring R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem tprod_tprod (l : List δ) (μ : ∀ i, Measure (π i)) [∀ i, SigmaFinite (μ i)]
    (s : ∀ i, Set (π i)) :
    Measure.tprod l μ (Set.tprod l s) = (l.map fun i => (μ i) (s i)).prod
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem AffineEquiv.pointReflection_midpoint_left (x y : P) :
    pointReflection R (midpoint R x y) x = y
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- The functor `(F, S) ⥤ (F ⋙ G, G(S))`. -/
@[simps]
def post (F : B ⥤ C) (G : C ⥤ D) (S : C) :
    CostructuredArrow F S ⥤ CostructuredArrow (F ⋙ G) (G.obj S)
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
theorem pullback_snd_isIso_of_range_subset (H : Set.range g.base ⊆ Set.range f.base) :
    IsIso (pullback.snd f g)
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp] lemma op_braiding (X Y : C) : (β_ X Y).op = β_ (op Y) (op X)
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem coe_comp (f : C(β, γ)) (g : C(α, β)) : ⇑(comp f g) = f ∘ g
-- Mathlib/Topology/Bornology/Basic.lean
lemma Bornology.ext_iff (t t' : Bornology α) :
    t = t' ↔ @Bornology.cobounded α t = @Bornology.cobounded α t'
-- Mathlib/Order/Filter/AtTopBot.lean
/-- The function `fun x ↦ f x / r` tends to negative infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to negative infinity or `r < 0` and `f` tends to infinity. -/
lemma tendsto_div_const_atBot_iff [NeBot l] :
    Tendsto (fun x ↦ f x / r) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop
-- Mathlib/Data/Set/Function.lean
theorem invFunOn_pos (h : ∃ a ∈ s, f a = b) : invFunOn f s b ∈ s ∧ f (invFunOn f s b) = b
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem symm_refl : (Diffeomorph.refl I M n).symm = Diffeomorph.refl I M n
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem natCast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R)
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
@[simp]
theorem inv_mk {f} (hf) : (mk (abv := abv) f)⁻¹ = mk (inv f hf)
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem descFactorial_one (n : ℕ) : n.descFactorial 1 = n
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem card_cycleType_eq_zero {σ : Perm α} : Multiset.card σ.cycleType = 0 ↔ σ = 1
-- Mathlib/Topology/Algebra/Polynomial.lean
@[continuity, fun_prop]
protected theorem continuous : Continuous fun x => p.eval x
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
theorem of_toQuadraticForm' [DecidableEq n] {M : Matrix n n ℝ} (hM : M.IsSymm)
    (hMq : M.toQuadraticMap'.PosDef) : M.PosDef
-- Mathlib/Data/Stream/Init.lean
theorem mem_of_mem_even (a : α) (s : Stream' α) : a ∈ even s → a ∈ s
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem exists_contracting_iterate :
    ∃ (N : ℕ) (K : _), ContractingWith K (FunSpace.next : v.FunSpace → v.FunSpace)^[N]
-- Mathlib/CategoryTheory/Yoneda.lean
lemma yonedaEquiv_symm_map {X Y : Cᵒᵖ} (f : X ⟶ Y) {F : Cᵒᵖ ⥤ Type v₁} (t : F.obj X) :
    yonedaEquiv.symm (F.map f t) = yoneda.map f.unop ≫ yonedaEquiv.symm t
-- Mathlib/Logic/Basic.lean
theorem ite_prop_iff_or : (if P then Q else R) ↔ (P ∧ Q ∨ ¬ P ∧ R)
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
@[simp] theorem trunc_X (n) : trunc (n + 2) X = (Polynomial.X : R[X])
-- Mathlib/Init/Logic.lean
theorem ExistsUnique.unique {α : Sort u} {p : α → Prop}
    (h : ∃! x, p x) {y₁ y₂ : α} (py₁ : p y₁) (py₂ : p y₂) : y₁ = y₂
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive (attr := simp)] lemma leOnePart_inv (a : α) : a⁻¹⁻ᵐ = a⁺ᵐ
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem comp_assoc (f : CompleteLatticeHom γ δ) (g : CompleteLatticeHom β γ)
    (h : CompleteLatticeHom α β) : (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Algebra/Ring/SumsOfSquares.lean
/--
In a type `R` with an addition, a zero element and a multiplication, the property of being a sum of
squares is defined by an inductive predicate: `0 : R` is a sum of squares and if `S` is a sum of
squares, then for all `a : R`, `a * a + S` is a sum of squares in `R`.
-/
@[mk_iff]
inductive isSumSq [Add R] [Zero R] : R → Prop
  | zero                              : isSumSq 0
  | sq_add (a S : R) (pS : isSumSq S) : isSumSq (a * a + S)
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem factorization_le_factorization_mul_right {a b : ℕ} (ha : a ≠ 0) :
    b.factorization ≤ (a * b).factorization
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem le_zero_iff {n : Nat} {k : Fin (n + 1)} : k ≤ 0 ↔ k = 0
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem one_apply (i) : (1 : CauSeq β abv) i = 1
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
theorem le_jacobson_bot [IsAdicComplete I R] : I ≤ (⊥ : Ideal R).jacobson
-- Mathlib/CategoryTheory/Adjunction/Limits.lean
/-- Transport a `HasColimitsOfSize` instance across an equivalence. -/
theorem has_colimits_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfSize.{v, u} D] :
    HasColimitsOfSize.{v, u} C
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_singleton_self (a : α) : a ∈ ({a} : Multiset α)
-- Mathlib/Data/Matrix/Basic.lean
protected theorem map_sub [Sub α] [Sub β] (f : α → β) (hf : ∀ a₁ a₂, f (a₁ - a₂) = f a₁ - f a₂)
    (M N : Matrix m n α) : (M - N).map f = M.map f - N.map f
-- Mathlib/CategoryTheory/Sites/SheafOfTypes.lean
@[simps]
instance : Category (SheafOfTypes J)
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive posPart_eq_of_posPart_pos]
lemma oneLePart_of_one_lt_oneLePart (ha : 1 < a⁺ᵐ) : a⁺ᵐ = a
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
/-- The cocone for `CostructuredArrow.proj L Y ⋙ F` attached to `E : LeftExtension L F`.
The point of this cocone is `E.right.obj Y` -/
@[simps]
def coconeAt (Y : D) : Cocone (CostructuredArrow.proj L Y ⋙ F)
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem IntegrableOn.continuousOn_smul [T2Space X] [SecondCountableTopologyEither X 𝕜] {g : X → E}
    (hg : IntegrableOn g K μ) {f : X → 𝕜} (hf : ContinuousOn f K) (hK : IsCompact K) :
    IntegrableOn (fun x => f x • g x) K μ
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem mem_stepSet_iff : s ∈ M.stepSet S a ↔ ∃ t ∈ S, s ∈ M.εClosure (M.step t a)
-- Mathlib/Algebra/Module/Defs.lean
theorem neg_ne_self
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : -v ≠ v ↔ v ≠ 0
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem combo_eq_smul_add_smul (a : Int) (xs : Coeffs) (b : Int) (ys : Coeffs) :
    combo a xs b ys = (a * xs) + (b * ys)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_sum_of_pos {ι : Type*} {a : ℝ} (ha : 0 < a) (f : ι → ℝ) (s : Finset ι) :
    (a ^ ∑ x ∈ s, f x) = ∏ x ∈ s, a ^ f x
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem image : f '' quasispectrum S a = quasispectrum R a
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
/-- The restriction of scalars by a composition of ring morphisms identify to the
composition of the restriction of scalars functors. -/
@[simps! hom_app inv_app]
def restrictScalarsComp' :
    ModuleCat.restrictScalars.{v} gf ≅
      ModuleCat.restrictScalars g ⋙ ModuleCat.restrictScalars f
-- Mathlib/Order/Cover.lean
lemma transGen_wcovBy_eq_reflTransGen_covBy [PartialOrder α] :
    TransGen ((· : α) ⩿ ·) = ReflTransGen (· ⋖ ·)
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
/-- Bijection between a subsemiring `S` and `MulOpposite` of its opposite. -/
@[simps!]
def ringEquivOpMop (S : Subsemiring R) : S ≃+* (S.op)ᵐᵒᵖ
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem coe_true_iff_false  : ∀(a b : Bool), (a ↔ b = false) ↔ a = (!b)
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem quasiMeasurePreserving_inv : QuasiMeasurePreserving (Inv.inv : G → G) μ μ
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive abs_add_eq_two_nsmul_posPart]
lemma mabs_mul_eq_oneLePart_sq (a : α) : |a|ₘ * a = a⁺ᵐ ^ 2
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- When a function has a limit at infinity, and its derivative is nonnegative, then the derivative
is automatically integrable on `(a, +∞)`. Version assuming differentiability
on `(a, +∞)` and continuity at `a⁺`. -/
theorem integrableOn_Ioi_deriv_of_nonneg (hcont : ContinuousWithinAt g (Ici a) a)
    (hderiv : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (g'pos : ∀ x ∈ Ioi a, 0 ≤ g' x)
    (hg : Tendsto g atTop (𝓝 l)) : IntegrableOn g' (Ioi a)
-- Mathlib/CategoryTheory/EffectiveEpi/Basic.lean
theorem effectiveEpi_iff_effectiveEpiFamily {B X : C} (f : X ⟶ B) :
    EffectiveEpi f ↔ EffectiveEpiFamily (fun () ↦ X) (fun () ↦ f)
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem Differentiable.sqrt (hf : Differentiable ℝ f) (hs : ∀ x, f x ≠ 0) :
    Differentiable ℝ fun y => √(f y)
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isRelPrime_one_right : IsRelPrime x 1
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma strictAnti_sumCoeffsExp : StrictAnti (fun (p : ℝ) => ∑ i, a i * (b i) ^ p)
-- Mathlib/LinearAlgebra/Ray.lean
/-- The images of two vectors under an injective linear map are on the same ray if and only if the
original vectors are on the same ray. -/
theorem _root_.Function.Injective.sameRay_map_iff
    {F : Type*} [FunLike F M N] [LinearMapClass F R M N]
    {f : F} (hf : Function.Injective f) :
    SameRay R (f x) (f y) ↔ SameRay R x y
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem functorPushforward_bot (F : C ⥤ D) (X : C) : (⊥ : Sieve X).functorPushforward F = ⊥
-- Mathlib/Order/Filter/Cofinite.lean
theorem Filter.Tendsto.exists_forall_le [Nonempty α] [LinearOrder β] {f : α → β}
    (hf : Tendsto f cofinite atTop) : ∃ a₀, ∀ a, f a₀ ≤ f a
-- Mathlib/Logic/Function/FromTypes.lean
/-- The definitional equality between `0`-ary heterogeneous functions into `τ` and `τ`. -/
@[simps!]
def fromTypes_zero_equiv (p : Fin 0 → Type u) (τ : Type u) :
    FromTypes p τ ≃ τ
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem subset_iff : ∀ {x y : PSet}, mk x ⊆ mk y ↔ x ⊆ y
-- Mathlib/Topology/Order/LawsonTopology.lean
lemma lawsonClosed_iff_scottClosed_of_isLowerSet (s : Set α) (h : IsLowerSet s) :
    IsClosed[L] s ↔ IsClosed[S] s
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
theorem cyclotomic_eval_lt_add_one_pow_totient {n : ℕ} {q : ℝ} (hn' : 3 ≤ n) (hq' : 1 < q) :
    (cyclotomic n ℝ).eval q < (q + 1) ^ totient n
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
/-- A diagonal matrix is positive semidefinite iff its diagonal entries are nonnegative. -/
lemma posSemidef_diagonal_iff [DecidableEq n] {d : n → R} :
    PosSemidef (diagonal d) ↔ (∀ i : n, 0 ≤ d i)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊥) : b + a = c + a ↔ b = c
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem Finsupp.mul_sum (b : S) (s : α →₀ R) {f : α → R → S} :
    b * s.sum f = s.sum fun a c => b * f a c
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem cancel_left {f : β →+*o γ} {g₁ g₂ : α →+*o β} (hf : Injective f) :
    f.comp g₁ = f.comp g₂ ↔ g₁ = g₂
-- Mathlib/Algebra/Order/Group/Bounds.lean
theorem IsGLB.exists_between_self_add (h : IsGLB s a) (hε : 0 < ε) : ∃ b ∈ s, a ≤ b ∧ b < a + ε
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis'.eq_of_subset_indep (hI : M.Basis' I X) (hJ : M.Indep J) (hIJ : I ⊆ J)
    (hJX : J ⊆ X) : I = J
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem append_assoc (s t u : Seq α) : append (append s t) u = append s (append t u)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem RingHom.isIntegralElem.of_comp {x : T} (h : (g.comp f).IsIntegralElem x) :
    g.IsIntegralElem x
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem ball_infDist_subset_compl : ball x (infDist x s) ⊆ sᶜ
-- Mathlib/Analysis/Calculus/BumpFunction/Convolution.lean
/-- If `φ` is a normed bump function, approximate `(φ ⋆ g) x₀`
if `g` is near `g x₀` on a ball with radius `φ.rOut` around `x₀`. -/
theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)
    (hg : ∀ x ∈ ball x₀ φ.rOut, dist (g x) (g x₀) ≤ ε) :
    dist ((φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) (g x₀) ≤ ε
-- Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean
/-- The composition of a primitive additive character with an injective mooid homomorphism
is also primitive. -/
lemma IsPrimitive.compMulHom_of_isPrimitive {R'' : Type*} [CommMonoid R''] {φ : AddChar R R'}
    {f : R' →* R''} (hφ : φ.IsPrimitive) (hf : Function.Injective f) :
    (f.compAddChar φ).IsPrimitive
-- Mathlib/GroupTheory/GroupAction/Period.lean
@[to_additive]
theorem period_le_exponent (exp_pos : 0 < Monoid.exponent M) (m : M) (a : α) :
    period m a ≤ Monoid.exponent M
-- Mathlib/Algebra/Module/LocalizedModule.lean
private theorem add_smul_aux (x y : T) (p : LocalizedModule S M) :
    (x + y) • p = x • p + y • p
-- Mathlib/Data/NNReal/Basic.lean
theorem toNNReal_le_toNNReal {r p : ℝ} (h : r ≤ p) : Real.toNNReal r ≤ Real.toNNReal p
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem isNormal_iff_lt_succ_and_bsup_eq {f : Ordinal.{u} → Ordinal.{max u v}} :
    IsNormal f ↔ (∀ a, f a < f (succ a)) ∧ ∀ o, IsLimit o → (bsup.{_, v} o fun x _ => f x) = f o
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
lemma restrictScalarsComp'App_inv_apply (M : ModuleCat R₃) (x : M) :
    (restrictScalarsComp'App f g gf hgf M).inv x = x
-- Mathlib/GroupTheory/Perm/ViaEmbedding.lean
theorem viaEmbeddingHom_injective : Function.Injective (viaEmbeddingHom ι)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[norm_cast]
theorem coe_prod (s : NonUnitalSubsemiring R) (t : NonUnitalSubsemiring S) :
    (s.prod t : Set (R × S)) = (s : Set R) ×ˢ (t : Set S)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of a strictly monotone function and a monotone function is strictly monotone. -/
@[to_additive add_monotone "The sum of a strictly monotone function and a monotone function is
strictly monotone."]
theorem StrictMonoOn.mul_monotone' (hf : StrictMonoOn f s) (hg : MonotoneOn g s) :
    StrictMonoOn (fun x => f x * g x) s
-- Mathlib/Order/Category/DistLat.lean
/-- Constructs an equivalence between distributive lattices from an order isomorphism between them.
-/
@[simps]
def Iso.mk {α β : DistLat.{u}} (e : α ≃o β) : α ≅ β
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem support_mem_nhds : support f ∈ 𝓝 c
-- Mathlib/Order/GaloisConnection.lean
theorem l_sSup_u_image [CompleteLattice α] [CompleteLattice β] (gi : GaloisInsertion l u)
    (s : Set β) : l (sSup (u '' s)) = sSup s
-- Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean
@[fun_prop]
lemma continuous_inducingFn : Continuous (inducingFn 𝕜 E F)
-- Mathlib/Analysis/Convex/GaugeRescale.lean
/-- Given two convex bounded sets in a topological vector space with nonempty interiors,
there exists a homeomorphism of the ambient space
that sends the interior, the closure, and the frontier of one set
to the interior, the closure, and the frontier of the other set.

In particular, if both `s` and `t` are open set or both `s` and `t` are closed sets,
then `e` maps `s` to `t`. -/
theorem exists_homeomorph_image_eq {s t : Set E}
    (hsc : Convex ℝ s) (hsne : (interior s).Nonempty) (hsb : IsVonNBounded ℝ s)
    (hst : Convex ℝ t) (htne : (interior t).Nonempty) (htb : IsVonNBounded ℝ t) :
    ∃ e : E ≃ₜ E, e '' interior s = interior t ∧ e '' closure s = closure t ∧
      e '' frontier s = frontier t
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_left_comm : ∀ a b c : G, a * (b * c) = b * (a * c)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem nonUnitalSubsemiringClosure_toAddSubmonoid :
    M.nonUnitalSubsemiringClosure.toAddSubmonoid = AddSubmonoid.closure (M : Set R)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem eq_δ_of_mono {n : ℕ} (θ : mk n ⟶ mk (n + 1)) [Mono θ] : ∃ i : Fin (n + 2), θ = δ i
-- Mathlib/Topology/Instances/Matrix.lean
theorem Matrix.conjTranspose_tsum [StarAddMonoid R] [ContinuousStar R] [T2Space R]
    {f : X → Matrix m n R} : (∑' x, f x)ᴴ = ∑' x, (f x)ᴴ
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem volume_eq_smul_haarAddCircle :
    (volume : Measure (AddCircle T)) = ENNReal.ofReal T • (@haarAddCircle T _)
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem coe_withConstants : (S.withConstants h : Set M) = ↑S
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem dropWhile_eq_nil_iff : dropWhile p l = [] ↔ ∀ x ∈ l, p x
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
theorem map_comp {f : α → β} {g : β → γ} : map (g ∘ f) = (map g).comp (map f)
-- Mathlib/Data/Matrix/Basic.lean
theorem mul_apply' [Fintype m] [Mul α] [AddCommMonoid α] {M : Matrix l m α} {N : Matrix m n α}
    {i k} : (M * N) i k = (fun j => M i j) ⬝ᵥ fun j => N j k
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalCommSemiring R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Data/Finset/Interval.lean
/-- A function `f` from `Finset α` is antitone if and only if `f (cons a s ha) ≤ f s` for all
`s` and `a ∉ s`. -/
lemma antitone_iff_forall_cons_le : Antitone f ↔ ∀ s ⦃a⦄ ha, f (cons a s ha) ≤ f s
-- Mathlib/Data/Set/Prod.lean
theorem _root_.AntitoneOn.set_prod (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
    AntitoneOn (fun x => f x ×ˢ g x) s
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem innerContent_comap (f : G ≃ₜ G) (h : ∀ ⦃K : Compacts G⦄, μ (K.map f f.continuous) = μ K)
    (U : Opens G) : μ.innerContent (Opens.comap f.toContinuousMap U) = μ.innerContent U
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_congr (hc : c₁ = c₂) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    IsBigOWith c₁ l f₁ g₁ ↔ IsBigOWith c₂ l f₂ g₂
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem coe_codRestrict (f : F) (S : NonUnitalStarSubalgebra R B) (hf : ∀ x, f x ∈ S) (x : A) :
    ↑(NonUnitalStarAlgHom.codRestrict f S hf x) = f x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem add_mul_div_right (x y : Nat) {z : Nat} (H : 0 < z) : (x + y * z) / z = x / z + y
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive (attr := simp)]
theorem mulIndicator_of_not_mem (h : a ∉ s) (f : α → M) : mulIndicator s f a = 1
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp] lemma map_snd_prod : Measure.map Prod.snd (μ.prod ν) = (μ univ) • ν
-- Mathlib/Analysis/Convex/Exposed.lean
theorem exposedPoints_subset : A.exposedPoints 𝕜 ⊆ A
-- Mathlib/Topology/Basic.lean
theorem interior_eq_iff_isOpen : interior s = s ↔ IsOpen s
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem integral_cos : ∫ x in a..b, cos x = sin b - sin a
-- Mathlib/Order/Filter/AtTopBot.lean
theorem extraction_forall_of_eventually' {P : ℕ → ℕ → Prop} (h : ∀ n, ∃ N, ∀ k ≥ N, P n k) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P n (φ n)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
protected theorem continuous : Continuous smoothTransition
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem map_ofNat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) [n.AtLeastTwo] (x : G) :
    f (OfNat.ofNat n + x) = f x + OfNat.ofNat n • b
-- Mathlib/CategoryTheory/Limits/Presheaf.lean
lemma isLeftKanExtension_along_yoneda_iff :
    L.IsLeftKanExtension α ↔
      (IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁} L))
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] protected theorem one_mul (n : Nat) : 1 * n = n
-- Mathlib/Order/Interval/Finset/Nat.lean
@[simp]
theorem card_Ioc : (Ioc a b).card = b - a
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem refl_range {a : X} : range (Path.refl a) = {a}
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem norm_neg_period (x : ℝ) : ‖(x : AddCircle (-p))‖ = ‖(x : AddCircle p)‖
-- Mathlib/Logic/Hydra.lean
/-- A multiset is accessible under `CutExpand` if all its singleton subsets are,
  assuming `r` is irreflexive. -/
theorem acc_of_singleton [IsIrrefl α r] {s : Multiset α} (hs : ∀ a ∈ s, Acc (CutExpand r) {a}) :
    Acc (CutExpand r) s