ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive (attr := simp)]
theorem mul_liftRight_inv (f : M →* N) (h : ∀ x, IsUnit (f x)) (x) :
    f x * ↑(IsUnit.liftRight f h x)⁻¹ = 1
-- Mathlib/Algebra/Order/Group/Defs.lean
@[to_additive (attr := simp)]
theorem inv_lt_self_iff : a⁻¹ < a ↔ 1 < a
-- Mathlib/LinearAlgebra/Reflection.lean
@[simp]
lemma reflection_symm (h : f x = 2) :
    (reflection h).symm = reflection h
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem coe_toAffineMap : ⇑f.toAffineMap = f
-- Mathlib/Data/Quot.lean
/-- A version of `Quotient.inductionOn` taking `{s : Setoid α}` as an implicit argument instead
of an instance argument. -/
@[elab_as_elim]
protected theorem inductionOn' {p : Quotient s₁ → Prop} (q : Quotient s₁)
    (h : ∀ a, p (Quotient.mk'' a)) : p q
-- Mathlib/MeasureTheory/Measure/Count.lean
theorem empty_of_count_eq_zero' (s_mble : MeasurableSet s) (hsc : count s = 0) : s = ∅
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_assoc : ∀ s t u : Finset α, s ○ t ○ u = s ○ (t ○ u)
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc]
theorem coconePointsIsoOfNatIso_inv_desc {F G : J ⥤ C} {s : Cocone G} {r t : Cocone F}
    (P : IsColimit t) (Q : IsColimit s) (w : F ≅ G) :
    (coconePointsIsoOfNatIso P Q w).inv ≫ P.desc r = Q.map _ w.inv
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem cycleOf_one [DecidableRel (1 : Perm α).SameCycle] (x : α) :
    cycleOf 1 x = 1
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
/-- The number of solutions to `x^2 = a` is determined by the quadratic character. -/
theorem quadraticChar_card_sqrts (hF : ringChar F ≠ 2) (a : F) :
    ↑{x : F | x ^ 2 = a}.toFinset.card = quadraticChar F a + 1
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem associated_of_irreducible {a b : R} (ha : Irreducible a) (hb : Irreducible b) :
    Associated a b
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive (attr := simp)]
lemma lipschitzWith_inv_iff : LipschitzWith K f⁻¹ ↔ LipschitzWith K f
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem le_inf_support_add : f.support.inf degt ⊓ g.support.inf degt ≤ (f + g).support.inf degt
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
/-- To show that two linear maps from the exterior algebra agree, it suffices to show they agree on
the exterior powers.

See note [partially-applied ext lemmas] -/
@[ext]
theorem lhom_ext ⦃f g : ExteriorAlgebra R M →ₗ[R] N⦄
    (h : ∀ i, f.compAlternatingMap (ιMulti R i) = g.compAlternatingMap (ιMulti R i)) : f = g
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
lemma exp_monotone : Monotone exp
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_eq_bot_iff : a \ b = ⊥ ↔ a ≤ b
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Given `f : β → ℝ≥0∞`, if `f` sends `{i | p i}` to a set of positive numbers
accumulating to zero, then closed `f i`-neighborhoods of the diagonal form a basis of `𝓤 α`.

