ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
protected lemma hasCompactSupport (f : C_c(α, β)) : HasCompactSupport f
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- Given a continuous `R`-multilinear map `f` taking values in `R`, `f.smulRight z` is the
continuous multilinear map sending `m` to `f m • z`. -/
@[simps! toMultilinearMap apply]
def smulRight : ContinuousMultilinearMap R M₁ M₂
-- Mathlib/MeasureTheory/Group/Prod.lean
/-- The map `(x, y) ↦ (y, xy)` sends the measure `μ × ν` to `ν × μ`. -/
@[to_additive measurePreserving_prod_add_swap_right
" The map `(x, y) ↦ (y, x + y)` sends the measure `μ × ν` to `ν × μ`. "]
theorem measurePreserving_prod_mul_swap_right [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.1 * z.2)) (μ.prod ν) (ν.prod μ)
-- Mathlib/RingTheory/Artinian.lean
theorem isArtinian_of_injective (f : M →ₗ[R] P) (h : Function.Injective f) [IsArtinian R P] :
    IsArtinian R M
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
/-- If the multiplicative action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`. -/
@[to_additive "If the additive action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`."]
theorem fixedBy_eq_univ_iff_eq_one {m : M} : fixedBy α m = Set.univ ↔ m = 1
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_top (N : Submodule R M) : (⊤ : Submodule R N).FG ↔ N.FG
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
lemma mappingCone_triangleh_distinguished {X Y : CochainComplex C ℤ} (f : X ⟶ Y) :
    CochainComplex.mappingCone.triangleh f ∈ distTriang (HomotopyCategory _ _)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- The composition of a continuous function of two variables and two ae strongly measurable
functions is ae strongly measurable. -/
theorem _root_.Continuous.comp_aestronglyMeasurable₂
    {β' : Type*} [TopologicalSpace β']
    {g : β → β' → γ} {f : α → β} {f' : α → β'} (hg : Continuous g.uncurry)
    (hf : AEStronglyMeasurable f μ) (h'f : AEStronglyMeasurable f' μ) :
    AEStronglyMeasurable (fun x => g (f x) (f' x)) μ
-- Mathlib/Data/List/Infix.lean
theorem inits_reverse (l : List α) : inits (reverse l) = reverse (map reverse l.tails)
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
protected theorem uniformInducing (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    UniformInducing f
-- Mathlib/MeasureTheory/Group/Integral.lean
@[to_additive]
theorem integral_inv_eq_self (f : G → E) (μ : Measure G) [IsInvInvariant μ] :
    ∫ x, f x⁻¹ ∂μ = ∫ x, f x ∂μ
-- Mathlib/GroupTheory/Finiteness.lean
@[to_additive]
theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps, norm_cast]
theorem ofReal_neg (r : ℝ) : ((-r : ℝ) : K) = -r
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem mem_eraseNone {s : Finset (Option α)} {x : α} : x ∈ eraseNone s ↔ some x ∈ s
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem coordChange_coordChange (e₁ e₂ e₃ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) (x : F) :
    e₂.coordChange e₃ b (e₁.coordChange e₂ b x) = e₁.coordChange e₃ b x
-- Mathlib/Algebra/Polynomial/GroupRingAction.lean
theorem prodXSubSMul.monic (x : R) : (prodXSubSMul G R x).Monic
-- Mathlib/Order/Bounds/Basic.lean
theorem lowerBounds_mono_set ⦃s t : Set α⦄ (hst : s ⊆ t) : lowerBounds t ⊆ lowerBounds s
-- Mathlib/Order/Max.lean
protected theorem IsMin.eq_of_ge (ha : IsMin a) (h : b ≤ a) : a = b
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- To construct a morphism of costructured arrows,
we need a morphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def homMk {f f' : CostructuredArrow S T} (g : f.left ⟶ f'.left)
    (w : S.map g ≫ f'.hom = f.hom := by aesop_cat) : f ⟶ f'
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem union_mul_inter_subset : (s ∪ t) * (s ∩ t) ⊆ s * t
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
/-- If `s` is a finite subset of `I`, then the good products span. -/
theorem GoodProducts.spanFin : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (· ∈ s))))
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
/-- Constructor for sections of a presheaf of modules. -/
@[simps]
def sectionsMk {M : PresheafOfModules.{v} R} (s : ∀ X, M.obj X)
    (hs : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), M.map f (s X) = s Y) : M.sections
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem length_le : c.length ≤ n
-- Mathlib/Geometry/Euclidean/Angle/Sphere.lean
/-- Angle at center of a circle equals twice angle at circumference, oriented vector angle
form with radius specified. -/
theorem oangle_eq_two_zsmul_oangle_sub_of_norm_eq_real {x y z : V} (hxyne : x ≠ y) (hxzne : x ≠ z)
    {r : ℝ} (hx : ‖x‖ = r) (hy : ‖y‖ = r) (hz : ‖z‖ = r) :
    o.oangle y z = (2 : ℤ) • o.oangle (y - x) (z - x)
