ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem norm_eq_of_nat {p : ℝ≥0∞} [Fact (1 ≤ p)] {β : ι → Type*}
    [∀ i, SeminormedAddCommGroup (β i)] (n : ℕ) (h : p = n) (f : PiLp p β) :
    ‖f‖ = (∑ i, ‖f i‖ ^ n) ^ (1 / (n : ℝ))
-- Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean
/-- If a gcf terminated at position `n`, it also terminated at `m ≥ n`. -/
theorem terminated_stable (n_le_m : n ≤ m) (terminatedAt_n : g.TerminatedAt n) :
    g.TerminatedAt m
-- Mathlib/Topology/Filter.lean
theorem nhds_atBot [Preorder α] : 𝓝 atBot = ⨅ x : α, 𝓟 (Iic (𝓟 (Iic x)))
-- Mathlib/Condensed/Light/Basic.lean
@[simp]
lemma hom_naturality_apply {X Y : LightCondSet.{u}} (f : X ⟶ Y)  {S T : LightProfiniteᵒᵖ}
    (g : S ⟶ T) (x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x)
-- Mathlib/Order/CompleteLatticeIntervals.lean
theorem subset_sInf_emptyset [Inhabited s] :
    sInf (∅ : Set s) = default
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem map_iInf {m : ι → MeasurableSpace α} : (⨅ i, m i).map f = ⨅ i, (m i).map f
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem exists_fixed_point_of_prime' {p n : ℕ} [hp : Fact p.Prime] (hα : p ∣ Fintype.card α)
    {σ : Perm α} (hσ : σ ^ p ^ n = 1) {a : α} (ha : σ a = a) : ∃ b : α, σ b = b ∧ b ≠ a
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem zero_bind : bind 0 f = 0
-- Mathlib/Order/Interval/Finset/Fin.lean
@[simp]
theorem map_valEmbedding_Iio : (Iio b).map Fin.valEmbedding = Iio ↑b
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem eraseNone_inter [DecidableEq (Option α)] [DecidableEq α] (s t : Finset (Option α)) :
    eraseNone (s ∩ t) = eraseNone s ∩ eraseNone t
-- Mathlib/Data/Real/EReal.lean
theorem coe_ennreal_ne_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) ≠ (y : EReal) ↔ x ≠ y
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem exists_basicOpen_le {V : X.Opens} (x : V) (h : ↑x ∈ U) :
    ∃ f : Γ(X, U), X.basicOpen f ≤ V ∧ ↑x ∈ X.basicOpen f
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Subgroup G} (i : ι) :
    ∀ {x : G}, x ∈ S i → x ∈ iSup S
-- Mathlib/Analysis/Calculus/LagrangeMultipliers.lean
/-- Lagrange multipliers theorem, 1d version. Let `f : ι → E → ℝ` be a finite family of functions.
Suppose that `φ : E → ℝ` has a local extremum on the set `{x | ∀ i, f i x = f i x₀}` at `x₀`.
Suppose that all functions `f i` as well as `φ` are strictly differentiable at `x₀`.
Then the derivatives `f' i : E → L[ℝ] ℝ` and `φ' : E →L[ℝ] ℝ` are linearly dependent:
there exist `Λ : ι → ℝ` and `Λ₀ : ℝ`, `(Λ, Λ₀) ≠ 0`, such that `∑ i, Λ i • f' i + Λ₀ • φ' = 0`.