For specific bases see `uniformity_basis_edist_le` and `uniformity_basis_edist_le'`. -/
protected theorem EMetric.mk_uniformity_basis_le {β : Type*} {p : β → Prop} {f : β → ℝ≥0∞}
    (hf₀ : ∀ x, p x → 0 < f x) (hf : ∀ ε, 0 < ε → ∃ x, p x ∧ f x ≤ ε) :
    (𝓤 α).HasBasis p fun x => { p : α × α | edist p.1 p.2 ≤ f x }
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_smul_le [CommSemiring S] [DistribMulAction R S] (a : R) (f : MvPolynomial σ S) :
    (a • f).totalDegree ≤ f.totalDegree
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem upperBounds_insert (a : α) (s : Set α) :
    upperBounds (insert a s) = Ici a ∩ upperBounds s
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
theorem Sphere.mem_coe {p : P} {s : Sphere P} : p ∈ (s : Set P) ↔ p ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
@[simp] theorem add_mul_mod_self_right (x y z : Nat) : (x + y * z) % z = x % z
-- Mathlib/Order/Lattice.lean
theorem left_or_right_lt_sup (h : a ≠ b) : a < a ⊔ b ∨ b < a ⊔ b
-- Mathlib/Data/Multiset/Basic.lean
theorem attach_map_val' (s : Multiset α) (f : α → β) : (s.attach.map fun i => f i.val) = s.map f
-- Mathlib/LinearAlgebra/FreeProduct/Basic.lean
/--Universal property of the free product of algebras:
for every `R`-algebra `B`, every family of maps `maps : (i : I) → (A i →ₐ[R] B)` lifts
to a unique arrow `π` from `FreeProduct R A` such that  `π ∘ ι i = maps i`.-/
@[simps] def lift : ({i : I} → A i →ₐ[R] B) ≃ (FreeProduct R A →ₐ[R] B)
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
@[simp]
theorem interUnionPullbackCone_pt : (interUnionPullbackCone F U V).pt = F.1.obj (op <| U ⊔ V)
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma inrX_fstX (i j : ι) (hij : c.Rel i j) :
    inrX φ i ≫ fstX φ i j hij = 0
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma mem_orbit_of_mem_orbit_submonoid {S : Submonoid M} {a b : α} (h : a ∈ orbit S b) :
    a ∈ orbit M b
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[simp]
theorem pullback_refine {Y X : C} {P : Cᵒᵖ ⥤ D} {S T : J.Cover X} (h : S ⟶ T) (f : Y ⟶ X)
    (x : Meq P T) : (x.pullback f).refine ((J.pullback f).map h) = (refine x h).pullback _
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma ofNat_eq_coe (n : ℕ) [n.AtLeastTwo] (m : α) :
    no_index (OfNat.ofNat n) = (m : WithBot α) ↔ OfNat.ofNat n = m
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- A continuous function with compact support has a global maximum. -/
@[to_additive "A continuous function with compact support has a global maximum."]
theorem Continuous.exists_forall_ge_of_hasCompactMulSupport [ClosedIciTopology α] [Nonempty β]
    [One α] {f : β → α} (hf : Continuous f) (h : HasCompactMulSupport f) :
    ∃ x : β, ∀ y : β, f y ≤ f x
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem initial_of_initial_comp [Initial F] [Initial (F ⋙ G)] : Initial G
-- Mathlib/LinearAlgebra/Basis.lean
theorem mem_span_repr_support (m : M) : m ∈ span R (b '' (b.repr m).support)
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
    nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂
-- Mathlib/Algebra/Order/Floor/Div.lean
/-- Typeclass for division rounded up. For each `a > 0`, this asserts the existence of a left
adjoint to the map `b ↦ a • b : β → β`. -/
class CeilDiv where
  /-- Ceiling division. If `a > 0`, then `b ⌈/⌉ a` is the least `c` such that `b ≤ a • c`. -/
  ceilDiv : β → α → β
  /-- Do not use this. Use `gc_smul_ceilDiv` or `gc_mul_ceilDiv` instead. -/
  protected ceilDiv_gc ⦃a⦄ : 0 < a → GaloisConnection (ceilDiv · a) (a • ·)
  /-- Do not use this. Use `ceilDiv_nonpos` instead. -/
  protected ceilDiv_nonpos ⦃a⦄ : a ≤ 0 → ∀ b, ceilDiv b a = 0
  /-- Do not use this. Use `zero_ceilDiv` instead. -/
  protected zero_ceilDiv (a) : ceilDiv 0 a = 0
-- Mathlib/Topology/Filter.lean
theorem nhds_atTop [Preorder α] : 𝓝 atTop = ⨅ x : α, 𝓟 (Iic (𝓟 (Ici x)))
-- Mathlib/Topology/Category/TopCat/OpenNhds.lean
@[simp]
theorem inclusionMapIso_hom (x : X) : (inclusionMapIso f x).hom = 𝟙 _
-- Mathlib/Analysis/Convex/Side.lean
theorem isConnected_setOf_sSameSide {s : AffineSubspace ℝ P} {x : P} (hx : x ∉ s)
    (h : (s : Set P).Nonempty) : IsConnected { y | s.SSameSide x y }
