ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Integral/PeakFunction.lean
/-- If a sequence of peak functions `φᵢ` converges uniformly to zero away from a point `x₀` and its
integral on some finite-measure neighborhood of `x₀` converges to `1`, and `g` is integrable and
has a limit `a` at `x₀`, then `∫ φᵢ • g` converges to `a`. Version localized to a subset. -/
theorem tendsto_setIntegral_peak_smul_of_integrableOn_of_tendsto
    (hs : MeasurableSet s) {t : Set α} (ht : MeasurableSet t) (hts : t ⊆ s) (h'ts : t ∈ 𝓝[s] x₀)
    (h't : μ t ≠ ∞) (hnφ : ∀ᶠ i in l, ∀ x ∈ s, 0 ≤ φ i x)
    (hlφ : ∀ u : Set α, IsOpen u → x₀ ∈ u → TendstoUniformlyOn φ 0 l (s \ u))
    (hiφ : Tendsto (fun i ↦ ∫ x in t, φ i x ∂μ) l (𝓝 1))
    (h'iφ : ∀ᶠ i in l, AEStronglyMeasurable (φ i) (μ.restrict s))
    (hmg : IntegrableOn g s μ) (hcg : Tendsto g (𝓝[s] x₀) (𝓝 a)) :
    Tendsto (fun i : ι ↦ ∫ x in s, φ i x • g x ∂μ) l (𝓝 a)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem ite_empty_left (t s : Set α) : t.ite ∅ s = s \ t
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem nndist_center_homothety (p₁ p₂ : P) (c : 𝕜) :
    nndist p₁ (homothety p₁ c p₂) = ‖c‖₊ * nndist p₁ p₂
-- Mathlib/Data/Nat/Size.lean
theorem size_pow {n : ℕ} : size (2 ^ n) = n + 1
-- Mathlib/RingTheory/Localization/Submodule.lean
theorem coeSubmodule_span_singleton (x : R) :
    coeSubmodule S (Ideal.span {x}) = Submodule.span R {(algebraMap R S) x}
-- Mathlib/GroupTheory/Perm/Finite.lean
theorem Disjoint.isConj_mul [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ)
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem nat_add_continuum (n : ℕ) : ↑n + 𝔠 = 𝔠
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoUniformly_iff_tendstoUniformlyOnFilter :
    TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepSets.bInter {s : ι → Set (Set Ω)} {s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} {u : Set ι} (h : ∃ n ∈ u, IndepSets (s n) s' κ μ) :
    IndepSets (⋂ n ∈ u, s n) s' κ μ
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[simp]
theorem memℒp_zero_iff_aestronglyMeasurable {f : α → E} :
    Memℒp f 0 μ ↔ AEStronglyMeasurable f μ
-- Mathlib/Data/Rel.lean
theorem preimage_def (s : Set β) : preimage r s = { x | ∃ y ∈ s, r x y }
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arctan_eq_of_tan_eq {x y : ℝ} (h : tan x = y) (hx : x ∈ Ioo (-(π / 2)) (π / 2)) :
    arctan y = x
-- Mathlib/NumberTheory/ClassNumber/Finite.lean
theorem ne_bot_of_prod_finsetApprox_mem (J : Ideal S)
    (h : algebraMap _ _ (∏ m ∈ finsetApprox bS adm, m) ∈ J) : J ≠ ⊥
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem swap_prod_mk {a : α} {b : β} : swap (a, b) = (b, a)
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_add_of_principal_mul_opow {o b : Ordinal} (hb : 1 < b)
    (ho : Principal (· * ·) (b^o)) : Principal (· + ·) o
-- Mathlib/Data/List/Sort.lean
theorem Sorted.orderedInsert (a : α) : ∀ l, Sorted r l → Sorted r (orderedInsert r a l)
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem IsBlock.smul_eq_or_disjoint {B : Set X} (hB : IsBlock G B) (g : G) :
    g • B = B ∨ Disjoint (g • B) B
-- Mathlib/Order/Defs.lean
@[trans]
theorem gt_of_ge_of_gt {a b c : α} (h₁ : a ≥ b) (h₂ : b > c) : a > c
-- Mathlib/NumberTheory/SumTwoSquares.lean
/-- **Fermat's theorem on the sum of two squares**. Every prime not congruent to 3 mod 4 is the sum
of two squares. Also known as **Fermat's Christmas theorem**. -/
theorem Nat.Prime.sq_add_sq {p : ℕ} [Fact p.Prime] (hp : p % 4 ≠ 3) :
    ∃ a b : ℕ, a ^ 2 + b ^ 2 = p
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem dropFun_RelLast' {α : TypeVec n} {β} (R : β → β → Prop) :
    dropFun (RelLast' α R) = repeatEq α
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem tendsto_filterAt_iff {ι : Type*} {l : Filter ι} {f : ι → Set α} {x : α} :
    Tendsto f l (v.filterAt x) ↔
      (∀ᶠ i in l, f i ∈ v.setsAt x) ∧ ∀ ε > (0 : ℝ), ∀ᶠ i in l, f i ⊆ closedBall x ε
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- Given a measurable set `s`, then `μ (s ∩ closedBall x r) / μ (closedBall x r)` converges when
`r` tends to `0`, for almost every `x`. The limit is `1` for `x ∈ s` and `0` for `x ∉ s`.
This shows that almost every point of `s` is a Lebesgue density point for `s`.
A version for non-measurable sets holds, but it only gives the first conclusion,
see `ae_tendsto_measure_inter_div`. -/
theorem ae_tendsto_measure_inter_div_of_measurableSet (μ : Measure β) [IsLocallyFiniteMeasure μ]
    {s : Set β} (hs : MeasurableSet s) :
    ∀ᵐ x ∂μ,
      Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0)
        (𝓝 (s.indicator 1 x))
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem anyM_stop_le_start [Monad m] (p : α → m Bool) (as : Array α) (start stop)
    (h : min stop as.size ≤ start) : anyM p as start stop = pure false
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem circulant_injective [AddGroup n] : Injective (circulant : (n → α) → Matrix n n α)
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
lemma orderOf_generator_eq_natCard (h : ∀ x, x ∈ Subgroup.zpowers a) : orderOf a = Nat.card α
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem ContMDiff.prod (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n fun x ↦ ∏ i ∈ t, f i x
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem sum_rpow_le_of_tendsto (hp : p ≠ ∞) {C : ℝ} {F : ι → lp E p} (hCF : ∀ᶠ k in l, ‖F k‖ ≤ C)
    {f : ∀ a, E a} (hf : Tendsto (id fun i => F i : ι → ∀ a, E a) l (𝓝 f)) (s : Finset α) :
    ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal
-- Mathlib/Algebra/TrivSqZeroExt.lean
/-- The canonical `R`-linear projection `TrivSqZeroExt R M → M`. -/
@[simps apply]
def sndHom [Semiring R] [AddCommMonoid M] [Module R M] : tsze R M →ₗ[R] M
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma ofUpperSet_inj {a b : WithUpperSet α} : ofUpperSet a = ofUpperSet b ↔ a = b
-- Mathlib/RingTheory/Localization/Away/AdjoinRoot.lean
theorem IsLocalization.Away.finitePresentation (r : R) {S} [CommRing S] [Algebra R S]
    [IsLocalization.Away r S] : Algebra.FinitePresentation R S
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem ofNat'_one : Num.ofNat' 1 = 1
-- Mathlib/CategoryTheory/EqToHom.lean
theorem congr_obj {F G : C ⥤ D} (h : F = G) (X) : F.obj X = G.obj X
-- Mathlib/Algebra/Group/Units/Equiv.lean
@[to_additive]
protected
theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem hasFDerivAt_pi :
    HasFDerivAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') x ↔
      ∀ i, HasFDerivAt (φ i) (φ' i) x
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem star_coe : star (x : ℍ[R,c₁,c₂]) = x
-- Mathlib/Combinatorics/Colex.lean
lemma toColex_lt_toColex :
    toColex s < toColex t ↔ s ≠ t ∧ ∀ ⦃a⦄, a ∈ s → a ∉ t → ∃ b, b ∈ t ∧ b ∉ s ∧ a ≤ b
-- Mathlib/Analysis/Asymptotics/Theta.lean
lemma IsLittleO.add_isTheta {f₁ f₂ : α → E'} {g : α → F}
    (ho : f₁ =o[l] g) (hΘ : f₂ =Θ[l] g) : (f₁ + f₂) =Θ[l] g
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
lemma iso_map_bijective : Function.Bijective (iso_map C J)
-- Mathlib/Algebra/Order/Floor.lean
theorem sub_floor_div_mul_lt (a : k) (hb : 0 < b) : a - ⌊a / b⌋ * b < b
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
@[simp, norm_cast] lemma ofRat_ratCast (q : ℚ) : ofRat (q : β) = (q : Cauchy abv)
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[simp]
theorem isColimitCoforkOfCokernelCofork_desc {c : CokernelCofork (f - g)} (i : IsColimit c)
    (s : Cofork f g) :
    (isColimitCoforkOfCokernelCofork i).desc s = i.desc (cokernelCoforkOfCofork s)
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
lemma comparison_full [R.Full] {L : C ⥤ D} (adj : L ⊣ R) :
    (Monad.comparison adj).Full
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast] lemma coe_eq_top [Top α] {a : α} : (a : WithBot α) = ⊤ ↔ a = ⊤
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_inl [Zero M] (r : R) : (inl r : tsze R M).fst = r
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
@[simp]
theorem IsDedekindDomain.quotientEquivPiFactors_mk {I : Ideal R} (hI : I ≠ ⊥) (x : R) :
    IsDedekindDomain.quotientEquivPiFactors hI (Ideal.Quotient.mk I x) = fun _P =>
      Ideal.Quotient.mk _ x
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
/-- Given a right homology map data `ψ : RightHomologyMapData φ h₁ h₂` such that
both right homology data `h₁` and `h₂` are preserved by a functor `F`, this is
the induced right homology map data for the morphism `F.mapShortComplex.map φ`. -/
@[simps]
def RightHomologyMapData.map {φ : S₁ ⟶ S₂} {h₁ : S₁.RightHomologyData}
    {h₂ : S₂.RightHomologyData} (ψ : RightHomologyMapData φ h₁ h₂) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [h₁.IsPreservedBy F] [h₂.IsPreservedBy F] :
    RightHomologyMapData (F.mapShortComplex.map φ) (h₁.map F) (h₂.map F)
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
@[simp]
theorem mkMetric_toOuterMeasure (m : ℝ≥0∞ → ℝ≥0∞) :
    (mkMetric m : Measure X).toOuterMeasure = OuterMeasure.mkMetric m
-- Mathlib/CategoryTheory/Types.lean
theorem naturality (f : X ⟶ Y) (x : F.obj X) : σ.app Y ((F.map f) x) = (G.map f) (σ.app X x)
-- Mathlib/Data/List/Lattice.lean
theorem forall_mem_union : (∀ x ∈ l₁ ∪ l₂, p x) ↔ (∀ x ∈ l₁, p x) ∧ ∀ x ∈ l₂, p x
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
private theorem abs_density_star_sub_density_le_eps (hPε : ↑100 ≤ ↑4 ^ P.parts.card * ε ^ 5)
    (hε₁ : ε ≤ 1) {hU : U ∈ P.parts} {hV : V ∈ P.parts} (hUV' : U ≠ V) (hUV : ¬G.IsUniform ε U V) :
    |(G.edgeDensity ((star hP G ε hU V).biUnion id) ((star hP G ε hV U).biUnion id) : ℝ) -
      G.edgeDensity (G.nonuniformWitness ε U V) (G.nonuniformWitness ε V U)| ≤ ε / 5
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma max_mul_mul_le_max_mul_max [PosMulMono α] [MulPosMono α] (b c : α) (ha : 0 ≤ a) (hd : 0 ≤ d) :
    max (a * b) (d * c) ≤ max a c * max d b
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
/-- If `s` is a `Finset`, then the measure of its preimage can be found as the sum of measures
of the fibers `f ⁻¹' {y}`. -/
theorem sum_measure_preimage_singleton (s : Finset β) {f : α → β}
    (hf : ∀ y ∈ s, MeasurableSet (f ⁻¹' {y})) : (∑ b ∈ s, μ (f ⁻¹' {b})) = μ (f ⁻¹' ↑s)
-- Mathlib/Analysis/NormedSpace/QuaternionExponential.lean
theorem re_exp (q : ℍ[ℝ]) : (exp ℝ q).re = exp ℝ q.re * Real.cos ‖q - q.re‖
-- Mathlib/Data/Set/Card.lean
theorem ncard_eq_three : s.ncard = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem smul_mem_smul_finset_iff (a : α) : a • b ∈ a • s ↔ b ∈ s
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
lemma prod_Ioi_mul_eq_prod_Ici (a : α) : (∏ x ∈ Ioi a, f x) * f a = ∏ x ∈ Ici a, f x
-- Mathlib/Algebra/Homology/ExactSequence.lean
/-- `F : ComposableArrows C n` is a complex if all compositions of
two consecutive arrows are zero. -/
structure IsComplex : Prop where
  /-- the composition of two consecutive arrows is zero -/
  zero (i : ℕ) (hi : i + 2 ≤ n := by omega) :
    S.map' i (i + 1) ≫ S.map' (i + 1) (i + 2) = 0
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma sq_le_sq' (h1 : -b ≤ a) (h2 : a ≤ b) : a ^ 2 ≤ b ^ 2
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem sdiff_inter_self_left (s t : Finset α) : s \ (s ∩ t) = s \ t
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem Ico_succ_left (a b : α) : Ico (succ a) b = Ioo a b
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
lemma restrictionApp_apply {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R) (x : M.obj X) :
    restrictionApp f M x = M.map f x
-- Mathlib/Data/Finset/Basic.lean
theorem mem_insert_self (a : α) (s : Finset α) : a ∈ insert a s
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.span_range_eq_ideal :
    Ideal.span (Set.range fun s : S => (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)) =
      KaehlerDifferential.ideal R S
-- Mathlib/RepresentationTheory/Rep.lean
@[simp]
theorem homEquiv_def (A B C : Rep k G) : (ihom.adjunction A).homEquiv B C = Rep.homEquiv A B C
-- Mathlib/Order/Filter/Basic.lean
theorem Eventually.congr {f : Filter α} {p q : α → Prop} (h' : ∀ᶠ x in f, p x)
    (h : ∀ᶠ x in f, p x ↔ q x) : ∀ᶠ x in f, q x
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem restrict_Ioo_eq_restrict_Icc : μ.restrict (Ioo a b) = μ.restrict (Icc a b)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand the square -/
theorem norm_sub_sq (x y : E) : ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * re ⟪x, y⟫ + ‖y‖ ^ 2
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem neg_toProd (a : 𝓜(𝕜, A)) : (-a).toProd = -a.toProd
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem le_aleph0_iff_set_countable {s : Set α} : #s ≤ ℵ₀ ↔ s.Countable
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem image_iff {f : E →ₗ.[R] F} {x : E} {y : F} (hx : x ∈ f.domain) :
    y = f ⟨x, hx⟩ ↔ (x, y) ∈ f.graph
-- Mathlib/Topology/ContinuousFunction/CocompactMap.lean
/-- Preimages of compact closed sets are compact under a cocompact continuous map. -/
theorem isCompact_preimage_of_isClosed (f : CocompactMap α β)
    ⦃s : Set β⦄ (hs : IsCompact s) (h's : IsClosed s) :
    IsCompact (f ⁻¹' s)
-- Mathlib/RingTheory/Localization/Algebra.lean
lemma mapₐ_injective_of_injective (f : A →ₐ[R] B) (hf : Function.Injective f) :
    Function.Injective (mapₐ M Rₚ Aₚ Bₚ f)
-- Mathlib/Algebra/Group/Invertible/Basic.lean
theorem commute_invOf {M : Type*} [One M] [Mul M] (m : M) [Invertible m] : Commute m (⅟ m)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
/-- If `0 : ℕ` is not in the support of `f : ℕ →₀ ℕ` then `0 < ∏ x ∈ f.support, x ^ (f x)`. -/
theorem prod_pow_pos_of_zero_not_mem_support {f : ℕ →₀ ℕ} (nhf : 0 ∉ f.support) :
    0 < f.prod (· ^ ·)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma hurwitzZetaEven_neg (a : UnitAddCircle) (s : ℂ) :
    hurwitzZetaEven (-a) s = hurwitzZetaEven a s
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem mem_support_iff : n ∈ p.support ↔ p.coeff n ≠ 0
-- Mathlib/RingTheory/SimpleModule.lean
theorem iso_symm {X Y : Submodule R M × Submodule R M} : Iso X Y → Iso Y X
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
theorem CokernelCofork.π_eq_zero (s : CokernelCofork f) : s.ι.app zero = 0
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Removal.lean
lemma triangleRemovalBound_pos (hε : 0 < ε) (hε₁ : ε ≤ 1) : 0 < triangleRemovalBound ε
-- Mathlib/Algebra/DirectLimit.lean
lemma congr_apply_of [IsDirected ι (· ≤ ·)]
    (e : (i : ι) → G i ≃ₗ[R] G' i) (he : ∀ i j h, e j ∘ₗ f i j h = f' i j h ∘ₗ e i)
    {i : ι} (g : G i) :
    congr e he (of _ _ G f i g) = of _ _ G' f' i (e i g)
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is continuous on `ℝ`, and `f''` is strictly positive on `ℝ`,
then `f` is strictly convex on `ℝ`.
Note that we don't require twice differentiability explicitly as it is already implied by the second
derivative being strictly positive, except at at most one point. -/
theorem strictConvexOn_univ_of_deriv2_pos {f : ℝ → ℝ} (hf : Continuous f)
    (hf'' : ∀ x, 0 < (deriv^[2] f) x) : StrictConvexOn ℝ univ f
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive (attr := simp)]
theorem const_one [One β] : const α (1 : β) = 1
-- Mathlib/Probability/Kernel/Basic.lean
theorem kernel_sum_seq (κ : Kernel α β) [h : IsSFiniteKernel κ] : Kernel.sum (seq κ) = κ
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
/-- Product of two infinites sums indexed by arbitrary types.
    See also `tsum_mul_tsum_of_summable_norm` if `f` and `g` are absolutely summable. -/
theorem tsum_mul_tsum (hf : Summable f) (hg : Summable g)
    (hfg : Summable fun x : ι × κ ↦ f x.1 * g x.2) :
    ((∑' x, f x) * ∑' y, g y) = ∑' z : ι × κ, f z.1 * g z.2
-- Mathlib/Init/Data/Nat/GCD.lean
theorem gcd_def (x y : ℕ) : gcd x y = if x = 0 then y else gcd (y % x) x
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive (attr := simp) posPart_pos_iff] lemma one_lt_oneLePart_iff : 1 < a⁺ᵐ ↔ 1 < a
-- Mathlib/Analysis/Normed/Group/Rat.lean
@[norm_cast, simp 1001]
-- Porting note: increase priority to prevent the left-hand side from simplifying
theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem int_add_iff : LiouvilleWith p (m + x) ↔ LiouvilleWith p x
-- Mathlib/Topology/Category/LightProfinite/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : LightProfinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a
-- Mathlib/AlgebraicTopology/CechNerve.lean
/-- The morphism between Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.cechConerve ⟶ g.cechConerve
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.prod_left_fst (h : IsBigOWith c l (fun x => (f' x, g' x)) k') :
    IsBigOWith c l f' k'
-- Mathlib/Data/Nat/PartENat.lean
theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) ≤ x
-- Mathlib/Algebra/Order/Antidiag/Finsupp.lean
@[simp] lemma finsuppAntidiag_zero (s : Finset ι) : finsuppAntidiag s (0 : μ) = {0}
-- Mathlib/Data/List/Indexes.lean
/-- `p` does not hold for elements with indices less than `xs.findIdx p`. -/
theorem not_of_lt_findIdx {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.findIdx p) :
    ¬p (xs.get ⟨i, h.trans_le (findIdx_le_length p)⟩)
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivWithinAt_snd (s : Set (M × M')) (x : M × M') :
    HasMFDerivWithinAt (I.prod I') I' Prod.snd s x
      (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_zero (a : G) : (single a 0 : k[G]) = 0
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- A sequence of functions `(fₙ)` is uniformly integrable in the probability sense if for all
`ε > 0`, there exists some `C` such that `∫ x in {|fₙ| ≥ C}, fₙ x ∂μ ≤ ε` for all `n`. -/
theorem uniformIntegrable_of [IsFiniteMeasure μ] (hp : 1 ≤ p) (hp' : p ≠ ∞)
    (hf : ∀ i, AEStronglyMeasurable (f i) μ)
    (h : ∀ ε : ℝ, 0 < ε → ∃ C : ℝ≥0,
      ∀ i, eLpNorm ({ x | C ≤ ‖f i x‖₊ }.indicator (f i)) p μ ≤ ENNReal.ofReal ε) :
    UniformIntegrable f p μ
-- Mathlib/Data/Multiset/Basic.lean
theorem rel_add_left {as₀ as₁} :
    ∀ {bs}, Rel r (as₀ + as₁) bs ↔ ∃ bs₀ bs₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
-- Mathlib/Order/Filter/AtTopBot.lean
theorem map_val_atTop_of_Ici_subset [SemilatticeSup α] {a : α} {s : Set α} (h : Ici a ⊆ s) :
    map ((↑) : s → α) atTop = atTop
-- Mathlib/Data/Bool/Count.lean
theorem count_true_le_count_false_add_one (hl : Chain' (· ≠ ·) l) :
    count true l ≤ count false l + 1
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem card_biUnion_lt_iff_forall_of_isRegular {α β : Type u} {s : Set α} {t : ∀ a ∈ s, Set β}
    {c : Cardinal} (hc : c.IsRegular) (hs : #s < c) :
    #(⋃ a ∈ s, t a ‹_›) < c ↔ ∀ a (ha : a ∈ s), # (t a ha) < c
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma isLittleO_deriv_smoothingFn : deriv ε =o[atTop] fun x => x⁻¹
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem mem_diag : x ∈ s.diag ↔ x.1 ∈ s ∧ x.1 = x.2
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_eq_sqrt_one_sub_sin_sq {x : ℝ} (hl : -(π / 2) ≤ x) (hu : x ≤ π / 2) :
    cos x = √(1 - sin x ^ 2)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_add_int (x : α) (y : ℤ) : round (x + y) = round x + y
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem mod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : mod a b < b
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
/--
This lemma follows from the preexisting `Unique` instance, but
it is often convenient to use it directly as `apply toUnit_unique` forcing
lean to do the necessary elaboration.
-/
lemma toUnit_unique {X : C} (f g : X ⟶ 𝟙_ _) : f = g
-- Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean
@[to_additive]
theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem WfDvdMonoid.of_wellFounded_associates [CancelCommMonoidWithZero α]
    (h : WellFounded ((· < ·) : Associates α → Associates α → Prop)) : WfDvdMonoid α
-- Mathlib/CategoryTheory/Sites/LeftExact.lean
@[reassoc (attr := simp)]
lemma toSheafify_plusPlusIsoSheafify_hom (P : Cᵒᵖ ⥤ D) :
    J.toSheafify P ≫ (plusPlusIsoSheafify J D P).hom = toSheafify J P
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- The subsemiring generated by a set includes the set. -/
@[simp, aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_closure {s : Set R} : s ⊆ closure s
-- Mathlib/RingTheory/Nilpotent/Defs.lean
lemma isNilpotent_of_pos_nilpotencyClass (hx : 0 < nilpotencyClass x) :
    IsNilpotent x
-- Mathlib/Data/PFun.lean
theorem res_univ (f : α → β) : PFun.res f Set.univ = f
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem neg_iff : LiouvilleWith p (-x) ↔ LiouvilleWith p x
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem sInf_adj_of_nonempty {s : Set G.Subgraph} (hs : s.Nonempty) :
    (sInf s).Adj a b ↔ ∀ G' ∈ s, Adj G' a b
-- Mathlib/Algebra/Module/Torsion.lean
theorem _root_.Submodule.annihilator_top_inter_nonZeroDivisors [Module.Finite R M]
    (hM : Module.IsTorsion R M) : ((⊤ : Submodule R M).annihilator : Set R) ∩ R⁰ ≠ ∅
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_mono (b : ℕ) : Monotone fun a => choose a b
-- Mathlib/FieldTheory/IsSepClosed.lean
/-- Every separable polynomial splits in the field extension `f : k →+* K` if `k` is
separably closed.

See also `IsSepClosed.splits_codomain` for the case where `k` is separably closed.
-/
theorem IsSepClosed.splits_domain [IsSepClosed k] {f : k →+* K}
    (p : k[X]) (h : p.Separable) : p.Splits f
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem componentComplMk_mem (G : SimpleGraph V) {v : V} (vK : v ∉ K) : v ∈ G.componentComplMk vK
-- Mathlib/GroupTheory/Commutator.lean
@[simp]
theorem commutatorElement_one_right : ⁅g, (1 : G)⁆ = 1
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem quot_mk_to_coe (l : List α) : @Eq (Multiset α) ⟦l⟧ l
-- Mathlib/Order/Basic.lean
protected lemma lt_of_lt_of_le (h₁ : x.1 < y.1) (h₂ : x.2 ≤ y.2) : x < y
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- We prove that `seminormFromConst' hf1 hc hpm x` is the limit of the sequence
  `seminormFromConst_seq c f x` as `n` tends to infinity. -/
theorem seminormFromConst_isLimit (x : R) :
    Tendsto (seminormFromConst_seq c f x) atTop (𝓝 (seminormFromConst' hf1 hc hpm x))
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
/-- Characterization the map `descSet hc`: the image of an element in a vertex of the original
  diagram in the cocone point lies in `descSet hc ls` if and only if the image of the corresponding
  element in the lifted diagram lie in `ls`. -/
lemma descSet_spec (s : Set c.pt) (ls : Set lc.pt) :
    descSet hc ls = s ↔ ∀ j x, lc.ι.app j ⟨x⟩ ∈ ls ↔ c.ι.app j x ∈ s
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem coe_mk'_linearMap (D : A →ₗ[R] M) (h) : (mk' D h : A →ₗ[R] M) = D
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.of_bound [IsFiniteMeasure μ] {f : α → E} (hf : AEStronglyMeasurable f μ) (C : ℝ)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : Memℒp f p μ
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast]
theorem ofReal_re (r : ℝ) : Complex.re (r : ℂ) = r
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem LinearOrderedAddCommGroup.tendsto_nhds {x : Filter β} {a : α} :
    Tendsto f x (𝓝 a) ↔ ∀ ε > (0 : α), ∀ᶠ b in x, |f b - a| < ε
-- Mathlib/MeasureTheory/Group/Integral.lean
@[to_additive]
theorem Integrable.comp_div_right {f : G → F} [IsMulRightInvariant μ] (hf : Integrable f μ)
    (g : G) : Integrable (fun t => f (t / g)) μ
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem Filter.EventuallyEq.differentiableAt_iff (h : f₀ =ᶠ[𝓝 x] f₁) :
    DifferentiableAt 𝕜 f₀ x ↔ DifferentiableAt 𝕜 f₁ x