See also `IsLocalExtrOn.linear_dependent_of_hasStrictFDerivAt` for a version that
states `¬LinearIndependent ℝ _` instead of existence of `Λ` and `Λ₀`. -/
theorem IsLocalExtrOn.exists_multipliers_of_hasStrictFDerivAt {ι : Type*} [Fintype ι]
    {f : ι → E → ℝ} {f' : ι → E →L[ℝ] ℝ} (hextr : IsLocalExtrOn φ {x | ∀ i, f i x = f i x₀} x₀)
    (hf' : ∀ i, HasStrictFDerivAt (f i) (f' i) x₀) (hφ' : HasStrictFDerivAt φ φ' x₀) :
    ∃ (Λ : ι → ℝ) (Λ₀ : ℝ), (Λ, Λ₀) ≠ 0 ∧ (∑ i, Λ i • f' i) + Λ₀ • φ' = 0
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_nndist_eq_add [PseudoMetricSpace α] [PseudoMetricSpace β]
    (hp : p ≠ ∞) (x y : WithLp p (α × β)) :
    nndist x y = (nndist x.fst y.fst ^ p.toReal + nndist x.snd y.snd ^ p.toReal) ^ (1 / p.toReal)
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- A functorial version of `Cosimplicial_object.Augmented.leftOp`. -/
@[simps]
def cosimplicialToSimplicialAugmented :
    CosimplicialObject.Augmented Cᵒᵖ ⥤ (SimplicialObject.Augmented C)ᵒᵖ
-- Mathlib/Computability/Primrec.lean
theorem mul : @Primrec' 2 fun v => v.head * v.tail.head
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp] lemma coe_toBoundedLatticeHom (f : CompleteLatticeHom α β) : ⇑f.toBoundedLatticeHom = f
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem image_symm (f : P₁ ≃ᵃ[k] P₂) (s : Set P₂) : f.symm '' s = f ⁻¹' s
-- Mathlib/LinearAlgebra/Dual.lean
/-- `f.dualMap` is injective if and only if `f` is surjective -/
@[simp]
theorem dualMap_injective_iff {f : V₁ →ₗ[K] V₂} :
    Function.Injective f.dualMap ↔ Function.Surjective f
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
@[reassoc (attr := simp)]
lemma descOfIsLeftKanExtension_fac (G : D ⥤ H) (β : F ⟶ L ⋙ G) :
    α ≫ whiskerLeft L (F'.descOfIsLeftKanExtension α G β) = β
-- Mathlib/Algebra/Algebra/Operations.lean
theorem smul_def (s : SetSemiring A) (P : Submodule R A) :
    s • P = span R (SetSemiring.down (α := A) s) * P
-- Mathlib/Data/Set/Basic.lean
lemma disjoint_iff_forall_ne : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ t → a ≠ b
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_lt_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω < i}
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive (attr := simp)]
theorem finprod_true (f : True → M) : ∏ᶠ i, f i = f trivial
-- Mathlib/Data/Matrix/Block.lean
theorem blockDiag'_apply (M : Matrix (Σi, m' i) (Σi, n' i) α) (k : o) (i j) :
    blockDiag' M k i j = M ⟨k, i⟩ ⟨k, j⟩
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive norm_le_zero_iff']
theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp]
lemma snd_prod [IsProbabilityMeasure μ] : (μ.prod ν).snd = ν
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_filter_of_ne {p : α → Prop} [DecidablePred p] (hp : ∀ x ∈ s, f x ≠ 1 → p x) :
    ∏ x ∈ s.filter p, f x = ∏ x ∈ s, f x
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_one_isSolvable : IsSolvable (1 : F[X]).Gal
-- Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean
@[simp]
theorem directSumRight_tmul_lof (x : M₁') (i : ι₂) (y : M₂ i) :
    directSumRight R M₁' M₂ (x ⊗ₜ[R] DirectSum.lof R _ _ i y) =
    DirectSum.lof R _ _ i (x ⊗ₜ[R] y)
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem frontier_Iic [NoMaxOrder α] {a : α} : frontier (Iic a) = {a}
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem eq_prod_roots_of_monic_of_splits_id {p : K[X]} (m : Monic p)
    (hsplit : Splits (RingHom.id K) p) : p = (p.roots.map fun a => X - C a).prod
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected theorem mul_left_injective (h : IsUnit b) : Injective (· * b)
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem compl_inf_self (a : α) : aᶜ ⊓ a = ⊥
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean
theorem aestronglyMeasurable_smul_const_iff {f : α → 𝕜} {c : E} (hc : c ≠ 0) :
    AEStronglyMeasurable (fun x => f x • c) μ ↔ AEStronglyMeasurable f μ
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
@[simp]
theorem mem_homogeneousSubmodule [CommSemiring R] (n : ℕ) (p : MvPolynomial σ R) :
    p ∈ homogeneousSubmodule σ R n ↔ p.IsHomogeneous n
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem ae_restrict_iUnion_eq [Countable ι] (s : ι → Set α) :
    ae (μ.restrict (⋃ i, s i)) = ⨆ i, ae (μ.restrict (s i))
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma singleton_sups : {a} ⊻ t = t.image (a ⊔ ·)
-- Mathlib/Data/Setoid/Basic.lean
theorem Quot.subsingleton_iff (r : α → α → Prop) : Subsingleton (Quot r) ↔ EqvGen r = ⊤
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualBasis_apply (i : ι) (m : M) : b.dualBasis i m = b.repr m i
-- Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean
theorem mem_iff_eq_smul_annIdealGenerator {p : 𝕜[X]} (a : A) :
    p ∈ annIdeal 𝕜 a ↔ ∃ s : 𝕜[X], p = s • annIdealGenerator 𝕜 a
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
theorem decomposeAux_coe {i : ι} (x : gradeBy R f i) :
    decomposeAux f ↑x = DirectSum.of (fun i => gradeBy R f i) i x
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem rightUnitor_tensor (X Y : C) :
    (ρ_ (X ⊗ Y)).hom = (α_ X Y (𝟙_ C)).hom ≫ X ◁ (ρ_ Y).hom
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNormEssSup_indicator_le (s : Set α) (f : α → G) :
    eLpNormEssSup (s.indicator f) μ ≤ eLpNormEssSup f μ
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem volume_pi_pi [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))]
    (s : ∀ i, Set (α i)) : volume (pi univ s) = ∏ i, volume (s i)