-- Mathlib/Combinatorics/HalesJewett.lean
@[simp]
theorem diagonal_apply {α ι} [Nonempty ι] (x : α) : Line.diagonal α ι x = fun _ => x
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.to_subtype_range' {ι} {f : ι → M} (hf : LinearIndependent R f) {t}
    (ht : range f = t) : LinearIndependent R ((↑) : t → M)
-- Mathlib/GroupTheory/Exponent.lean
/-- The exponent of finite product of monoids is the `Finset.lcm` of the exponents of the
constituent monoids. -/
@[to_additive "The exponent of finite product of additive monoids is the `Finset.lcm` of the
exponents of the constituent additive monoids."]
theorem Monoid.exponent_pi {ι : Type*} [Fintype ι] {M : ι → Type*} [∀ i, Monoid (M i)] :
    exponent ((i : ι) → M i) = lcm univ (exponent <| M ·)
-- Mathlib/LinearAlgebra/Finsupp.lean
/-- Given `Finite α`, `linearEquivFunOnFinite R` is the natural `R`-linear equivalence between
`α →₀ β` and `α → β`. -/
@[simps apply]
noncomputable def linearEquivFunOnFinite : (α →₀ M) ≃ₗ[R] α → M
-- Mathlib/Algebra/Homology/ShortComplex/ConcreteCategory.lean
lemma Preadditive.epi_iff_surjective {X Y : C} (f : X ⟶ Y) :
    Epi f ↔ Function.Surjective ((forget₂ C Ab).map f)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem add_mul_right_right_iff : IsRelPrime x (y + z * x) ↔ IsRelPrime x y
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem descPochhammer_succ_right (n : ℕ) :
    descPochhammer R (n + 1) = descPochhammer R n * (X - (n : R[X]))
-- Mathlib/Data/Num/Lemmas.lean
lemma toNat_injective : Injective (castNum : Num → ℕ)
-- Mathlib/Analysis/Normed/Module/Ray.lean
theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem coe_copy (S : StarSubalgebra R A) (s : Set A) (hs : s = ↑S) : (S.copy s hs : Set A) = s
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
private lemma natDegree_coeff_ΨSq_ofNat (n : ℕ) :
    (W.ΨSq n).natDegree ≤ n ^ 2 - 1 ∧ (W.ΨSq n).coeff (n ^ 2 - 1) = (n ^ 2 : ℤ)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem get_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
    get ⟨c :: cs⟩ (i + c) = get ⟨cs⟩ i
-- Mathlib/GroupTheory/Divisible.lean
@[to_additive smul_right_surj_of_divisibleBy]
theorem pow_left_surj_of_rootableBy [RootableBy A α] {n : α} (hn : n ≠ 0) :
    Function.Surjective (fun a => a ^ n : A → A)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Filter.tendsto_nhds_max_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝[>] a)) :
    Tendsto (fun i => max a (f i)) l (𝓝[>] a)
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem span_univ : lieSpan R L (Set.univ : Set L) = ⊤
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.basis_subset (hI : M.Basis I X) (hIY : I ⊆ Y) (hYX : Y ⊆ X) : M.Basis I Y
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_succ_right_eq (n k : ℕ) : choose n (k + 1) * (k + 1) = choose n k * (n - k)
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
@[simp]
theorem colimitPresheafObjIsoComponentwiseLimit_hom_π (F : J ⥤ PresheafedSpace.{_, _, v} C)
    (U : Opens (Limits.colimit F).carrier) (j : J) :
    (colimitPresheafObjIsoComponentwiseLimit F U).hom ≫ limit.π _ (op j) =
      (colimit.ι F j).c.app (op U)
