ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_X : X.toFinsupp = Finsupp.single 1 (1 : R)
-- Mathlib/Order/BooleanGenerators.lean
lemma sSup_le_sSup_iff_of_atoms (hS : BooleanGenerators S) (X Y : Set α) (hX : X ⊆ S) (hY : Y ⊆ S) :
    sSup X ≤ sSup Y ↔ X ⊆ Y
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] : 1 ≤ (a : WithBot α) ↔ 1 ≤ a
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_atTop_of_monotone [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f)
    (h : ∀ b, ∃ a, b ≤ f a) : Tendsto f atTop atTop
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem IsOrtho.comap_iff (f : E ≃ₗᵢ[𝕜] F) {U V : Submodule 𝕜 F} : U.comap f ⟂ V.comap f ↔ U ⟂ V
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
/-- Linear map version of the map `toMultilinearMap` associating to a continuous alternating map
the corresponding multilinear map. -/
@[simps]
def toContinuousMultilinearMapLinear :
    M [⋀^ι]→L[A] N →ₗ[R] ContinuousMultilinearMap A (fun _ : ι => M) N
-- Mathlib/CategoryTheory/Monoidal/FunctorCategory.lean
@[simp]
theorem associator_inv_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).inv : F ⊗ G ⊗ H ⟶ (F ⊗ G) ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).inv
-- .lake/packages/batteries/Batteries/Logic.lean
theorem congr_eqRec {β : α → Sort _} (f : (x : α) → β x → γ) (h : x = x') (y : β x) :
  f x' (Eq.rec y h) = f x y
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_zero_left' (hT : DominatedFinMeasAdditive μ T C)
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) : setToFun μ T hT f = 0
-- Mathlib/Order/Filter/Archimedean.lean
/-- See also `Filter.Tendsto.atTop_mul_const_of_neg` for a version of this lemma for
`LinearOrderedField`s which does not require the `Archimedean` assumption. -/
theorem Tendsto.atTop_mul_const_of_neg' (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atBot
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.base_of_maximal (hI : M.Indep I) (h : ∀ J, M.Indep J → I ⊆ J → I = J) : M.Base I
-- Mathlib/Analysis/BoundedVariation.lean
/-- The variation of a function on the union of two sets `s` and `t`, with `s` to the left of `t`,
bounds the sum of the variations along `s` and `t`. -/
theorem add_le_union (f : α → E) {s t : Set α} (h : ∀ x ∈ s, ∀ y ∈ t, x ≤ y) :
    eVariationOn f s + eVariationOn f t ≤ eVariationOn f (s ∪ t)
-- Mathlib/MeasureTheory/Measure/Tilted.lean
@[simp]
lemma tilted_neg_same [IsProbabilityMeasure μ] (hf : Integrable (fun x ↦ exp (f x)) μ) :
    (μ.tilted f).tilted (-f) = μ
-- Mathlib/Algebra/Ring/Parity.lean
lemma odd_sub' (h : n ≤ m) : Odd (m - n) ↔ (Odd n ↔ Even m)
-- Mathlib/Order/Lattice.lean
/-- Pointwise minimum of two monotone functions is a monotone function. -/
protected theorem min [Preorder α] [LinearOrder β] {f g : α → β} {s : Set α} (hf : MonotoneOn f s)
    (hg : MonotoneOn g s) : MonotoneOn (fun x => min (f x) (g x)) s
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem add_thirds (a : α) : a / 3 + a / 3 + a / 3 = a
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- Counterpart to `List.prod_take_succ` when we have an inverse operation -/
@[to_additive (attr := simp)
  "Counterpart to `List.sum_take_succ` when we have a negation operation"]
theorem prod_drop_succ :
    ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.get ⟨i, p⟩)⁻¹ * (L.drop i).prod