-- Mathlib/Data/Matroid/Dual.lean
theorem Base.ssubset_ground [h : RkPos M✶] (hB : M.Base B) : B ⊂ M.E
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.toNat_lt (x : UInt8) : x.toNat < 2 ^ 8
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive Right.pow_nonpos]
theorem Right.pow_le_one_of_le (hx : x ≤ 1) : ∀ {n : ℕ}, x ^ n ≤ 1
-- Mathlib/Order/Filter/Basic.lean
theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 sᶜ)
-- Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean
lemma of_isPreimmersion {X Y : Scheme} (f : X ⟶ Y) [IsPreimmersion f]
    (hf : IsClosed (Set.range f.1.base)) : IsClosedImmersion f
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem sum_cond (μ ν : Measure α) : (sum fun b => cond b μ ν) = μ + ν
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma smul_basis_eq_zero {p q : R[X]} (hpq : p • (1 : W.CoordinateRing) + q • mk W Y = 0) :
    p = 0 ∧ q = 0
-- Mathlib/Data/Matrix/Basic.lean
theorem op_smul_one_eq_diagonal [DecidableEq m] (a : α) :
    MulOpposite.op a • (1 : Matrix m m α) = diagonal fun _ => a
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem mem_toNat' : ∀ (a : Int) (n : Nat), toNat' a = some n ↔ a = n
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem neg_eq : -a = a
-- Mathlib/Data/Part.lean
theorem ofOption_eq_get {α} (o : Option α) : ofOption o = ⟨_, @Option.get _ o⟩
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_false {s : False → Set α} : iInter s = univ
-- Mathlib/Data/List/DropRight.lean
theorem rdropWhile_singleton (x : α) : rdropWhile p [x] = if p x then [] else [x]
-- Mathlib/MeasureTheory/MeasurableSpace/Card.lean
theorem generateMeasurableRec_subset (s : Set (Set α)) {i j : ω₁} (h : i ≤ j) :
    generateMeasurableRec s i ⊆ generateMeasurableRec s j
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[reassoc (attr := simp)]
theorem leftDistributor_inv_comp_biproduct_π {J : Type} [Fintype J] (X : C) (f : J → C) (j : J) :
    (leftDistributor X f).inv ≫ (X ◁ biproduct.π _ j) = biproduct.π _ j
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
/-- Transposing Young diagrams is an `OrderIso`. -/
@[simps]
def transposeOrderIso : YoungDiagram ≃o YoungDiagram
-- Mathlib/Deprecated/Submonoid.lean
/-- Submonoids are closed under natural powers. -/
@[to_additive
      "An `AddSubmonoid` is closed under multiplication by naturals."]