-- Mathlib/Data/Nat/Multiplicity.lean
theorem dvd_choose_pow (hp : Prime p) (hk : k ≠ 0) (hkp : k ≠ p ^ n) : p ∣ (p ^ n).choose k
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
lemma Pi.map_comp_map' {f g : α → C} {h : β → C} [HasProduct f] [HasProduct g] [HasProduct h]
    (p : β → α) (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (b : β), g (p b) ⟶ h b) :
    Pi.map q ≫ Pi.map' p q' = Pi.map' p (fun b => q (p b) ≫ q' b)
-- Mathlib/Algebra/Algebra/Operations.lean
theorem map_op_pow (n : ℕ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M ^ n) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M ^ n
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_add_cos : cos x + cos y = 2 * cos ((x + y) / 2) * cos ((x - y) / 2)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
/-- In a `GroupWithZero` `α`, the unit group `αˣ` is equivalent to the subtype of nonzero
elements. -/
@[simps] def unitsEquivNeZero [GroupWithZero α] : αˣ ≃ {a : α // a ≠ 0}
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_le_floor_add_one (a : α) : ⌈a⌉ ≤ ⌊a⌋ + 1
-- Mathlib/Algebra/Group/Units.lean
@[to_additive IsAddUnit.exists_neg']
lemma IsUnit.exists_left_inv {a : M} (h : IsUnit a) : ∃ b, b * a = 1
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_disjoint_iff {f : α → M} {s : Set α} :
    Disjoint (mulSupport f) s ↔ EqOn f 1 s
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, local version for any measure.

Let filters `l` and `l'` be related by `[intervalIntegral.FTCFilter a l l']`; let `μ` be a locally
finite measure.  If `f` has a finite limit `c` at `l' ⊓ ae μ`, then
`∫ x in u..v, f x ∂μ = -μ (Set.Ioc v u) • c + o(μ(Set.Ioc v u))` as both `u` and `v` tend to `l`.

See also `measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_ge'` for a version that also works,
e.g., for `l = l' = Filter.atTop`. -/
theorem measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_ge
    (hfm : StronglyMeasurableAtFilter f l' μ) (hf : Tendsto f (l' ⊓ ae μ) (𝓝 c))
    (hu : Tendsto u lt l) (hv : Tendsto v lt l) (huv : v ≤ᶠ[lt] u) :
    (fun t => (∫ x in u t..v t, f x ∂μ) + (μ (Ioc (v t) (u t))).toReal • c) =o[lt] fun t =>
      (μ <| Ioc (v t) (u t)).toReal
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/-- Shows that the `n`th denominator is greater than or equal to the `n + 1`th fibonacci number,
that is `Nat.fib (n + 1) ≤ Bₙ`. -/
theorem succ_nth_fib_le_of_nth_den (hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)) :
    (fib (n + 1) : K) ≤ (of v).dens n
-- Mathlib/Data/List/Iterate.lean
theorem iterate_add (f : α → α) (a : α) (m n : ℕ) :
    iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mex_not_mem_range {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ∉ Set.range f
-- Mathlib/Topology/Category/Profinite/EffectiveEpi.lean
theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Profinite.{u}}
    (X : α → Profinite.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ]
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
theorem HD_below_aux2 {f : Cb X Y} (C : ℝ) {y : Y} :
    BddBelow (range fun x : X => f (inl x, inr y) + C)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma ofHom_homOf_eq_self (z : Cocycle F G 0) : ofHom (homOf z) = z