-- Mathlib/Tactic/ComputeDegree.lean
theorem natDegree_natCast_le (n : ℕ) : natDegree (n : R[X]) ≤ 0
-- Mathlib/Topology/Order/LowerUpperTopology.lean
protected lemma _root_.sInfHom.continuous (f : sInfHom α β) : Continuous f
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
/-- The submonoid of pointwise inverse of `S` is `MulEquiv` to `S`. -/
@[to_additive (attr := simps apply) "The additive submonoid of pointwise additive inverse of `S` is
`AddEquiv` to `S`."]
noncomputable def leftInvEquiv : S.leftInv ≃* S
-- Mathlib/Order/Chain.lean
protected theorem IsChain.insert (hs : IsChain r s) (ha : ∀ b ∈ s, a ≠ b → a ≺ b ∨ b ≺ a) :
    IsChain r (insert a s)
-- Mathlib/Algebra/Ring/Defs.lean
/-- The additive inverse of one multiplied by an element of a ring is the element's additive
  inverse. -/
theorem neg_one_mul (a : α) : -1 * a = -a
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem restrict_trim (hle : m ≤ n) {i : Set α} (hi : MeasurableSet[m] i) :
    @VectorMeasure.restrict α m M _ _ (v.trim hle) i = (v.restrict i).trim hle
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem split_of_valid (s p) : split s p = (List.splitOnP p s.1).map mk
-- Mathlib/SetTheory/Game/PGame.lean
theorem neg_insertRight_neg (x x' : PGame.{u}) : (-x).insertRight (-x') = -x.insertLeft x'
-- Mathlib/RingTheory/WittVector/Teichmuller.lean
@[simp]
theorem teichmuller_zero : teichmuller p (0 : R) = 0
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
/-- this lemma establishes that if `ContinuousLinearMap.mul 𝕜 A` is injective, then so is
`Unitization.splitMul 𝕜 A`. When `A` is a `RegularNormedAlgebra`, then
`ContinuousLinearMap.mul 𝕜 A` is an isometry, and is therefore automatically injective. -/
theorem splitMul_injective_of_clm_mul_injective
    (h : Function.Injective (mul 𝕜 A)) :
    Function.Injective (splitMul 𝕜 A)
-- Mathlib/Combinatorics/SimpleGraph/Dart.lean
theorem dart_edge_eq_iff : ∀ d₁ d₂ : G.Dart, d₁.edge = d₂.edge ↔ d₁ = d₂ ∨ d₁ = d₂.symm
-- Mathlib/CategoryTheory/Limits/Shapes/NormalMono/Basic.lean
/-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem lift_single (F : G →* A) (a b) : lift k G A F (single a b) = b • F a
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
protected lemma «forall» {p : Multiplicative α → Prop} : (∀ a, p a) ↔ ∀ a, p (ofAdd a)
-- Mathlib/Order/Bounds/Basic.lean
theorem upperBounds_Ioc (h : a < b) : upperBounds (Ioc a b) = Ici b
-- Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean
theorem isIntegral_algHom_iff {x : A} : IsIntegral R (f x) ↔ IsIntegral R x
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp) sub_self]
theorem div_self' (a : G) : a / a = 1
-- Mathlib/Order/Filter/Pi.lean
theorem mem_pi_of_mem (i : ι) {s : Set (α i)} (hs : s ∈ f i) : eval i ⁻¹' s ∈ pi f
-- Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean
theorem isClosed_range (coercive : IsCoercive B) : IsClosed (range B♯ : Set V)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.bound : f =O[l] g → ∃ c : ℝ, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Topology/Connected/Clopen.lean
/-- In a preconnected space, any disjoint family of non-empty clopen subsets has at most one
element. -/
lemma subsingleton_of_disjoint_isClopen
    (h_clopen : ∀ i, IsClopen (s i)) :
    Subsingleton ι