theorem IsSubmonoid.pow_mem {a : M} (hs : IsSubmonoid s) (h : a ∈ s) : ∀ {n : ℕ}, a ^ n ∈ s
-- Mathlib/Order/Heyting/Boundary.lean
theorem boundary_le_boundary_sup_sup_boundary_inf_left : ∂ a ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)
-- Mathlib/Topology/Instances/Matrix.lean
@[continuity]
theorem Continuous.matrix_fromBlocks {A : X → Matrix n l R} {B : X → Matrix n m R}
    {C : X → Matrix p l R} {D : X → Matrix p m R} (hA : Continuous A) (hB : Continuous B)
    (hC : Continuous C) (hD : Continuous D) :
    Continuous fun x => Matrix.fromBlocks (A x) (B x) (C x) (D x)
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_mul (since := "2024-06-26")]
protected theorem map_mul (x y) : φ (x * y) = φ x * φ y
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma _root_.LocalRing.isRegular_iff_isWeaklyRegular_of_subset_maximalIdeal
    [LocalRing R] [Nontrivial M] [Module.Finite R M] {rs : List R}
    (h : ∀ r ∈ rs, r ∈ LocalRing.maximalIdeal R) :
    IsRegular M rs ↔ IsWeaklyRegular M rs
-- Mathlib/GroupTheory/OrderOfElement.lean
theorem isOfFinAddOrder_ofMul_iff : IsOfFinAddOrder (Additive.ofMul x) ↔ IsOfFinOrder x
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive]
theorem prod_apply [CommMonoid β] [ContinuousMul β] {ι : Type*} (s : Finset ι) (f : ι → C(α, β))
    (a : α) : (∏ i ∈ s, f i) a = ∏ i ∈ s, f i a