-- Mathlib/Data/Nat/Nth.lean
theorem range_nth_subset : Set.range (nth p) ⊆ insert 0 (setOf p)
-- Mathlib/Data/List/EditDistance/Bounds.lean
theorem le_suffixLevenshtein_cons_minimum (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ (suffixLevenshtein C xs (y :: ys)).1.minimum
-- Mathlib/CategoryTheory/Opposites.lean
/-- The double opposite category is equivalent to the original. -/
@[simps]
def opOpEquivalence : Cᵒᵖᵒᵖ ≌ C
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
/-- Over the ring `ZMod (p^(n+1))`, we produce the `n+1`st Witt polynomial
by expanding the `n`th Witt polynomial by `p`. -/
@[simp]
theorem wittPolynomial_zmod_self (n : ℕ) :
    W_ (ZMod (p ^ (n + 1))) (n + 1) = expand p (W_ (ZMod (p ^ (n + 1))) n)
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem cycleRange_self {n : ℕ} (i : Fin n.succ) : cycleRange i i = 0
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem toList_replace [BEq α] (a : α) (b : β) (l : AssocList α β) :
    (replace a b l).toList =
    l.toList.replaceF (bif ·.1 == a then some (a, b) else none)
-- Mathlib/Order/FixedPoints.lean
theorem map_le_lfp {a : α} (ha : a ≤ lfp f) : f a ≤ lfp f
-- Mathlib/Topology/Order/LeftRightNhds.lean
/-- The following statements are equivalent:

0. `s` is a neighborhood of `b` within `(-∞, b)`
1. `s` is a neighborhood of `b` within `[a, b)`
2. `s` is a neighborhood of `b` within `(a, b)`
3. `s` includes `(l, b)` for some `l ∈ [a, b)`
4. `s` includes `(l, b)` for some `l < b` -/
theorem TFAE_mem_nhdsWithin_Iio {a b : α} (h : a < b) (s : Set α) :
    TFAE [s ∈ 𝓝[<] b,-- 0 : `s` is a neighborhood of `b` within `(-∞, b)`
        s ∈ 𝓝[Ico a b] b,-- 1 : `s` is a neighborhood of `b` within `[a, b)`
        s ∈ 𝓝[Ioo a b] b,-- 2 : `s` is a neighborhood of `b` within `(a, b)`
        ∃ l ∈ Ico a b, Ioo l b ⊆ s,-- 3 : `s` includes `(l, b)` for some `l ∈ [a, b)`
        ∃ l ∈ Iio b, Ioo l b ⊆ s]
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
@[simp]
lemma decompose_algebraMap (r : R) :
    decompose 𝒜 (algebraMap R A r) = algebraMap R (⨁ i, 𝒜 i) r
-- Mathlib/Algebra/Order/Ring/Rat.lean
theorem ofScientific_nonneg (m : ℕ) (s : Bool) (e : ℕ) :
    0 ≤ Rat.ofScientific m s e
-- Mathlib/Algebra/Ring/Defs.lean
@[simp]
theorem neg_mul (a b : α) : -a * b = -(a * b)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem vanishingIdeal_singleton (x : ProjectiveSpectrum 𝒜) :
    vanishingIdeal ({x} : Set (ProjectiveSpectrum 𝒜)) = x.asHomogeneousIdeal
-- Mathlib/Algebra/Group/Hom/Instances.lean
@[to_additive (attr := simp)]
theorem compl₂_apply [MulOneClass M] [MulOneClass N] [CommMonoid P] [MulOneClass Q]
    (f : M →* N →* P) (g : Q →* N) (m : M) (q : Q) : (compl₂ f g) m q = f m (g q)
-- Mathlib/Order/SuccPred/Basic.lean
theorem Ioc_pred_right_of_not_isMin (ha : ¬IsMin b) : Ioc a (pred b) = Ioo a b
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_nnnorm_eq_of_L2 (x : WithLp 2 (α × β)) :
    ‖x‖₊ = NNReal.sqrt (‖x.fst‖₊ ^ 2 + ‖x.snd‖₊ ^ 2)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mul_subset_iff : s * t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x * y ∈ u
-- Mathlib/FieldTheory/Fixed.lean
theorem finrank_le_card [Fintype G] : finrank (subfield G F) F ≤ Fintype.card G
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp, reassoc]
theorem limitIsoLimitCurryCompLim_inv_π {j} {k} :
    (limitIsoLimitCurryCompLim G).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _)
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem nthRoots_nodup {ζ : R} {n : ℕ} (h : IsPrimitiveRoot ζ n) {a : R} (ha : a ≠ 0) :
    (nthRoots n a).Nodup
-- Mathlib/CategoryTheory/Functor/Const.lean
/-- The functor sending `X : C` to the constant functor `J ⥤ C` sending everything to `X`.
-/
@[simps]
def const : C ⥤ J ⥤ C
-- Mathlib/Order/Atoms.lean
@[simp] lemma isAtom_compl : IsAtom aᶜ ↔ IsCoatom a
-- Mathlib/Probability/Density.lean
theorem _root_.Real.hasPDF_iff : HasPDF X ℙ ↔ AEMeasurable X ℙ ∧ map X ℙ ≪ volume
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The isomorphism of short complexes `S.map F ≅ S.map G` induced by
a natural isomorphism `F ≅ G`. -/
@[simps]
def mapNatIso {F G : C ⥤ D} [F.PreservesZeroMorphisms] [G.PreservesZeroMorphisms] (τ : F ≅ G) :
    S.map F ≅ S.map G