-- Mathlib/Algebra/Order/Group/Int.lean
theorem abs_ediv_le_abs : ∀ a b : ℤ, |a / b| ≤ |a|
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp)]
theorem empty_smul : (∅ : Set α) • t = ∅
-- Mathlib/NumberTheory/SumPrimeReciprocals.lean
/-- The sum over the reciprocals of the primes diverges. -/
theorem Nat.Primes.not_summable_one_div : ¬ Summable (fun p : Nat.Primes ↦ (1 / p : ℝ))
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem vecMul_zero [Fintype m] (v : m → α) : v ᵥ* (0 : Matrix m n α) = 0
-- Mathlib/RingTheory/LocalRing/Basic.lean
theorem nonunits_add {a b : R} (ha : a ∈ nonunits R) (hb : b ∈ nonunits R) : a + b ∈ nonunits R
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_rpow_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z < y ^ z ↔ x < y
-- Mathlib/Topology/Instances/CantorSet.lean
theorem zero_mem_cantorSet : 0 ∈ cantorSet
-- Mathlib/Topology/Homeomorph.lean
protected theorem quotientMap (h : X ≃ₜ Y) : QuotientMap h
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iSup_iSup_eq_right {b : β} {f : ∀ x : β, b = x → α} : ⨆ x, ⨆ h : b = x, f x h = f b rfl
-- Mathlib/Algebra/GroupWithZero/Divisibility.lean
/-- Given two elements `b`, `c` of a `CancelMonoidWithZero` and a nonzero element `a`,
 `a*b` divides `a*c` iff `b` divides `c`. -/