-- Mathlib/Probability/IdentDistrib.lean
protected theorem trans {ρ : Measure δ} {h : δ → γ} (h₁ : IdentDistrib f g μ ν)
    (h₂ : IdentDistrib g h ν ρ) : IdentDistrib f h μ ρ
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_split (f : β → α) (p : β → Prop) :
    ⨆ i, f i = (⨆ (i) (_ : p i), f i) ⊔ ⨆ (i) (_ : ¬p i), f i
-- Mathlib/Data/Multiset/Sort.lean
@[simp]
theorem length_sort {s : Multiset α} : (sort r s).length = card s
-- Mathlib/CategoryTheory/PUnit.lean
/-- The constant functor sending everything to `PUnit.star`. -/
@[simps!]
def star : C ⥤ Discrete PUnit.{w + 1}
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_neg (x : ℝ) : ↑(-x) = (-x : ℝ*)
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem imJ_star : (star a).imJ = -a.imJ
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
@[simp]
theorem Real.Angle.arg_expMapCircle (θ : Real.Angle) :
    (arg (Real.Angle.expMapCircle θ) : Real.Angle) = θ
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The square of `J(a | b)` is `1` when `a` and `b` are coprime. -/
theorem sq_one {a : ℤ} {b : ℕ} (h : a.gcd b = 1) : J(a | b) ^ 2 = 1
-- Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean
@[to_additive]
theorem smul_Lp_sub (c : Mᵈᵐᵃ) : ∀ f g : Lp E p μ, c • (f - g) = c • f - c • g
-- Mathlib/NumberTheory/FLT/Basic.lean
lemma fermatLastTheoremFor_iff_nat {n : ℕ} : FermatLastTheoremFor n ↔ FermatLastTheoremWith ℕ n
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem mk'_mul_coeIdeal_eq_coeIdeal {I J : Ideal R₁} {x y : R₁} (hy : y ∈ R₁⁰) :
    spanSingleton R₁⁰ (IsLocalization.mk' K x ⟨y, hy⟩) * I = (J : FractionalIdeal R₁⁰ K) ↔
      Ideal.span {x} * I = Ideal.span {y} * J
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp]
protected theorem extractLsb_ofFin {n} (x : Fin (2^n)) (hi lo : Nat) :
  extractLsb hi lo (@BitVec.ofFin n x) = .ofNat (hi-lo+1) (x.val >>> lo)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- When every element of a set `s` is bounded by an element of a set `t`, and conversely, then
`s` and `t` have the same supremum. This holds even when the sets may be empty or unbounded. -/
theorem csSup_eq_csSup_of_forall_exists_le {s t : Set α}
    (hs : ∀ x ∈ s, ∃ y ∈ t, x ≤ y) (ht : ∀ y ∈ t, ∃ x ∈ s, y ≤ x) :
    sSup s = sSup t
-- Mathlib/Order/MinMax.lean
theorem MonotoneOn.map_min (hf : MonotoneOn f s) (ha : a ∈ s) (hb : b ∈ s) : f (min a b) =
    min (f a) (f b)
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
theorem analyticSet_range_of_polishSpace {β : Type*} [TopologicalSpace β] [PolishSpace β]
    {f : β → α} (f_cont : Continuous f) : AnalyticSet (range f)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem iff_self_or (a b : Prop) : (a ↔ a ∨ b) ↔ (b → a)
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is continuous on a convex set `D ⊆ ℝ` and `f''` is strictly negative on the
interior, then `f` is strictly concave on `D`.
Note that we don't require twice differentiability explicitly as it already implied by the second
derivative being strictly negative, except at at most one point. -/
theorem strictConcaveOn_of_deriv2_neg {D : Set ℝ} (hD : Convex ℝ D) {f : ℝ → ℝ}
    (hf : ContinuousOn f D) (hf'' : ∀ x ∈ interior D, deriv^[2] f x < 0) :
    StrictConcaveOn ℝ D f
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasDerivWithinAt : HasDerivWithinAt f (f.linear 1) s x
-- Mathlib/Topology/Basic.lean
@[simp]
theorem closure_univ : closure (univ : Set X) = univ
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distance to the empty set is 0 (if you want to have the more reasonable
value `∞` instead, use `EMetric.infEdist`, which takes values in `ℝ≥0∞`) -/
@[simp]
theorem infDist_empty : infDist x ∅ = 0
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
@[simp]
theorem coe_inv : ↑ₘA⁻¹ = adjugate A
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
theorem reflectsMonomorphisms.of_iso {F G : C ⥤ D} [ReflectsMonomorphisms F] (α : F ≅ G) :
    ReflectsMonomorphisms G