-- Mathlib/Topology/Algebra/Algebra.lean
theorem id_apply (x : A) : ContinuousAlgHom.id R A x = x
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- `c.toUnder` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cone.mapConeToUnder {F : J ⥤ C} (c : Cone F) : (Under.forget c.pt).mapCone c.toUnder ≅ c
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.homogeneousCore_eq_sSup :
    I.homogeneousCore 𝒜 = sSup { J : HomogeneousIdeal 𝒜 | J.toIdeal ≤ I }
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
lemma IsInvertedBy.iff_map_le_isomorphisms (W : MorphismProperty C) (F : C ⥤ D) :
    W.IsInvertedBy F ↔ W.map F ≤ isomorphisms D
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem isoWhiskerRight_inv {G H : C ⥤ D} (α : G ≅ H) (F : D ⥤ E) :
    (isoWhiskerRight α F).inv = whiskerRight α.inv F
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem List.untrop_prod [AddMonoid R] (l : List (Tropical R)) :
    untrop l.prod = List.sum (l.map untrop)
-- Mathlib/Data/Nat/Dist.lean
theorem dist.triangle_inequality (n m k : ℕ) : dist n k ≤ dist n m + dist m k
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_preimage_of_injective_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
    (h : Injective f) : lift.{v} #(f ⁻¹' s) ≤ lift.{u} #s
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_C (r : R) : eraseLead (C r) = 0
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem attach_eq_empty_iff {s : Finset α} : s.attach = ∅ ↔ s = ∅
-- Mathlib/LinearAlgebra/CrossProduct.lean
@[simp]
theorem cross_self (v : Fin 3 → R) : v ×₃ v = 0
-- Mathlib/Topology/Instances/AddCircle.lean
theorem coe_zsmul {n : ℤ} {x : 𝕜} : (↑(n • x) : AddCircle p) = n • (x : AddCircle p)
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- See also the strictly more general `initial_of_initial_comp` below. -/
theorem initial_of_equivalence_comp [IsEquivalence F] [Initial (F ⋙ G)] : Initial G
-- Mathlib/Data/Vector/Defs.lean
/-- Vector is determined by the underlying list. -/
protected theorem eq {n : ℕ} : ∀ a1 a2 : Vector α n, toList a1 = toList a2 → a1 = a2
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability]
theorem measurable_ofReal : Measurable ENNReal.ofReal
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
/-- Expressing `HasFDerivWithinAt f f' s x` in terms of `HasDerivWithinAt` -/
theorem hasFDerivWithinAt_iff_hasDerivWithinAt {f' : 𝕜 →L[𝕜] F} :
    HasFDerivWithinAt f f' s x ↔ HasDerivWithinAt f (f' 1) s x
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem closedBall_one_mul_singleton : closedBall 1 δ * {x} = closedBall x δ
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem length_take_le (n) (l : List α) : length (take n l) ≤ n
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem emptySum_apply_inr [IsEmpty α] (b : β) : emptySum α β (Sum.inr b) = b
-- Mathlib/Data/Multiset/FinsetOps.lean
@[simp]
theorem disjoint_ndinsert_left {a : α} {s t : Multiset α} :
    Disjoint (ndinsert a s) t ↔ a ∉ t ∧ Disjoint s t
-- Mathlib/CategoryTheory/Idempotents/KaroubiKaroubi.lean
@[reassoc]
lemma p_comm_f {P Q : Karoubi (Karoubi C)} (f : P ⟶ Q) : P.p.f ≫ f.f.f = f.f.f ≫ Q.p.f
-- Mathlib/LinearAlgebra/LinearPMap.lean
private theorem sSup_aux (c : Set (E →ₗ.[R] F)) (hc : DirectedOn (· ≤ ·) c) :
    ∃ f : ↥(sSup (domain '' c)) →ₗ[R] F, (⟨_, f⟩ : E →ₗ.[R] F) ∈ upperBounds c
-- Mathlib/Data/List/Cycle.lean
theorem next_cons_concat (y : α) (hy : x ≠ y) (hx : x ∉ l)
    (h : x ∈ y :: l ++ [x] := mem_append_right _ (mem_singleton_self x)) :
    next (y :: l ++ [x]) x h = y