theorem mul_dvd_mul_iff_left [CancelMonoidWithZero α] {a b c : α} (ha : a ≠ 0) :
    a * b ∣ a * c ↔ b ∣ c
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_zipWith [D : DecidableEq α] {f : M → N → P} {hf : f 0 0 = 0} {g₁ : α →₀ M}
    {g₂ : α →₀ N} : (zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_le_iff_le_comap {f : F} {S : Submonoid M} {T : Submonoid N} :
    S.map f ≤ T ↔ S ≤ T.comap f
-- Mathlib/Algebra/FreeAlgebra.lean
/-- The canonical function `X → FreeAlgebra R X`.
-/
irreducible_def ι : X → FreeAlgebra R X
-- Mathlib/Topology/MetricSpace/Gluing.lean
private theorem Sum.mem_uniformity (s : Set ((X ⊕ Y) × (X ⊕ Y))) :
    s ∈ 𝓤 (X ⊕ Y) ↔ ∃ ε > 0, ∀ a b, Sum.dist a b < ε → (a, b) ∈ s
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem toFunLinear_one_tmul_one :
    toFunLinear R A (1 ⊗ₜ[R] 1) = 1
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_dirac' (a : α) {f : α → ℝ≥0∞} (hf : Measurable f) : ∫⁻ a, f a ∂dirac a = f a
-- Mathlib/Analysis/Seminorm.lean
theorem finset_sup_apply_lt {p : ι → Seminorm 𝕜 E} {s : Finset ι} {x : E} {a : ℝ} (ha : 0 < a)
    (h : ∀ i, i ∈ s → p i x < a) : s.sup p x < a
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem hasDerivAt_aeval (x : 𝕜) :
    HasDerivAt (fun x => aeval x q) (aeval x (derivative q)) x
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
theorem scaleRoots_aeval_eq_zero_of_aeval_div_eq_zero [Algebra R K]
    (inj : Function.Injective (algebraMap R K)) {p : R[X]} {r s : R}
    (hr : aeval (algebraMap R K r / algebraMap R K s) p = 0) (hs : s ∈ nonZeroDivisors R) :
    aeval (algebraMap R K r) (scaleRoots p s) = 0
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
lemma support_nonempty {p : MvPolynomial σ R} : p.support.Nonempty ↔ p ≠ 0
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Group homomorphisms preserve integer power. -/
@[to_additive "Additive group homomorphisms preserve integer scaling."]
protected theorem map_zpow [Group α] [DivisionMonoid β] (f : α →* β) (g : α) (n : ℤ) :
    f (g ^ n) = f g ^ n
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
@[simp]
theorem range_exp : Set.range exp = {0}ᶜ
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive (attr := simp)]
lemma monovaryOn_inv_left : MonovaryOn f⁻¹ g s ↔ AntivaryOn f g s
-- Mathlib/Data/Matroid/Basic.lean
theorem ground_finite (M : Matroid α) [M.Finite] : M.E.Finite
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
@[simp]
theorem pathEquivList_symm_nil : pathEquivList.symm ([] : List α) = Path.nil
-- Mathlib/Topology/Homotopy/Basic.lean
/--
Given a `HomotopyRel f₀ f₁ S`, we can define a `HomotopyRel f₁ f₀ S` by reversing the homotopy.
-/
@[simps!]
def symm (F : HomotopyRel f₀ f₁ S) : HomotopyRel f₁ f₀ S
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive (attr := mono)]
theorem tprod_strict_mono (hf : Multipliable f) (hg : Multipliable g) (h : f < g) :
    ∏' n, f n < ∏' n, g n
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem piCongr'_symm_apply_symm_apply (f : ∀ b, Z b) (b : β) :
    (h₁.piCongr' h₂).symm f (h₁.symm b) = (h₂ b).symm (f b)
-- Mathlib/Topology/Constructions.lean
theorem closedEmbedding_inr : ClosedEmbedding (inr : Y → X ⊕ Y)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem surjective_projRestricts (h : ∀ i, J i → K i) : Function.Surjective (ProjRestricts C h)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem mem_sInf {S : Set (Subring R)} {x : R} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Mathlib/CategoryTheory/Adjunction/Over.lean
/-- `Under.pushout f` is left adjoint to `Under.map f`. -/
@[simps! unit_app counit_app]
def mapPushoutAdj {X Y : C} (f : X ⟶ Y) : pushout f ⊣ map f
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast]
theorem coe_indicator {α} (s : Set α) (f : α → ℝ≥0) (a : α) :
    ((s.indicator f a : ℝ≥0) : ℝ) = s.indicator (fun x => ↑(f x)) a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem finset_card_neighborSet_eq_degree {G' : Subgraph G} {v : V} [Fintype (G'.neighborSet v)] :
    (G'.neighborSet v).toFinset.card = G'.degree v
-- Mathlib/RingTheory/Int/Basic.lean
theorem Int.Prime.dvd_pow {n : ℤ} {k p : ℕ} (hp : Nat.Prime p) (h : (p : ℤ) ∣ n ^ k) :
    p ∣ n.natAbs
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_le_hnot : a \ b ≤ ￢b
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem one_right : (1 : N ⋊[φ] G).right = 1
-- Mathlib/CategoryTheory/Monoidal/Center.lean
@[simp]
theorem associator_hom_f (X Y Z : Center C) : Hom.f (α_ X Y Z).hom = (α_ X.1 Y.1 Z.1).hom
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem isClosed_C' : IsClosed (C' C ho)
-- Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean
/-- Technical lemma to control the addition of functions in `L^p` even for `p < 1`: Given `δ > 0`,
there exists `η` such that two functions bounded by `η` in `L^p` have a sum bounded by `δ`. One
could take `η = δ / 2` for `p ≥ 1`, but the point of the lemma is that it works also for `p < 1`.
-/
theorem exists_Lp_half (p : ℝ≥0∞) {δ : ℝ≥0∞} (hδ : δ ≠ 0) :
    ∃ η : ℝ≥0∞,
      0 < η ∧
        ∀ (f g : α → E), AEStronglyMeasurable f μ → AEStronglyMeasurable g μ →
          eLpNorm f p μ ≤ η → eLpNorm g p μ ≤ η → eLpNorm (f + g) p μ < δ
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_iff_forall {P : α → Prop} : ∀ {t}, All P t ↔ ∀ x, Emem x t → P x
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem splittingOfFinsuppSurjective_injective (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    Injective (splittingOfFinsuppSurjective f s)
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
lemma eigenvalues_self_mul_conjTranspose_nonneg (A : Matrix m n 𝕜) [DecidableEq m] (i : m) :
    0 ≤ (isHermitian_mul_conjTranspose_self A).eigenvalues i
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem X_pow_mul {n : ℕ} : X ^ n * p = p * X ^ n
-- Mathlib/Algebra/SMulWithZero.lean
protected lemma MulActionWithZero.nontrivial
    [MulActionWithZero R M] [Nontrivial M] : Nontrivial R
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_map {α β σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ) : (f <$> x).run s = (fun (p : α × σ) => (f p.1, p.2)) <$> x.run s
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mk'_spec (x) (y : S) : f.mk' x y * f.toMap y = f.toMap x
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem blimsup_or_eq_sup : (blimsup u f fun x => p x ∨ q x) = blimsup u f p ⊔ blimsup u f q
-- Mathlib/Order/CompleteLattice.lean
protected lemma Antitone.sInf (hs : ∀ f ∈ s, Antitone f) : Antitone (sInf s)
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
@[simp]
theorem countable_preimage_exp {s : Set ℂ} : (exp ⁻¹' s).Countable ↔ s.Countable
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem id_mem_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 c ∈ S.arrows c c
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem bind_nil (f : α → List β) : List.bind [] f = []
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem lowerCentralSeriesLast_le_max_triv :
    lowerCentralSeriesLast R L M ≤ maxTrivSubmodule R L M
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_castPred_self (p : Fin (n + 1)) (hp : p ≠ last n) :
    (castPred p hp).predAbove p = castPred p hp
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem LinearMap.toMatrix'_one : LinearMap.toMatrix' (1 : (n → R) →ₗ[R] n → R) = 1
-- Mathlib/Topology/Algebra/Constructions/DomMulAct.lean
@[to_additive] theorem quotientMap_mk : QuotientMap (@mk M)
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem iInter_Iic_eq_empty_iff : ⋂ i, Iic (f i) = ∅ ↔ ¬ BddBelow (range f)
-- Mathlib/Order/UpperLower/Basic.lean
theorem upperClosure_min (h : s ⊆ t) (ht : IsUpperSet t) : ↑(upperClosure s) ⊆ t
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
/-- Induction principle used for proving facts about Chebyshev polynomials. -/
@[elab_as_elim]
protected theorem induct (motive : ℤ → Prop)
    (zero : motive 0)
    (one : motive 1)
    (add_two : ∀ (n : ℕ), motive (↑n + 1) → motive ↑n → motive (↑n + 2))
    (neg_add_one : ∀ (n : ℕ), motive (-↑n) → motive (-↑n + 1) → motive (-↑n - 1)) :
    ∀ (a : ℤ), motive a
-- Mathlib/Algebra/Order/Field/Basic.lean
lemma div_le_comm₀ (hb : 0 < b) (hc : 0 < c) : a / b ≤ c ↔ a / c ≤ b
-- Mathlib/Algebra/Category/ModuleCat/Sheaf.lean
/-- The forget functor `SheafOfModules R ⥤ Sheaf J AddCommGrp`. -/
@[simps]
def toSheaf : SheafOfModules.{v} R ⥤ Sheaf J AddCommGrp.{v}
-- Mathlib/Order/Filter/Prod.lean
theorem top_prod : (⊤ : Filter α) ×ˢ g = g.comap Prod.snd
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem cancel_left {g f₁ f₂ : CentroidHom α} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Order/CompleteLattice.lean
lemma Equiv.biSup_comp {ι ι' : Type*} {g : ι' → α} (e : ι ≃ ι') (s : Set ι') :
    ⨆ i ∈ e.symm '' s, g (e i) = ⨆ i ∈ s, g i
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem minFac_pos (n : ℕ) : 0 < minFac n
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := fun_prop, aesop safe 20 apply (rule_sets := [Measurable]))]
theorem Measurable.smul [MeasurableSMul₂ M β] (hf : Measurable f) (hg : Measurable g) :
    Measurable fun x => f x • g x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the sign of the angle between two vectors is nonzero, the vectors are not equal. -/