-- Mathlib/FieldTheory/Adjoin.lean
theorem aeval_gen_minpoly (α : E) : aeval (AdjoinSimple.gen F α) (minpoly F α) = 0
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem loopyOn_ground (E : Set α) : (loopyOn E).E = E
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma homologyι_naturality :
    homologyMap φ i ≫ L.homologyι i = K.homologyι i ≫ opcyclesMap φ i
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
protected theorem ext_iff : f = g ↔ ∀ x, f x = g x
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem mem_sup_right {S T : Submodule R M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem CauchySeq.prod_map {γ δ} [UniformSpace β] [Preorder γ] [Preorder δ] {u : γ → α}
    {v : δ → β} (hu : CauchySeq u) (hv : CauchySeq v) : CauchySeq (Prod.map u v)
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/-- Shows that the partial numerators `aᵢ` are equal to one. -/
theorem of_partNum_eq_one {a : K} (nth_partNum_eq : (of v).partNums.get? n = some a) :
    a = 1
-- Mathlib/Order/Closure.lean
@[simp]
theorem IsClosed.closure_le_iff (hy : c.IsClosed y) : c x ≤ y ↔ x ≤ y
-- Mathlib/Analysis/LocallyConvex/Polar.lean
@[simp]
theorem polar_empty : B.polar ∅ = Set.univ
-- Mathlib/Analysis/Convex/Side.lean
theorem wOppSide_vadd_left_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WOppSide (v +ᵥ x) y ↔ s.WOppSide x y
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem Complex.logDeriv_cosh : logDeriv (Complex.cosh) = Complex.tanh
-- Mathlib/Computability/TMToPartrec.lean
theorem tr_pred (q₁ q₂) : tr (Λ'.pred q₁ q₂) = pop' main (branch (fun s => s = some Γ'.bit0)
    ((push rev fun _ => Γ'.bit1) <| goto fun _ => Λ'.pred q₁ q₂) <|
    branch (fun s => natEnd s.iget) (goto fun _ => q₁)
      (peek' main <|
        branch (fun s => natEnd s.iget) (goto fun _ => unrev q₂)
          ((push rev fun _ => Γ'.bit0) <| goto fun _ => unrev q₂)))
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem quotMapOfEquivQuotMapCMapSpanMk_symm_mk (x : AdjoinRoot f) :
    (quotMapOfEquivQuotMapCMapSpanMk I f).symm
        (Ideal.Quotient.mk ((I.map (C : R →+* R[X])).map (Ideal.Quotient.mk (span {f}))) x) =
      Ideal.Quotient.mk (I.map (of f)) x
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_inj {s₁ s₂ : Finset α} : (s₁ : Set α) = s₂ ↔ s₁ = s₂
-- Mathlib/Algebra/Polynomial/Module/FiniteDimensional.lean
theorem isTorsion_of_aeval_eq_zero [CommSemiring R] [NoZeroDivisors R] [Semiring A] [Algebra R A]
    [AddCommMonoid M] [Module A M] [Module R M] [IsScalarTower R A M]
    {p : R[X]} (h : aeval a p = 0) (h' : p ≠ 0) :
    IsTorsion R[X] (AEval R M a)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma nonempty_uIcc : [[a, b]].Nonempty
-- Mathlib/Data/List/MinMax.lean
theorem argmax_concat (f : α → β) (a : α) (l : List α) :
    argmax f (l ++ [a]) =
      Option.casesOn (argmax f l) (some a) fun c => if f c < f a then some a else some c
-- Mathlib/FieldTheory/Galois.lean
/-- Equivalent characterizations of a Galois extension of finite degree-/
theorem tfae [FiniteDimensional F E] : List.TFAE [
    IsGalois F E,
    IntermediateField.fixedField (⊤ : Subgroup (E ≃ₐ[F] E)) = ⊥,
    Fintype.card (E ≃ₐ[F] E) = finrank F E,
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E]
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Set α)
-- Mathlib/Order/Directed.lean
/-- `IsDirected α r` states that for any elements `a`, `b` there exists an element `c` such that
`r a c` and `r b c`. -/
class IsDirected (α : Type*) (r : α → α → Prop) : Prop where
  /-- For every pair of elements `a` and `b` there is a `c` such that `r a c` and `r b c` -/
  directed (a b : α) : ∃ c, r a c ∧ r b c
-- Mathlib/Order/UpperLower/Basic.lean
@[simp 1100, norm_cast]
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ t ≤ s
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_eq_max_inv : |a|ₘ = max a a⁻¹
-- Mathlib/Data/Set/Finite.lean
theorem finite_coe_iff {s : Set α} : Finite s ↔ s.Finite
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem mul_self_le_self {I : FractionalIdeal S P} (hI : I ≤ 1) : I * I ≤ I
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp] theorem mk_succ_pow (m : ℕ) (x : K) : mk K p ⟨m + 1, x ^ p⟩ = mk K p ⟨m, x⟩
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem SimpleFunc.exists_lt_lintegral_simpleFunc_of_lt_lintegral {m : MeasurableSpace α}
    {μ : Measure α} [SigmaFinite μ] {f : α →ₛ ℝ≥0} {L : ℝ≥0∞} (hL : L < ∫⁻ x, f x ∂μ) :
    ∃ g : α →ₛ ℝ≥0, (∀ x, g x ≤ f x) ∧ ∫⁻ x, g x ∂μ < ∞ ∧ L < ∫⁻ x, g x ∂μ
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected theorem map_of_continuous [BorelSpace α] [MeasurableSpace β] [TopologicalSpace β]
    [BorelSpace β] [h : InnerRegular μ] {f : α → β} (hf : Continuous f) :
    InnerRegular (Measure.map f μ)
-- Mathlib/Order/Filter/Extr.lean
theorem isMaxOn_dual_iff : IsMaxOn (toDual ∘ f) s a ↔ IsMinOn f s a
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem map_add (e : M₁ ≃SL[σ₁₂] M₂) (x y : M₁) : e (x + y) = e x + e y
-- Mathlib/Algebra/Vertex/HVertexOperator.lean
/-- The coefficient of a heterogeneous vertex operator, viewed as a formal power series with
coefficients in linear maps. -/
@[simps]
def coeff (A : HVertexOperator Γ R V W) (n : Γ) : V →ₗ[R] W
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma llr_tilted_left [SigmaFinite μ] [SigmaFinite ν] (hμν : μ ≪ ν)
    (hf : Integrable (fun x ↦ exp (f x)) μ) (hfν : AEMeasurable f ν) :
    (llr (μ.tilted f) ν) =ᵐ[μ] fun x ↦ f x - log (∫ z, exp (f z) ∂μ) + llr μ ν x
-- Mathlib/Topology/PartitionOfUnity.lean
/-- The `tsupport`s of a partition of unity are locally finite. -/
theorem finite_tsupport : {i | x₀ ∈ tsupport (ρ i)}.Finite
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- When the derivative of a function is nonnegative, then it is automatically integrable,
Ioc version. -/
theorem integrableOn_deriv_of_nonneg (hcont : ContinuousOn g (Icc a b))
    (hderiv : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (g'pos : ∀ x ∈ Ioo a b, 0 ≤ g' x) :
    IntegrableOn g' (Ioc a b)
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_mul : ∀ x y : ℝ≥0∞, ((x * y : ℝ≥0∞) : EReal) = (x : EReal) * y
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConcaveOn.mul (hf : ConcaveOn 𝕜 s f) (hg : ConcaveOn 𝕜 s g)
    (hf₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ f x) (hg₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ g x) (hfg : AntivaryOn f g s) :
    ConcaveOn 𝕜 s (f * g)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
/-- The map `Cocycle K L n → Cocycle K (L⟦a⟧) n'` when `n' + a = n`. -/
@[simps!]
def rightShift (γ : Cocycle K L n) (a n' : ℤ) (hn' : n' + a = n) :
    Cocycle K (L⟦a⟧) n'
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.wbtw {x y z : P} (h : Sbtw R x y z) : Wbtw R x y z
-- Mathlib/Data/Finsupp/Basic.lean
/-- The equivalence between `(α ⊕ β) →₀ γ` and `(α →₀ γ) × (β →₀ γ)`.

This is the `Finsupp` version of `Equiv.sum_arrow_equiv_prod_arrow`. -/
@[simps apply symm_apply]
def sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] : (α ⊕ β →₀ γ) ≃ (α →₀ γ) × (β →₀ γ)
-- Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean
@[reassoc (attr := simp)]
theorem πSummand_comp_cofan_inj_id_comp_PInfty_eq_PInfty (n : ℕ) :
    s.πSummand (IndexSet.id (op [n])) ≫ (s.cofan _).inj (IndexSet.id (op [n])) ≫ PInfty.f n =
      PInfty.f n
-- Mathlib/Tactic/ComputeDegree.lean
/--  The following two lemmas should be viewed as a hand-made "congr"-lemmas.
They achieve the following goals.
* They introduce *two* fresh metavariables replacing the given one `deg`,
  one for the `natDegree ≤` computation and one for the `coeff =` computation.
  This helps `compute_degree`, since it does not "pre-estimate" the degree,
  but it "picks it up along the way".
* They split checking the inequality `coeff p n ≠ 0` into the task of
  finding a value `c` for the `coeff` and then
  proving that this value is non-zero by `coeff_ne_zero`.
-/
theorem natDegree_eq_of_le_of_coeff_ne_zero' {deg m o : ℕ} {c : R} {p : R[X]}
    (h_natDeg_le : natDegree p ≤ m) (coeff_eq : coeff p o = c)
    (coeff_ne_zero : c ≠ 0) (deg_eq_deg : m = deg) (coeff_eq_deg : o = deg) :
    natDegree p = deg
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma ι₁_π : ι₁ K ≫ π K = 𝟙 K
-- Mathlib/Analysis/Normed/Ring/Units.lean
protected theorem nhds (x : Rˣ) : { x : R | IsUnit x } ∈ 𝓝 (x : R)
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- `M` acts pretransitively on `α` if for any `x y` there is `g` such that `g +ᵥ x = y`.
  A transitive action should furthermore have `α` nonempty. -/
class AddAction.IsPretransitive (M α : Type*) [VAdd M α] : Prop where
  /-- There is `g` such that `g +ᵥ x = y`. -/
  exists_vadd_eq : ∀ x y : α, ∃ g : M, g +ᵥ x = y
-- Mathlib/Algebra/Order/Module/Defs.lean
@[simp]
lemma smul_pos_iff_of_pos_right [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    0 < a • b ↔ 0 < a
-- Mathlib/Data/ENNReal/Operations.lean
theorem lt_add_right (ha : a ≠ ∞) (hb : b ≠ 0) : a < a + b
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp, deprecated toNat_ofNat (since := "2024-02-22")]
theorem toNat_zero (n : Nat) : (0#n).toNat = 0
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem isOpen_image (h : X ≃ₜ Y) {s : Set X} : IsOpen (h '' s) ↔ IsOpen s
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem target_subset_preimage_source : e.target ⊆ e.symm ⁻¹' e.source
-- Mathlib/Data/Num/Bitwise.lean
@[simp] lemma shiftr_eq_shiftRight (p : Num) (n : Nat) : p.shiftr n = p >>> n
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma le_comap_range_rTensor (q : Q) :
    LinearMap.range g ≤ (LinearMap.range (rTensor Q g)).comap
      ((TensorProduct.mk R P Q).flip q)
-- Mathlib/Data/Option/NAry.lean
theorem map₂_swap (f : α → β → γ) (a : Option α) (b : Option β) :
    map₂ f a b = map₂ (fun a b => f b a) b a
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem orderIsoPUnitSumLex_toLex (a : α) : orderIsoPUnitSumLex ↑a = toLex (inr a)
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
@[simp]
theorem contLinear_map_vsub (f : P →ᴬ[R] Q) (p₁ p₂ : P) : f.contLinear (p₁ -ᵥ p₂) = f p₁ -ᵥ f p₂
-- Mathlib/Algebra/GCDMonoid/Finset.lean
@[simp]
theorem lcm_dvd_iff {a : α} : s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a
-- Mathlib/Data/Set/Lattice.lean
theorem setOf_exists (p : ι → β → Prop) : { x | ∃ i, p i x } = ⋃ i, { x | p i x }
-- Mathlib/Analysis/LocallyConvex/WeakDual.lean
@[simp]
theorem toSeminorm_apply {f : E →ₗ[𝕜] 𝕜} {x : E} : f.toSeminorm x = ‖f x‖
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem isOrtho_iff_inner_eq {U V : Submodule 𝕜 E} : U ⟂ V ↔ ∀ u ∈ U, ∀ v ∈ V, ⟪u, v⟫ = 0
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma le_mulIndicator_apply (hfg : a ∈ s → y ≤ g a) (hf : a ∉ s → y ≤ 1) :
    y ≤ mulIndicator s g a
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem aequiv_self (h : IsAdjoinRoot S f) : h.aequiv h = AlgEquiv.refl
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem measure_subtype_coe_le_comap (hs : NullMeasurableSet s μ) (t : Set s) :
    μ (((↑) : s → α) '' t) ≤ μ.comap Subtype.val t
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem smul_mem (r : R) (h : x ∈ p) : r • x ∈ p
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_one : xn a1 1 = a
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- A measurable subspace of a standard Borel space is standard Borel. -/
theorem _root_.MeasurableSet.standardBorel {s : Set α} (hs : MeasurableSet s) :
    StandardBorelSpace s
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem Set.Finite.isLindelof_sUnion {S : Set (Set X)} (hf : S.Finite)
    (hc : ∀ s ∈ S, IsLindelof s) : IsLindelof (⋃₀ S)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem ball_disjoint_ball (h : δ + ε ≤ dist x y) : Disjoint (ball x δ) (ball y ε)
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- If `g` is a separable contraction of `f`, then the separable degree of `f` is equal to
the degree of `g`. -/
theorem IsSeparableContraction.natSepDegree_eq {g : Polynomial F} {q : ℕ} [ExpChar F q]
    (h : IsSeparableContraction q f g) : f.natSepDegree = g.natDegree