-- Mathlib/Algebra/Group/Support.lean
@[to_additive (attr := simp)]
theorem mulSupport_one : (mulSupport fun _ : α => (1 : M)) = ∅
-- Mathlib/Topology/PartitionOfUnity.lean
theorem toPOUFun_eq_mul_prod (i : ι) (x : X) (t : Finset ι)
    (ht : ∀ j, WellOrderingRel j i → f j x ≠ 0 → j ∈ t) :
    f.toPOUFun i x = f i x * ∏ j ∈ t.filter fun j => WellOrderingRel j i, (1 - f j x)
-- Mathlib/Logic/Relator.lean
lemma RightTotal.rel_forall (h : RightTotal R) :
    ((R ⇒ (· → ·)) ⇒ (· → ·)) (fun p => ∀i, p i) (fun q => ∀i, q i)
-- Mathlib/Data/List/Forall2.lean
theorem _root_.Relator.LeftUnique.forall₂ (hr : LeftUnique R) : LeftUnique (Forall₂ R)
-- Mathlib/Data/Part.lean
theorem eq_none_iff {o : Part α} : o = none ↔ ∀ a, a ∉ o
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.card_eq_of_equiv_fintype {s : Finset α} [Fintype β] (i : s ≃ β) :
    s.card = Fintype.card β