theorem ne_of_oangle_sign_ne_zero {x y : V} (h : (o.oangle x y).sign ≠ 0) : x ≠ y
-- Mathlib/Order/LiminfLimsup.lean
theorem le_limsSup_of_le {f : Filter α} {a}
    (hf : f.IsBounded (· ≤ ·) := by isBoundedDefault)
    (h : ∀ b, (∀ᶠ n in f, n ≤ b) → a ≤ b) : a ≤ limsSup f
-- Mathlib/Data/Seq/WSeq.lean
theorem LiftRelO.imp {R S : α → β → Prop} {C D : WSeq α → WSeq β → Prop} (H1 : ∀ a b, R a b → S a b)
    (H2 : ∀ s t, C s t → D s t) : ∀ {o p}, LiftRelO R C o p → LiftRelO S D o p
-- Mathlib/Logic/Equiv/Basic.lean
/-- If `α ≃ α'` and `β ≃ β'`, then `α ⊕ β ≃ α' ⊕ β'`. This is `Sum.map` as an equivalence. -/
@[simps apply]
def sumCongr (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) : α₁ ⊕ β₁ ≃ α₂ ⊕ β₂
-- Mathlib/Data/Matrix/Rank.lean
/-- The rank of a matrix is the rank of the space spanned by its rows.

