ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem toSubsemigroup_injective :
    Function.Injective (toSubsemigroup : NonUnitalSubsemiring R → Subsemigroup R)
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, which is
the inverse functor of the Dold-Kan equivalence when `C` is an abelian
category, or more generally a pseudoabelian category. -/
@[simps!]
def Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem range_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] :
    (LinearMap.range (toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)).toAddSubgroup =
      MeasureTheory.Lp.boundedContinuousFunction E p μ
-- Mathlib/Algebra/Algebra/Opposite.lean
/-- Swap the `ᵐᵒᵖ` on an algebra hom to the opposite side. -/
@[simps!]
def opComm : (A →ₐ[R] Bᵐᵒᵖ) ≃ (Aᵐᵒᵖ →ₐ[R] B)
-- Mathlib/Tactic/CC/Lemmas.lean
theorem imp_eq_true_of_eq {a b : Prop} (h : a = b) : (a → b) = True
-- Mathlib/Order/Bounds/Basic.lean
theorem le_isGLB_iff (h : IsGLB s a) : b ≤ a ↔ b ∈ lowerBounds s
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Polarization identity: The real part of the inner product, in terms of the norm. -/
theorem re_inner_eq_norm_add_mul_self_sub_norm_sub_mul_self_div_four (x y : E) :
    re ⟪x, y⟫ = (‖x + y‖ * ‖x + y‖ - ‖x - y‖ * ‖x - y‖) / 4
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem diam_ball {r : ℝ≥0∞} : diam (ball x r) ≤ 2 * r
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- The dependent version of `MultilinearMap.domDomCongrLinearEquiv`. -/
@[simps apply symm_apply]
def domDomCongrLinearEquiv' {ι' : Type*} (σ : ι ≃ ι') :
    MultilinearMap R M₁ M₂ ≃ₗ[S] MultilinearMap R (fun i => M₁ (σ.symm i)) M₂
-- Mathlib/Order/Filter/Basic.lean
theorem mem_top_iff_forall {s : Set α} : s ∈ (⊤ : Filter α) ↔ ∀ x, x ∈ s
-- Mathlib/Tactic/Ring/Basic.lean
theorem add_pos_left {a₁ : ℕ} (a₂) (h : 0 < a₁) : 0 < a₁ + a₂
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_hom_associator (X Y Z : C) :
    (α_ X Y Z).hom.mop = (α_ (mop Z) (mop Y) (mop X)).inv
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
/-- `rpow` version of `Finset.prod_pow` for `ℝ≥0`. -/
lemma finset_prod_rpow {ι} (s : Finset ι) (f : ι → ℝ≥0) (r : ℝ) :
    (∏ i ∈ s, f i ^ r) = (∏ i ∈ s, f i) ^ r
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
lemma isRightDerivedFunctor_iff_of_iso (α' : F ⟶ L ⋙ RF') (W : MorphismProperty C)
    [L.IsLocalization W] (e : RF ≅ RF') (comm : α ≫ whiskerLeft L e.hom = α') :
    RF.IsRightDerivedFunctor α W ↔ RF'.IsRightDerivedFunctor α' W
-- Mathlib/Data/Set/Card.lean
theorem Infinite.ncard (hs : s.Infinite) : s.ncard = 0
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
theorem inv_eq_zero {a : G₀} : a⁻¹ = 0 ↔ a = 0
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem diff_ae_eq_left (h : AEDisjoint μ s t) : (s \ t : Set α) =ᵐ[μ] s
-- Mathlib/Data/Matroid/Closure.lean
lemma Indep.basis_of_subset_of_subset_closure (hI : M.Indep I) (hIX : I ⊆ X)
    (hXI : X ⊆ M.closure I) : M.Basis I X
-- Mathlib/Data/Bool/Basic.lean
theorem and_le_right : ∀ x y : Bool, (x && y) ≤ y
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem symm_symm (e : α ≃ᵐ β) : e.symm.symm = e
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_sub_const_Icc : (fun x => x - a) ⁻¹' Icc b c = Icc (b + a) (c + a)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem id_comp (f : M₁ →SL[σ₁₂] M₂) : (id R₂ M₂).comp f = f
-- Mathlib/Data/Multiset/Bind.lean
@[to_additive (attr := simp)]
theorem prod_join [CommMonoid α] {S : Multiset (Multiset α)} :
    prod (join S) = prod (map prod S)
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma IsWeaklyRegular.prototype_perm {rs : List R} (h : IsWeaklyRegular M rs)
    {rs'} (h'' : rs ~ rs') (h' : ∀ a b rs', (a :: b :: rs') <+~ rs →
      let K := torsionBy R (M ⧸ (Ideal.ofList rs' • ⊤ : Submodule R M)) b
      K = a • K → K = ⊥) : IsWeaklyRegular M rs'
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem mem_isPairSelfAdjointSubmodule (f : Module.End R M) :
    f ∈ isPairSelfAdjointSubmodule B₂ F₂ ↔ IsPairSelfAdjoint B₂ F₂ f
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
lemma homMk'_comp (f : CostructuredArrow S T) (g : Y' ⟶ f.left) (g' : Y'' ⟶ Y') :
    homMk' f (g' ≫ g) = eqToHom (by simp) ≫ homMk' (mk (S.map g ≫ f.hom)) g' ≫ homMk' f g
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp] lemma prodComm_symm [Module R₁ M₂] : (prodComm R₁ M₁ M₂).symm = prodComm R₁ M₂ M₁
-- Mathlib/Deprecated/Group.lean
@[to_additive]
theorem MulEquiv.isGroupHom {G H : Type*} {_ : Group G} {_ : Group H} (h : G ≃* H) :
    IsGroupHom h
-- Mathlib/Algebra/Field/Subfield.lean
theorem comap_map (f : K →+* L) (s : Subfield K) : (s.map f).comap f = s
-- Mathlib/Analysis/NormedSpace/Exponential.lean
@[continuity]
theorem exp_continuous : Continuous (exp 𝕂 : 𝔸 → 𝔸)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem get_cons_succ' {as : List α} {i : Fin as.length} :
  (a :: as).get i.succ = as.get i
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp, norm_cast]
theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : Germ l β)
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp)]
theorem coe_comp : ⇑(p.comp f) = p ∘ f
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_image (f : ZFSet → ZFSet) [H : Definable 1 f] (x : ZFSet) :
    (image f x).toSet = f '' x.toSet
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- A morphism in the arrow category is a commutative square connecting two objects of the arrow
    category. -/