-- Mathlib/Data/Nat/PrimeFin.lean
@[simp] lemma mem_primeFactors : p ∈ n.primeFactors ↔ p.Prime ∧ p ∣ n ∧ n ≠ 0
-- Mathlib/RingTheory/Localization/FractionRing.lean
protected theorem injective : Function.Injective (algebraMap R K)
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma mem_mk' (carrier : Set R)
    (zero_mem : 0 ∈ carrier)
    (add_mem : ∀ {x y}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier)
    (neg_mem : ∀ {x}, x ∈ carrier → -x ∈ carrier)
    (mul_mem_left : ∀ {x y}, y ∈ carrier → x * y ∈ carrier)
    (mul_mem_right : ∀ {x y}, x ∈ carrier → x * y ∈ carrier)
    (x : R) :
    x ∈ mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right ↔ x ∈ carrier
-- Mathlib/Topology/Bases.lean
/-- If a family of open sets `s` is such that every open neighbourhood contains some
member of `s`, then `s` is a topological basis. -/
theorem isTopologicalBasis_of_isOpen_of_nhds {s : Set (Set α)} (h_open : ∀ u ∈ s, IsOpen u)
    (h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ s, a ∈ v ∧ v ⊆ u) :
    IsTopologicalBasis s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_bind_of_mem {b : β} {l : List α} {f : α → List β} {a} (al : a ∈ l) (h : b ∈ f a) :
    b ∈ List.bind l f
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem add_snd : (x + y).snd = x.snd + y.snd
-- Mathlib/Algebra/Group/Center.lean
/-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiff_fst : ContMDiff (I.prod J) I n (@Prod.fst M N)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem Nonempty.of_smul_left : (s • t).Nonempty → s.Nonempty
-- Mathlib/Logic/Function/Basic.lean
theorem apply_invFun_apply {α β : Type*} {f : α → β} {a : α} :
    f (@invFun _ _ ⟨a⟩ f (f a)) = f a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_sub_eq_succ (h : m - n = succ l) : n < m
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_leftUnitor_inv_snd (X : C₁ × C₂) :
    ((λ_ X).inv : X ⟶ 𝟙_ _ ⊗ X).2 = (λ_ X.2).inv
-- Mathlib/Order/Hom/Basic.lean
/-- `OrderIsoClass F α β` states that `F` is a type of order isomorphisms.

You should extend this class when you extend `OrderIso`. -/
class OrderIsoClass (F α β : Type*) [LE α] [LE β] [EquivLike F α β] : Prop where
  /-- An order isomorphism respects `≤`. -/
  map_le_map_iff (f : F) {a b : α} : f a ≤ f b ↔ a ≤ b
-- Mathlib/Order/Filter/Bases.lean
theorem asBasis_filter (f : Filter α) : f.asBasis.filter = f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Basic.lean
theorem shiftRight_succ (m n) : m >>> (n + 1) = (m >>> n) / 2
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_sub_le_sub_right : ∀ {n m k : Nat}, k ≤ m → n - k ≤ m - k → n ≤ m
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem nonuniformWitnesses_spec (h : ¬G.IsUniform ε s t) :
    ε ≤
      |G.edgeDensity (G.nonuniformWitnesses ε s t).1 (G.nonuniformWitnesses ε s t).2 -
          G.edgeDensity s t|
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem inv_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) [IsIso f] :
    inv (X ◁ f) = X ◁ inv f
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive prod_mono]
theorem prod_mono {s₁ s₂ : Subsemigroup M} {t₁ t₂ : Subsemigroup N} (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂) :
    s₁.prod t₁ ≤ s₂.prod t₂
-- Mathlib/Data/Multiset/Basic.lean
theorem monotone_filter_left : Monotone (filter p)
-- Mathlib/GroupTheory/Perm/Support.lean
theorem Disjoint.mul_left (H1 : Disjoint f h) (H2 : Disjoint g h) : Disjoint (f * g) h
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_of_one_lt (h : 1 < a) : |a|ₘ = a
-- Mathlib/Data/Set/NAry.lean
@[simp] lemma image2_mk_eq_prod : image2 Prod.mk s t = s ×ˢ t
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.smul_eq (hA : Balanced 𝕜 A) (ha : ‖a‖ = 1) : a • A = A
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
protected theorem LocallyIntegrable.add (hf : LocallyIntegrable f μ) (hg : LocallyIntegrable g μ) :
    LocallyIntegrable (f + g) μ
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp, norm_cast]
theorem coe_sep (p : Class.{u}) (x : ZFSet.{u}) :
    (ZFSet.sep p x : Class) = { y ∈ x | p y }