TODO: prove this in a generality that works for `ℂ` too, not just `ℚ` and `ℝ`. -/
theorem rank_eq_finrank_span_row [LinearOrderedField R] [Finite m] (A : Matrix m n R) :
    A.rank = finrank R (Submodule.span R (Set.range A))
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem dif_neg {c : Prop} {h : Decidable c} (hnc : ¬c) {α : Sort u} {t : c → α} {e : ¬ c → α} : (dite c t e) = e hnc
-- Mathlib/Combinatorics/Hindman.lean
@[to_additive]
theorem FP.finset_prod {M} [CommMonoid M] (a : Stream' M) (s : Finset ℕ) (hs : s.Nonempty) :
    (s.prod fun i => a.get i) ∈ FP a
-- Mathlib/Order/LiminfLimsup.lean
lemma mem_limsup_iff_frequently_mem : (a ∈ limsup s 𝓕) ↔ (∃ᶠ i in 𝓕, a ∈ s i)
-- Mathlib/Order/Filter/EventuallyConst.lean
theorem HasBasis.eventuallyConst_iff' {ι : Sort*} {p : ι → Prop} {s : ι → Set α}
    {x : ι → α} (h : l.HasBasis p s) (hx : ∀ i, p i → x i ∈ s i) :
    EventuallyConst f l ↔ ∃ i, p i ∧ ∀ y ∈ s i, f y = f (x i)
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
/-- Implementation of `Mon_.equivLaxMonoidalFunctorPUnit`. -/
@[simps]
def laxMonoidalToMon : LaxMonoidalFunctor (Discrete PUnit.{u + 1}) C ⥤ Mon_ C
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_inter_Ici (a b c : α) : Ico a b ∩ Ici c = Ico (a ⊔ c) b
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem conj_cong_is_cong (g : ConjAct SL(2, ℤ)) (Γ : Subgroup SL(2, ℤ))
    (h : IsCongruenceSubgroup Γ) : IsCongruenceSubgroup (g • Γ)
-- Mathlib/Analysis/Complex/Basic.lean
theorem dist_conj_self (z : ℂ) : dist (conj z) z = 2 * |z.im|
-- Mathlib/Control/Lawful.lean
@[simp]
theorem run_monadLift {n} [MonadLiftT n m] (x : n α) :
    (monadLift x : OptionT m α).run = (monadLift x : m α) >>= fun a => pure (some a)
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
lemma nonUnitalStarAlgebraAdjoin_id_subset_ker_evalStarAlgHom {s : Set 𝕜} (h0 : 0 ∈ s) :
    (adjoin 𝕜 {restrict s (.id 𝕜)} : Set C(s, 𝕜)) ⊆
      RingHom.ker (evalStarAlgHom 𝕜 𝕜 (⟨0, h0⟩ : s))