@[simps]
def homMk {f g : Arrow T} {u : f.left ⟶ g.left} {v : f.right ⟶ g.right}
    (w : u ≫ g.hom = f.hom ≫ v) : f ⟶ g
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem outerMeasure_eq_iInf (A : Set G) :
    μ.outerMeasure A = ⨅ (U : Set G) (hU : IsOpen U) (_ : A ⊆ U), μ.innerContent ⟨U, hU⟩
-- Mathlib/Data/List/Sublists.lean
theorem sublists'_eq_sublists'Aux (l : List α) :
    sublists' l = l.foldr (fun a r => sublists'Aux a r r) [[]]
-- Mathlib/Data/Finset/Lattice.lean
theorem iSup_singleton (a : α) (s : α → β) : ⨆ x ∈ ({a} : Finset α), s x = s a
-- Mathlib/Combinatorics/Quiver/Basic.lean
/-- The identity morphism between quivers. -/
@[simps]
def id (V : Type*) [Quiver V] : Prefunctor V V
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformlyOn.congr {F' : ι → α → β} (hf : TendstoUniformlyOn F f p s)
    (hff' : ∀ᶠ n in p, Set.EqOn (F n) (F' n) s) : TendstoUniformlyOn F' f p s
-- Mathlib/Algebra/Group/Action/Sum.lean
@[to_additive (attr := simp)]
theorem smul_swap : (a • x).swap = a • x.swap
-- Mathlib/Data/List/Zip.lean
theorem getElem?_zip_eq_some (l₁ : List α) (l₂ : List β) (z : α × β) (i : ℕ) :
    (zip l₁ l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2
-- Mathlib/GroupTheory/Complement.lean
theorem isComplement'_of_card_mul_and_disjoint [Finite G]
    (h1 : Nat.card H * Nat.card K = Nat.card G) (h2 : Disjoint H K) :
    IsComplement' H K
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive] lemma leOnePart_mul_oneLePart (a : α) : a⁻ᵐ * a⁺ᵐ = |a|ₘ
-- Mathlib/Control/Bitraversable/Lemmas.lean
@[higher_order tfst_id]
theorem id_tfst : ∀ {α β} (x : t α β), tfst (F := Id) pure x = pure x
-- Mathlib/Algebra/Quaternion.lean
/-- There is a natural equivalence when swapping the coefficients of a quaternion algebra. -/
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁]
-- Mathlib/Order/LiminfLimsup.lean
theorem Monotone.isBoundedUnder_ge_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMinOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atBot atBot) :
    IsBoundedUnder (· ≥ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≥ ·) l f