-- Mathlib/GroupTheory/SpecificGroups/Quaternion.lean
@[simp]
theorem xa_pow_four (i : ZMod (2 * n)) : xa i ^ 4 = 1
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem inclusion_inclusion {S T U : Subalgebra R A} (hst : S ≤ T) (htu : T ≤ U) (x : S) :
    inclusion htu (inclusion hst x) = inclusion (le_trans hst htu) x
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
/-- Turán-maximality with `0 < r` transfers across graph isomorphisms. -/
theorem IsTuranMaximal.iso {W : Type*} [Fintype W] [DecidableEq W] {H : SimpleGraph W}
    [DecidableRel H.Adj] (h : G.IsTuranMaximal r) (f : G ≃g H) (hr : 0 < r) : H.IsTuranMaximal r
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem map_sub [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x - y)) = f (update m i x) - f (update m i y)
-- Mathlib/Order/Filter/Partial.lean
theorem rcomap'_sets (r : Rel α β) (f : Filter β) :
    (rcomap' r f).sets = Rel.image (fun s t => r.preimage s ⊆ t) f.sets
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem isBounded_of_image2_right {f : α → β → γ} {K₂ : ℝ≥0} (hf : ∀ a, AntilipschitzWith K₂ (f a))
    {s : Set α} {t : Set β} (hst : IsBounded (Set.image2 f s t)) : IsBounded s ∨ IsBounded t
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[ext high]
theorem ext_to_ring (f g : A →ₗc[R] R) : f = g
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_le_comap_smul (fₗ : N →ₗ[R] N₂) (c : R) : comap fₗ qₗ ≤ comap (c • fₗ) qₗ
-- Mathlib/Topology/NhdsSet.lean
@[simp]
theorem nhdsSet_insert (x : X) (s : Set X) : 𝓝ˢ (insert x s) = 𝓝 x ⊔ 𝓝ˢ s
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
theorem count_coe_nonneg (J : Ideal R) : 0 ≤ count K v J
-- Mathlib/Topology/Covering.lean
protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
    IsLocalHomeomorphOn f (f ⁻¹' s)
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem finInsepDegree_bot : finInsepDegree F (⊥ : IntermediateField F E) = 1
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
theorem hext {X Y : PresheafedSpace C} (α β : Hom X Y) (w : α.base = β.base) (h : HEq α.c β.c) :
    α = β
-- Mathlib/Data/Set/Sigma.lean
@[simp] theorem mem_sigma_iff : x ∈ s.sigma t ↔ x.1 ∈ s ∧ x.2 ∈ t x.1
-- Mathlib/Data/Finset/Image.lean
/-- If a `Finset` of a subtype is converted to the main type with
`Embedding.subtype`, the result is a subset of the set giving the
subtype. -/
theorem map_subtype_subset {t : Set α} (s : Finset t) : ↑(s.map (Embedding.subtype _)) ⊆ t
-- Mathlib/Analysis/Convex/Cone/InnerDual.lean
@[simp]
theorem innerDualCone_empty : (∅ : Set H).innerDualCone = ⊤
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem coe_srange : (srange f : Set S) = Set.range f
-- Mathlib/Analysis/Convex/Function.lean
/-- For a function on a convex set in a linearly ordered space (where the order and the algebraic
structures aren't necessarily compatible), in order to prove that it is strictly concave it suffices
to verify the inequality `a • f x + b • f y < f (a • x + b • y)` for `x < y` and positive `a`, `b`.
The main use case is `E = 𝕜` however one can apply it, e.g., to `𝕜^n` with lexicographic order. -/
theorem LinearOrder.strictConcaveOn_of_lt (hs : Convex 𝕜 s)
    (hf : ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → x < y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 →
      a • f x + b • f y < f (a • x + b • y)) :
    StrictConcaveOn 𝕜 s f
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem CliqueFree.mono (h : m ≤ n) : G.CliqueFree m → G.CliqueFree n
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) =
      ((𝓤 α).comap fun p : (α × β) × α × β => (p.1.1, p.2.1)) ⊓
        (𝓤 β).comap fun p : (α × β) × α × β => (p.1.2, p.2.2)
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_rat_sub_iff : Irrational (q - x) ↔ Irrational x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_lt_cos_of_nonneg_of_le_pi_div_two {x y : ℝ} (hx₁ : 0 ≤ x) (hy₂ : y ≤ π / 2)
    (hxy : x < y) : cos y < cos x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem eq_or_mem_of_mem_insert {l : List α} (h : a ∈ l.insert b) : a = b ∨ a ∈ l
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
/-- Shortcut lemma for `Matrix.toLin'_mul` and `LinearMap.comp_apply` -/
theorem Matrix.toLin'_mul_apply [Fintype m] [DecidableEq m] (M : Matrix l m R) (N : Matrix m n R)
    (x) : Matrix.toLin' (M * N) x = Matrix.toLin' M (Matrix.toLin' N x)
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
@[simp]
theorem withDensity_zero : μ.withDensity 0 = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sup_sum {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal) :
    sup.{max u v, w} f =
      max (sup.{u, max v w} fun a => f (Sum.inl a)) (sup.{v, max u w} fun b => f (Sum.inr b))
-- Mathlib/Dynamics/Newton.lean
/-- If `x` is almost a root of `P` in the sense that `P(x)` is nilpotent (and `P'(x)` is a
unit) then we may write `x` as a sum `x = n + r` where `n` is nilpotent and `r` is a root of `P`.
Moreover, `n` and `r` are unique.

This can be used to prove the Jordan-Chevalley decomposition of linear endomorphims. -/
theorem exists_unique_nilpotent_sub_and_aeval_eq_zero
    (h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) :
    ∃! r, IsNilpotent (x - r) ∧ aeval r P = 0
-- .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean
@[simp] theorem ForInStep.run_yield : (ForInStep.yield a).run = a
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem le_symmDiff_iff_right : b ≤ a ∆ b ↔ Disjoint a b
-- Mathlib/CategoryTheory/Category/Bipointed.lean
/-- Composition of morphisms of `Bipointed`. -/
@[simps]
def comp {X Y Z : Bipointed.{u}} (f : Bipointed.Hom X Y) (g : Bipointed.Hom Y Z) :
    Bipointed.Hom X Z
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem add_le_add_left {I J : FractionalIdeal S P} (hIJ : I ≤ J) (J' : FractionalIdeal S P) :
    J' + I ≤ J' + J
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem isPath_reverse_iff {u v : V} (p : G.Walk u v) : p.reverse.IsPath ↔ p.IsPath
-- Mathlib/Algebra/BigOperators/Ring.lean
/-- The product over a sum can be written as a sum over the product of sets, `Finset.Pi`.
  `Finset.prod_univ_sum` is an alternative statement when the product is over `univ`. -/
lemma prod_sum (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    ∏ a ∈ s, ∑ b ∈ t a, f a b = ∑ p ∈ s.pi t, ∏ x ∈ s.attach, f x.1 (p x.1 x.2)
-- Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
theorem appLE (H : P f) (U : Y.affineOpens) (V : X.affineOpens) (e) : Q (f.appLE U V e)
-- Mathlib/Data/List/Perm.lean
theorem Perm.dropSlice_inter [DecidableEq α] {xs ys : List α} (n m : ℕ) (h : xs ~ ys)
    (h' : ys.Nodup) : List.dropSlice n m xs ~ ys ∩ List.dropSlice n m xs
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp]
theorem iteratedPDeriv_one (m : Fin 1 → E) (f : 𝓢(E, F)) :
    iteratedPDeriv 𝕜 m f = pderivCLM 𝕜 (m 0) f
-- Mathlib/Topology/Order.lean
theorem le_iff_nhds {α : Type*} (t t' : TopologicalSpace α) :
    t ≤ t' ↔ ∀ x, @nhds α t x ≤ @nhds α t' x
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem transpose_transpose (M : Matrix m n α) : Mᵀᵀ = M
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
@[simp]
theorem val_eq_to_measure (ν : ProbabilityMeasure Ω) : ν.val = (ν : Measure Ω)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem lower_le_lower (hJ : J ∈ π) : I.lower ≤ J.lower
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
lemma homEquiv_apply (h : IsColimit t) {W : C} (f : t.pt ⟶ W) :
    h.homEquiv W f = (t.extend f).ι
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem dist_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    dist (c • x) (c • y) = dist x y
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive zsmul_zero, simp]
lemma one_zpow : ∀ n : ℤ, (1 : α) ^ n = 1
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma prod.lift_snd {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    prod.lift τ₁ τ₂ ≫ prod.snd = τ₂
-- Mathlib/Data/Finset/Prod.lean
theorem Nonempty.snd (h : (s ×ˢ t).Nonempty) : t.Nonempty
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepFun.ae_eq {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    {f' : Ω → β} {g' : Ω → β'} (hfg : IndepFun f g μ)
    (hf : f =ᵐ[μ] f') (hg : g =ᵐ[μ] g') : IndepFun f' g' μ
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualBasis_repr (l : Dual R M) (i : ι) : b.dualBasis.repr l i = l (b i)
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem lsum_symm_apply (f : (α →₀ M) →ₗ[R] N) (x : α) : (lsum S).symm f x = f.comp (lsingle x)
-- Mathlib/MeasureTheory/Integral/Average.lean
@[simp]
theorem average_const (μ : Measure α) [IsFiniteMeasure μ] [h : NeZero μ] (c : E) :
    ⨍ _x, c ∂μ = c
-- Mathlib/Order/Rel/GaloisConnection.lean
theorem leftDual_rightDual_le_of_le {I I' : Set β} (h : I' ∈ R.rightFixedPoints) (h₁ : I ≤ I') :
    R.leftDual (R.rightDual I) ≤ I'
-- Mathlib/Computability/TuringMachine.lean
theorem eval_maximal {σ} {f : σ → Option σ} {a b} (h : b ∈ eval f a) {c} : Reaches f b c ↔ c = b
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableOn.pow (ha : DifferentiableOn 𝕜 a s) (n : ℕ) :
    DifferentiableOn 𝕜 (fun x => a x ^ n) s
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
theorem le_op_iff {S₁ : Subalgebra R Aᵐᵒᵖ} {S₂ : Subalgebra R A} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂
-- Mathlib/GroupTheory/Solvable.lean
theorem Equiv.Perm.not_solvable (X : Type*) (hX : 5 ≤ Cardinal.mk X) :
    ¬IsSolvable (Equiv.Perm X)
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- Assume that a function `f` has a derivative at every point of a set `s`. Then one may cover `s`
with countably many closed sets `t n` on which `f` is well approximated by linear maps `A n`. -/
theorem exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt [SecondCountableTopology F]
    (f : E → F) (s : Set E) (f' : E → E →L[ℝ] F) (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x)
    (r : (E →L[ℝ] F) → ℝ≥0) (rpos : ∀ A, r A ≠ 0) :
    ∃ (t : ℕ → Set E) (A : ℕ → E →L[ℝ] F),
      (∀ n, IsClosed (t n)) ∧
        (s ⊆ ⋃ n, t n) ∧
          (∀ n, ApproximatesLinearOn f (A n) (s ∩ t n) (r (A n))) ∧
            (s.Nonempty → ∀ n, ∃ y ∈ s, A n = f' y)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_enum (f : α → β) (l : List α) : map (Prod.map id f) (enum l) = enum (map f l)
-- Mathlib/Algebra/Ring/CentroidHom.lean
theorem toEnd_smul (m : M) (x : CentroidHom α) : (m • x).toEnd = m • x.toEnd
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
@[simp]
theorem integralClosure_eq_bot [NoZeroSMulDivisors R A] [Nontrivial A] : integralClosure R A = ⊥
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem vsub_union : s -ᵥ (t₁ ∪ t₂) = s -ᵥ t₁ ∪ (s -ᵥ t₂)
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem support_bernoulli : (bernoulli p h).support = { b | cond b (p ≠ 0) (p ≠ 1) }
-- Mathlib/Analysis/NormedSpace/MazurUlam.lean
@[simp]
theorem toRealLinearIsometryEquiv_symm_apply (f : E ≃ᵢ F) (y : F) :
    (f.toRealLinearIsometryEquiv.symm : F → E) y = f.symm (y + f 0)
-- Mathlib/Algebra/Regular/Basic.lean
theorem Commute.isRightRegular_iff {a : R} (ca : ∀ b, Commute a b) :
    IsRightRegular a ↔ IsLeftRegular a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma cpow_ofReal_re (x : ℂ) (y : ℝ) : (x ^ (y : ℂ)).re = (abs x) ^ y * Real.cos (arg x * y)
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_union_inter_subset {f : α → α → β} {s t : Finset α} (hf : ∀ a b, f a b = f b a) :
    image₂ f (s ∪ t) (s ∩ t) ⊆ image₂ f s t
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem vComp_apply_coe (t : Icc v.tMin v.tMax) : f.vComp t = v t (f t)
-- Mathlib/Data/ENNReal/Operations.lean
/-- Seeing `ℝ≥0∞` as `ℝ≥0` does not change their sum, unless one of the `ℝ≥0∞` is
infinity -/
theorem toNNReal_sum {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ∞) :
    ENNReal.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, ENNReal.toNNReal (f a)
-- Mathlib/Probability/Independence/Conditional.lean
@[to_additive]
lemma iCondIndepFun.indepFun_div_div (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (f i / f j) (f k / f l) μ
-- Mathlib/Order/Bounds/Basic.lean
theorem isGLB_empty [OrderTop α] : IsGLB ∅ (⊤ : α)
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[simp]
theorem toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f
-- Mathlib/Data/Matroid/Constructions.lean
@[simp] theorem freeOn_dual_eq : (freeOn E)✶ = loopyOn E
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasStrictDerivAt.neg (h : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => -f x) (-f') x
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
protected theorem Connected.pos_dist_of_ne (hconn : G.Connected) (hne : u ≠ v) :
    0 < G.dist u v
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem equiv_symm_eps :
    CliffordAlgebraDualNumber.equiv.symm (eps : R[ε]) = ι (0 : QuadraticForm R R) 1
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.toLin'_apply' (M : Matrix m n R) : Matrix.toLin' M = M.mulVecLin
-- Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean
theorem isUnital_leftAdd : EckmannHilton.IsUnital (· +ₗ ·) 0
-- Mathlib/Data/Sign.lean
@[simp]
theorem sign_nonneg_iff : 0 ≤ sign a ↔ 0 ≤ a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_union_congr_of_subset {t₁ t₂ : Set α} (hs : s₁ ⊆ s₂) (hsμ : μ s₂ ≤ μ s₁)
    (ht : t₁ ⊆ t₂) (htμ : μ t₂ ≤ μ t₁) : μ (s₁ ∪ t₁) = μ (s₂ ∪ t₂)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem AEMeasurable.norm {f : β → α} {μ : Measure β} (hf : AEMeasurable f μ) :
    AEMeasurable (fun a => norm (f a)) μ
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
/-- Generalization of `IsIntegral.of_mem_closure` bootstrapped up from that lemma -/
theorem IsIntegral.of_mem_closure' (G : Set A) (hG : ∀ x ∈ G, IsIntegral R x) :
    ∀ x ∈ Subring.closure G, IsIntegral R x
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem exp_bound {x : ℝ} (hx : |x| ≤ 1) {n : ℕ} (hn : 0 < n) :
    |exp x - ∑ m ∈ range n, x ^ m / m.factorial| ≤ |x| ^ n * (n.succ / (n.factorial * n))
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The (open) thickening of a set contains the closure of the set. -/
theorem closure_subset_thickening {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) :
    closure E ⊆ thickening δ E
-- Mathlib/Topology/Basic.lean
theorem nhds_basis_closeds (x : X) : (𝓝 x).HasBasis (fun s : Set X => x ∉ s ∧ IsClosed s) compl
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem coe_top : ((⊤ : HomogeneousIdeal 𝒜) : Set A) = univ
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_openSegment (a b : E) : Convex 𝕜 (openSegment 𝕜 a b)
-- Mathlib/Order/Filter/EventuallyConst.lean
lemma eventuallyConst_atTop_nat {f : ℕ → α} :
    EventuallyConst f atTop ↔ ∃ n, ∀ m, n ≤ m → f (m + 1) = f m
-- Mathlib/LinearAlgebra/RootSystem/RootPositive.lean
@[simp]
lemma apply_root_root_zero_iff : B (P.root i) (P.root j) = 0 ↔ P.pairing i j = 0
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_equiv (e : ι ≃ ι') {f : ι' → M} :
    LinearIndependent R (f ∘ e) ↔ LinearIndependent R f
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
@[simp] -- Porting note: removed `norm_cast`
theorem coe_to_affineMap (f : P →ᴬ[R] Q) : ((f : P →ᵃ[R] Q) : P → Q) = f
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem Measurable.mul_const [MeasurableMul M] (hf : Measurable f) (c : M) :
    Measurable fun x => f x * c
-- Mathlib/Topology/Sets/Opens.lean
protected theorem comap_comp (g : C(β, γ)) (f : C(α, β)) :
    comap (g.comp f) = (comap f).comp (comap g)
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem IsClique.subset (h : t ⊆ s) : G.IsClique s → G.IsClique t