-- Mathlib/Data/Num/Lemmas.lean
theorem zneg_toZNum (n : Num) : -n.toZNum = n.toZNumNeg
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
@[simp]
theorem full_univ : full Set.univ = (⊤ : Subgroupoid C)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem setOf_mem_eq {s : Set α} : { x | x ∈ s } = s
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem subgroupOf_sup (A A' B : Subgroup G) (hA : A ≤ B) (hA' : A' ≤ B) :
    (A ⊔ A').subgroupOf B = A.subgroupOf B ⊔ A'.subgroupOf B
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive]
theorem zpow_comp [Group γ] [TopologicalGroup γ] (f : C(β, γ)) (z : ℤ) (g : C(α, β)) :
    (f ^ z).comp g = f.comp g ^ z
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
@[reassoc (attr := simp)]
theorem Subpresheaf.lift_ι (f : F' ⟶ F) (hf : ∀ U x, f.app U x ∈ G.obj U) :
    G.lift f hf ≫ G.ι = f
-- Mathlib/Topology/Compactness/SigmaCompact.lean
lemma isSigmaCompact_iff_sigmaCompactSpace {s : Set X} :
    IsSigmaCompact s ↔ SigmaCompactSpace s
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gauge_of_subset_zero (h : s ⊆ 0) : gauge s = 0
-- Mathlib/RingTheory/RingHom/Surjective.lean
theorem surjective_stableUnderComposition : StableUnderComposition surjective
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- A `G`-diffeomorphism between two charted spaces is a homeomorphism which, when read in the
charts, belongs to `G`. We avoid the word diffeomorph as it is too related to the smooth category,
and use structomorph instead. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure Structomorph (G : StructureGroupoid H) (M : Type*) (M' : Type*) [TopologicalSpace M]
  [TopologicalSpace M'] [ChartedSpace H M] [ChartedSpace H M'] extends Homeomorph M M' where
  mem_groupoid : ∀ c : PartialHomeomorph M H, ∀ c' : PartialHomeomorph M' H, c ∈ atlas H M →
    c' ∈ atlas H M' → c.symm ≫ₕ toHomeomorph.toPartialHomeomorph ≫ₕ c' ∈ G
-- Mathlib/Topology/Algebra/GroupWithZero.lean
@[simp]
theorem coe_mulRight₀ (c : α) (hc : c ≠ 0) : ⇑(Homeomorph.mulRight₀ c hc) = (· * c)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Filter.Tendsto.min_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun i => min a (f i)) l (𝓝 a)
-- Mathlib/Probability/Moments.lean
theorem cgf_neg : cgf (-X) μ t = cgf X μ (-t)
-- Mathlib/Order/LiminfLimsup.lean
@[simp] theorem limsup_bot (f : β → α) : limsup f ⊥ = ⊥
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- The inverse of a `TransvectionStruct`, designed so that `t.inv.toMatrix` is the inverse of
`t.toMatrix`. -/
@[simps]
protected def inv (t : TransvectionStruct n R) : TransvectionStruct n R
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem cauchy (f : CauSeq β abv) : ∀ {ε}, 0 < ε → ∃ i, ∀ j ≥ i, abv (f j - f i) < ε
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive (attr := simp)]
theorem op_le_op_iff {S₁ S₂ : Submonoid M} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem normalizedFactors_one : normalizedFactors (1 : α) = 0
-- Mathlib/NumberTheory/Divisors.lean
theorem properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) :
    properDivisors (p ^ k) = (Finset.range k).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩
-- Mathlib/Data/DFinsupp/NeLocus.lean
theorem neLocus_eq_support_sub : f.neLocus g = (f - g).support
-- Mathlib/Data/Finset/Sups.lean
theorem sups_subset_right : s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t
-- Mathlib/Data/Fintype/BigOperators.lean
nonrec theorem Fintype.prod_dite [Fintype α] {p : α → Prop} [DecidablePred p] [CommMonoid β]
    (f : ∀ a, p a → β) (g : ∀ a, ¬p a → β) :
    (∏ a, dite (p a) (f a) (g a)) =
    (∏ a : { a // p a }, f a a.2) * ∏ a : { a // ¬p a }, g a a.2
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem castAdd_castAdd {m n p : Nat} (i : Fin m) :
    castAdd p (castAdd n i) = cast (Nat.add_assoc ..).symm (castAdd (n + p) i)
-- Mathlib/Data/Set/Basic.lean
theorem AntitoneOn.union [Preorder β] {f g : β → Set α} {s : Set β} (hf : AntitoneOn f s)
    (hg : AntitoneOn g s) : AntitoneOn (fun x => f x ∪ g x) s
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem Matrix.toBilin'Aux_eq (M : Matrix n n R₂) : Matrix.toBilin'Aux M = Matrix.toBilin' M
-- Mathlib/Data/PNat/Basic.lean
theorem add_sub_of_lt {a b : ℕ+} : a < b → a + (b - a) = b
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem sin_neg : sin (-x) = -sin x
-- Mathlib/SetTheory/Game/PGame.lean
theorem moveLeft_neg {x : PGame} (i) : (-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAntiOn.mapsTo_Iio (h : StrictAntiOn f (Iic b)) : MapsTo f (Iio b) (Ioi (f b))
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem disjoint_out' {H K : Subgroup G} {a b : Quotient H.1 K} :
    a ≠ b → Disjoint (doset a.out' H K) (doset b.out' (H : Set G) K)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[simp]
theorem addOrderOf_ofMul_eq_orderOf (x : G) : addOrderOf (Additive.ofMul x) = orderOf x
-- Mathlib/Topology/Order/Monotone.lean
theorem sInf_mem_closure {s : Set α} (hs : s.Nonempty) : sInf s ∈ closure s
-- Mathlib/Data/Set/Basic.lean
theorem inter_insert_of_mem (h : a ∈ s) : s ∩ insert a t = insert a (s ∩ t)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive IsOpen.right_addCoset]
theorem IsOpen.rightCoset {U : Set G} (h : IsOpen U) (x : G) : IsOpen (op x • U)
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma isLocallyInjective_iff_of_fac {φψ : F₁ ⟶ F₃} (fac : φ ≫ ψ = φψ) [IsLocallyInjective J ψ] :
    IsLocallyInjective J φψ ↔ IsLocallyInjective J φ
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem IsCompact.sSup_lt_iff_of_continuous [ClosedIciTopology α] {f : β → α} {K : Set β}
    (hK : IsCompact K) (h0K : K.Nonempty) (hf : ContinuousOn f K) (y : α) :
    sSup (f '' K) < y ↔ ∀ x ∈ K, f x < y
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
/-- The functor `HomologicalComplex C c ⥤ ShortComplex C` which sends a homological
complex `K` to the short complex `K.X i ⟶ K.X j ⟶ K.X k` for arbitrary indices `i`, `j` and `k`. -/
@[simps]
def shortComplexFunctor' (i j k : ι) : HomologicalComplex C c ⥤ ShortComplex C
-- Mathlib/RingTheory/Localization/Basic.lean
/-- `IsLocalization.toLocalizationWithZeroMap M S` shows `S` is the monoid localization of
`R` at `M`. -/
@[simps]
def toLocalizationWithZeroMap : Submonoid.LocalizationWithZeroMap M S
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_mul' (h : leadingCoeff p * leadingCoeff q ≠ 0) :
    natDegree (p * q) = natDegree p + natDegree q
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem length_append (s t : String) : (s ++ t).length = s.length + t.length
-- Mathlib/MeasureTheory/Group/Action.lean
@[to_additive (attr := simp)]
theorem measurePreserving_smul : MeasurePreserving (c • ·) μ μ
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem polar_zero_right (y : M) : polar Q y 0 = 0
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- The function `x ^ (1 / x)` tends to `1` at `+∞`. -/
theorem tendsto_rpow_div : Tendsto (fun x => x ^ ((1 : ℝ) / x)) atTop (𝓝 1)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem getLast?_nil : @getLast? α [] = none
-- Mathlib/Algebra/Ring/Commute.lean
theorem commute_iff_lie_eq {x y : R} : Commute x y ↔ ⁅x, y⁆ = 0
-- Mathlib/Data/Vector/Basic.lean
theorem ne_cons_iff (a : α) (v : Vector α n.succ) (v' : Vector α n) :
    v ≠ a ::ᵥ v' ↔ v.head ≠ a ∨ v.tail ≠ v'
-- Mathlib/NumberTheory/ZetaValues.lean
theorem hasSum_zeta_two : HasSum (fun n : ℕ => (1 : ℝ) / (n : ℝ) ^ 2) (π ^ 2 / 6)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
/-- For every prime `p` dividing the order of a finite group `G` there exists an element of order
`p` in `G`. This is known as Cauchy's theorem. -/
theorem _root_.exists_prime_orderOf_dvd_card {G : Type*} [Group G] [Fintype G] (p : ℕ)
    [hp : Fact p.Prime] (hdvd : p ∣ Fintype.card G) : ∃ x : G, orderOf x = p
-- Mathlib/Order/Heyting/Basic.lean
theorem sup_sdiff_cancel_right (h : a ≤ b) : a ⊔ b \ a = b
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem IicSnd_apply (r : ℝ) {s : Set α} (hs : MeasurableSet s) :
    ρ.IicSnd r s = ρ (s ×ˢ Iic r)
-- Mathlib/CategoryTheory/Opposites.lean
/-- Given a natural transformation `α : F ⟶ G`, for `F G : C ⥤ Dᵒᵖ`,
taking `unop` of each component gives a natural transformation `G.leftOp ⟶ F.leftOp`.
-/
@[simps]
protected def leftOp (α : F ⟶ G) : G.leftOp ⟶ F.leftOp
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
/-- Out of three elements of a `LinearOrderedRing`, two must have the same sign. -/
theorem mul_nonneg_of_three [ExistsAddOfLE α] [MulPosStrictMono α] [PosMulStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
    (a b c : α) : 0 ≤ a * b ∨ 0 ≤ b * c ∨ 0 ≤ c * a
-- Mathlib/Data/Set/Pointwise/Basic.lean
theorem div_zero_subset (s : Set α) : s / 0 ⊆ 0
-- Mathlib/Data/Rat/Lemmas.lean
theorem num_den_mk {q : ℚ} {n d : ℤ} (hd : d ≠ 0) (qdf : q = n /. d) :
    ∃ c : ℤ, n = c * q.num ∧ d = c * q.den
-- Mathlib/Algebra/Ring/CompTypeclasses.lean
theorem comp_apply_eq {x : R₁} : σ' (σ x) = x
-- Mathlib/Data/Finsupp/WellFounded.lean
theorem Lex.wellFounded_of_finite [IsStrictTotalOrder α r] [Finite α]
    (hs : WellFounded s) : WellFounded (Finsupp.Lex r s)
-- Mathlib/FieldTheory/Fixed.lean
@[simp]
theorem smul_polynomial (m : M) (p : Polynomial (FixedPoints.subfield M F)) : m • p = p
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem hasFDerivAt_apply (i : ι) (f : ∀ i, F' i) :
    HasFDerivAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) (proj i) f
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem map_none' (f : α → β) : none.map f = none
-- Mathlib/FieldTheory/PurelyInseparable.lean
theorem IsPurelyInseparable.natSepDegree_eq_one [IsPurelyInseparable F E] (x : E) :
    (minpoly F x).natSepDegree = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem DifferentiableOn.sinh (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.sinh (f x)) s
-- Mathlib/RingTheory/LocalProperties.lean
theorem finite_ofLocalizationSpan : RingHom.OfLocalizationSpan @RingHom.Finite
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem zeta_mul_pow_eq_sigma {k : ℕ} : ζ * pow k = σ k
-- Mathlib/Analysis/Complex/Basic.lean
theorem edist_of_im_eq {z w : ℂ} (h : z.im = w.im) : edist z w = edist z.re w.re
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem intervalIntegrable_iff_integrableOn_Icc_of_le {f : ℝ → E} {a b : ℝ} (hab : a ≤ b)
    {μ : Measure ℝ} [NoAtoms μ] : IntervalIntegrable f μ a b ↔ IntegrableOn f (Icc a b) μ
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
@[elab_as_elim]
theorem GCD.induction {P : R → R → Prop} (a b : R) (H0 : ∀ x, P 0 x)
    (H1 : ∀ a b, a ≠ 0 → P (b % a) a → P a b) : P a b
-- Mathlib/Order/Partition/Finpartition.lean
lemma exists_enumeration : ∃ f : s ≃ Σ t : P.parts, Fin t.1.card,
    ∀ a b : s, P.part a = P.part b ↔ (f a).1 = (f b).1
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem coordChange_apply (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
    (he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    a.coordChange he he' b v = (e' ⟨b, e.symm b v⟩).2
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem nndist_le_distortion_mul (I : Box ι) (i : ι) :
    nndist I.lower I.upper ≤ I.distortion * nndist (I.lower i) (I.upper i)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mapMatrix_comp (f : β →+* γ) (g : α →+* β) :
    f.mapMatrix.comp g.mapMatrix = ((f.comp g).mapMatrix : Matrix m m α →+* _)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma preNormEDS_even (m : ℕ) : preNormEDS b c d (2 * (m + 3)) =
    preNormEDS b c d (m + 2) ^ 2 * preNormEDS b c d (m + 3) * preNormEDS b c d (m + 5) -
      preNormEDS b c d (m + 1) * preNormEDS b c d (m + 3) * preNormEDS b c d (m + 4) ^ 2
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma upperSet_le_upper {t₁ t₂ : TopologicalSpace α} [@Topology.IsUpperSet α t₁ _]
    [@Topology.IsUpper α t₂ _] : t₁ ≤ t₂
-- Mathlib/LinearAlgebra/Basis.lean
theorem repr_self_apply (j) [Decidable (i = j)] : b.repr (b i) j = if i = j then 1 else 0
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- If `R → A → B` is an algebra tower with `A → B` injective,
then if the entire tower is an integral extension so is `R → A` -/
theorem IsIntegral.tower_bot (H : Function.Injective (algebraMap A B)) {x : A}
    (h : IsIntegral R (algebraMap A B x)) : IsIntegral R x
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
/-- Given a family of `n` linearly independent vectors in a space of dimension `> n`, one may extend
the family by another vector while retaining linear independence. -/
theorem exists_linearIndependent_snoc_of_lt_rank [StrongRankCondition R] {n : ℕ} {v : Fin n → M}
    (hv : LinearIndependent R v) (h : n < Module.rank R M) :
    ∃ (x : M), LinearIndependent R (Fin.snoc v x)
-- .lake/packages/batteries/Batteries/Logic.lean
theorem ne_of_mem_of_not_mem' (h : a ∈ s) : a ∉ t → s ≠ t
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem prod_set :
    ∀ (L : List M) (n : ℕ) (a : M),
      (L.set n a).prod =
        ((L.take n).prod * if n < L.length then a else 1) * (L.drop (n + 1)).prod
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- The functor `(S, F) ⥤ (G(S), F ⋙ G)`. -/
@[simps]
def post (S : C) (F : B ⥤ C) (G : C ⥤ D) :
    StructuredArrow S F ⥤ StructuredArrow (G.obj S) (F ⋙ G)
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem ord_compl_dvd_ord_compl_iff_dvd (a b : ℕ) :
    (∀ p : ℕ, ord_compl[p] a ∣ ord_compl[p] b) ↔ a ∣ b
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
    cycleOf f x ∈ cycleFactorsFinset f ↔ x ∈ f.support
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
@[simp]
theorem toLin_toMatrix [Finite ι] [Fintype ι'] [DecidableEq ι'] (v : Basis ι' R M) :
    Matrix.toLin v e (e.toMatrix v) = LinearMap.id
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem wbtw_zero_one_iff {x : R} : Wbtw R 0 x 1 ↔ x ∈ Set.Icc (0 : R) 1
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
theorem toFun_eq_coe (p : MulRingNorm R) : p.toFun = p
-- Mathlib/Algebra/Order/Monoid/Defs.lean
@[to_additive (attr := simp)]
theorem mul_self_lt_one_iff : a * a < 1 ↔ a < 1
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
/-- The clifford algebras over `CliffordAlgebraComplex.Q` is isomorphic as an `ℝ`-algebra to `ℂ`. -/
@[simps!]
protected def equiv : CliffordAlgebra Q ≃ₐ[ℝ] ℂ
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem ndinter_subset_right (s t : Multiset α) : ndinter s t ⊆ t
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem ne_zero_of_not_supDegree_le {b : B} (h : ¬ p.supDegree D ≤ b) : p ≠ 0
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem bot_eq_one : (⊥ : α) = 1
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem coe_toSubalgebra : (S.toSubalgebra : Set L) = S
-- Mathlib/Data/Finset/Sum.lean
@[simp]
theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem Measurable.const_smul (hg : Measurable g) (c : M) : Measurable (c • g)
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem min_zero (a) : min a 0 = 0
-- Mathlib/Algebra/Polynomial/BigOperators.lean
/-- The degree of a product of polynomials is equal to
the sum of the degrees, where the degree of the zero polynomial is ⊥.
-/
theorem degree_multiset_prod [Nontrivial R] : t.prod.degree = (t.map fun f => degree f).sum
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
protected theorem one_mul : (1 : MvPowerSeries σ R) * φ = φ
-- Mathlib/Topology/Instances/NNReal.lean
theorem summable_comp_injective {β : Type*} {f : α → ℝ≥0} (hf : Summable f) {i : β → α}
    (hi : Function.Injective i) : Summable (f ∘ i)
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem index_iInf_ne_zero {ι : Type*} [Finite ι] {f : ι → Subgroup G}
    (hf : ∀ i, (f i).index ≠ 0) : (⨅ i, f i).index ≠ 0