ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toLinearEquiv (e : E ≃ₛₗᵢ[σ₁₂] E₂) : ⇑e.toLinearEquiv = e
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_lt_degree_mul_X (hp : p ≠ 0) : p.degree < (p * X).degree
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem monad_seq_eq_seq {α β : Type u} (q : PMF (α → β)) (p : PMF α) : q <*> p = q.seq p
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
/-- Every value of the ordinal approximants are greater or equal than every fixed point of f
  that is smaller then the initial value -/
lemma le_gfpApprox_of_mem_fixedPoints {a : α}
    (h_a : a ∈ fixedPoints f) (h_le_init : a ≤ x) (i : Ordinal) : a ≤ gfpApprox f x i
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_pos : 0 < s.infsep ↔ 0 < s.einfsep ∧ s.einfsep < ∞
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem tan_pi_div_six : tan (π / 6) = 1 / sqrt 3
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem self_eq_zero (H : B.IsAlt) (x : M) : B x x = 0
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem smul [NormedField 𝕜] [NormedSpace 𝕜 β] (hT : DominatedFinMeasAdditive μ T C) (c : 𝕜) :
    DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)
-- Mathlib/Order/InitialSeg.lean
@[simp]
theorem codRestrict_top (p) (f : r ≺i s) (H H₂) : (codRestrict p f H H₂).top = ⟨f.top, H₂⟩
-- Mathlib/Order/Filter/Bases.lean
theorem hasBasis_generate (s : Set (Set α)) :
    (generate s).HasBasis (fun t => Set.Finite t ∧ t ⊆ s) fun t => ⋂₀ t
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesOnBall.hasFPowerSeriesAt (hf : HasFPowerSeriesOnBall f p x r) :
    HasFPowerSeriesAt f p x
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive] lemma prod_subset {s : Finset ι} {f : ι → α} (h : ∀ i, f i ≠ 1 → i ∈ s) :
    ∏ i ∈ s, f i = ∏ i, f i
-- Mathlib/Data/Set/Basic.lean
@[elab_as_elim]
theorem set_cases {p : Set α → Prop} (h0 : p ∅) (h1 : p univ) (s) : p s
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem utf8Len_le_of_prefix (h : cs₁ <+: cs₂) : utf8Len cs₁ ≤ utf8Len cs₂
-- Mathlib/Topology/Instances/CantorSet.lean
/-- The ternary Cantor set is a subset of [0,1]. -/
lemma cantorSet_subset_unitInterval : cantorSet ⊆ Set.Icc 0 1
-- Mathlib/LinearAlgebra/Dual.lean
theorem eval_ker : LinearMap.ker (eval K V) = ⊥
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem integrable_zero_measure {_ : MeasurableSpace α} {f : α → β} :
    Integrable f (0 : Measure α)
-- Mathlib/Order/Filter/Basic.lean
theorem _root_.Pairwise.exists_mem_filter_of_disjoint {ι : Type*} [Finite ι] {l : ι → Filter α}
    (hd : Pairwise (Disjoint on l)) :
    ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s)
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The weighted sum is unaffected by changing the weights to the
corresponding indicator function and adding points to the set. -/
theorem weightedVSubOfPoint_indicator_subset (w : ι → k) (p : ι → P) (b : P) {s₁ s₂ : Finset ι}
    (h : s₁ ⊆ s₂) :
    s₁.weightedVSubOfPoint p b w = s₂.weightedVSubOfPoint p b (Set.indicator (↑s₁) w)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem _root_.Submodule.range_subtypeL (p : Submodule R₁ M₁) : range p.subtypeL = p
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem map_id' (s : Multiset α) : map (fun x => x) s = s
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := simp)]
theorem one_comp [One γ] (g : C(α, β)) : (1 : C(β, γ)).comp g = 1
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem enoughProjectives_of_enoughInjectives_op [EnoughInjectives Cᵒᵖ] : EnoughProjectives C
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
private theorem enumOrd_mem_aux (hS : Unbounded (· < ·) S) (o) :
    enumOrd S o ∈ S ∩ Set.Ici (blsub.{u, u} o fun c _ => enumOrd S c)
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem comp_apply (g : β →ₙ+* γ) (f : α →ₙ+* β) (x : α) : g.comp f x = g (f x)
-- Mathlib/Order/Circular.lean
theorem Btw.btw.antisymm {a b c : α} (h : btw a b c) : btw c b a → a = b ∨ b = c ∨ c = a
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem EuclideanSpace.inner_piLp_equiv_symm (x y : ι → 𝕜) :
    ⟪(WithLp.equiv 2 _).symm x, (WithLp.equiv 2 _).symm y⟫ = Matrix.dotProduct (star x) y
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_series_hasSum_exp' (x : 𝔸) : HasSum (fun n => (n !⁻¹ : 𝕂) • x ^ n) (exp 𝕂 x)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem nnnorm_inner_le_nnnorm (x y : E) : ‖⟪x, y⟫‖₊ ≤ ‖x‖₊ * ‖y‖₊
-- Mathlib/Probability/Independence/Conditional.lean
theorem iCondIndepSets.piiUnionInter_of_not_mem {π : ι → Set (Set Ω)} {a : ι} {S : Finset ι}
    (hp_ind : iCondIndepSets m' hm' π μ) (haS : a ∉ S) :
    CondIndepSets m' hm' (piiUnionInter π S) (π a) μ
-- Mathlib/Data/List/Range.lean
@[simp]
theorem finRange_eq_nil {n : ℕ} : finRange n = [] ↔ n = 0
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem _root_.Irreducible.maximalIdeal_eq {ϖ : R} (h : Irreducible ϖ) :
    maximalIdeal R = Ideal.span {ϖ}
-- Mathlib/Data/Set/Pairwise/Lattice.lean
theorem pairwiseDisjoint_iUnion {g : ι' → Set ι} (h : Directed (· ⊆ ·) g) :
    (⋃ n, g n).PairwiseDisjoint f ↔ ∀ ⦃n⦄, (g n).PairwiseDisjoint f
-- Mathlib/CategoryTheory/Localization/SmallShiftedHom.lean
lemma equiv_shift : equiv W L (f.shift a) =
    (L.commShiftIso a).hom.app X ≫ (equiv W L f)⟦a⟧' ≫ (L.commShiftIso a).inv.app Y
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem smul_snd (s : S) (a : 𝓜(𝕜, A)) : (s • a).snd = s • a.snd
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem comp_continuousOn_iff (h : X ≃ₜ Y) (f : Z → X) (s : Set Z) :
    ContinuousOn (h ∘ f) s ↔ ContinuousOn f s
-- Mathlib/Data/Complex/Basic.lean
@[simp]
lemma div_ofNat_re (z : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (z / no_index (OfNat.ofNat n)).re = z.re / OfNat.ofNat n
-- Mathlib/Topology/NhdsSet.lean
@[mono]
theorem nhdsSet_mono (h : s ⊆ t) : 𝓝ˢ s ≤ 𝓝ˢ t
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem contMDiffWithinAt_const : ContMDiffWithinAt I I' n (fun _ : M => c) s x
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₂_eq_zero_of_epi₁ (h : Epi T.mor₁) : T.mor₂ = 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.prod_left_fst : (fun x => (f' x, g' x)) =O[l] k' → f' =O[l] k'
-- Mathlib/Topology/Perfect.lean
/-- A set `C` is called perfect if it is closed and all of its
points are accumulation points of itself.
Note that we do not require `C` to be nonempty. -/
@[mk_iff perfect_def]
structure Perfect (C : Set α) : Prop where
  closed : IsClosed C
  acc : Preperfect C
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem eq_one_of_mul_eq_one_right {a b : Int} (H : 0 ≤ a) (H' : a * b = 1) : a = 1
-- Mathlib/Order/BooleanAlgebra.lean
theorem compl_sdiff_compl : xᶜ \ yᶜ = y \ x
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_natDegree_eq_one {f : K[X]} (hf : natDegree f = 1) : Splits i f
-- Mathlib/Algebra/NeZero.lean
@[field_simps]
lemma four_ne_zero [OfNat α 4] [NeZero (4 : α)] : (4 : α) ≠ 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem measurableSet_lt [SecondCountableTopology α] {f g : δ → α} (hf : Measurable f)
    (hg : Measurable g) : MeasurableSet { a | f a < g a }
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem Measurable.prod {f : α → β × γ} (hf₁ : Measurable fun a => (f a).1)
    (hf₂ : Measurable fun a => (f a).2) : Measurable f
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma MutuallySingular.singularPart (h : μ ⟂ₘ ν) (ν' : Measure α) :
    μ.singularPart ν' ⟂ₘ ν
-- Mathlib/CategoryTheory/Limits/FinallySmall.lean
theorem initiallySmall_of_essentiallySmall [EssentiallySmall.{w} J] : InitiallySmall.{w} J
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem le_rootMultiplicity_mul {p q : R[X]} (x : R) (hpq : p * q ≠ 0) :
    rootMultiplicity x p + rootMultiplicity x q ≤ rootMultiplicity x (p * q)
-- Mathlib/LinearAlgebra/Matrix/HermitianFunctionalCalculus.lean
lemma closedEmbedding_cfcAux : ClosedEmbedding hA.cfcAux
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma mk'_smul_mk' (x : R) (m : M) (s t : S) :
    IsLocalization.mk' A x s • mk' f m t = mk' f (x • m) (s * t)
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem tendsto_const_smul_iff₀ {f : β → α} {l : Filter β} {a : α} {c : G₀} (hc : c ≠ 0) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a)
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- The identity comonad. -/
@[simps!]
def id : Comonad C
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- See note [comp_of_eq lemmas] -/
theorem ContMDiffAt.comp_of_eq {g : M' → M''} {x : M} {y : M'} (hg : ContMDiffAt I' I'' n g y)
    (hf : ContMDiffAt I I' n f x) (hx : f x = y) : ContMDiffAt I I'' n (g ∘ f) x
-- Mathlib/Data/Sum/Order.lean
theorem le_def [LE α] [LE β] {a b : α ⊕ₗ β} : a ≤ b ↔ Lex (· ≤ ·) (· ≤ ·) (ofLex a) (ofLex b)
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem toLinearMap_injective {F : Type*} [FunLike F M M₃] [SemilinearMapClass F σ M M₃]
    {f g : F} (h : (f : M →ₛₗ[σ] M₃) = (g : M →ₛₗ[σ] M₃)) :
    f = g
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem top_prod (s : Subring S) : (⊤ : Subring R).prod s = s.comap (RingHom.snd R S)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem derivWithin_const_sub (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    derivWithin (fun y => c - f y) s x = -derivWithin f s x
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iic_union_Ioc_eq_Iic (h : a ≤ b) : Iic a ∪ Ioc a b = Iic b
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem exists_pos_bound_of_bound {V W : Type*} [SeminormedAddCommGroup V]
    [SeminormedAddCommGroup W] {f : V → W} (M : ℝ) (h : ∀ x, ‖f x‖ ≤ M * ‖x‖) :
    ∃ N, 0 < N ∧ ∀ x, ‖f x‖ ≤ N * ‖x‖
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_subset : ∀ (s : ι → Set β) (i : ι), ⋂ i, s i ⊆ s i
-- Mathlib/Data/Multiset/Basic.lean
/-- `Multiset.map f` preserves `count` if `f` is injective -/
theorem count_map_eq_count' [DecidableEq β] (f : α → β) (s : Multiset α) (hf : Function.Injective f)
    (x : α) : (s.map f).count (f x) = s.count x
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem forget_obj_hom {f} : ((forget X).obj f).hom = f.arrow
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma NumberField.InfinitePlace.isUnramified [IsUnramifiedAtInfinitePlaces k K]
    (w : InfinitePlace K) : IsUnramified k w
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem pow_succ (n m : Nat) : n^(succ m) = n^m * n
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem one_le_norm_mul_norm_symm [RingHomIsometric σ₁₂] [Nontrivial E] (e : E ≃SL[σ₁₂] F) :
    1 ≤ ‖(e : E →SL[σ₁₂] F)‖ * ‖(e.symm : F →SL[σ₂₁] E)‖
-- Mathlib/Algebra/Category/Ring/Colimits.lean
@[simp]
theorem quot_neg (x : Prequotient F) :
    -- Porting note: Lean can't see `Quot.mk Setoid.r x` is a `ColimitType F` even with type
    -- annotation unless we use `by exact` to change the elaboration order.
    (by exact Quot.mk Setoid.r (neg x) : ColimitType F) = -(by exact Quot.mk Setoid.r x)
-- Mathlib/Data/Finset/Finsupp.lean
@[simp]
theorem card_pi (f : ι →₀ Finset α) : f.pi.card = f.prod fun i => (f i).card
-- Mathlib/Data/Finset/NAry.lean
theorem image_image₂_antidistrib {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g₁ b) (g₂ a)) :
    (image₂ f s t).image g = image₂ f' (t.image g₁) (s.image g₂)
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
theorem Intersecting.ne_bot (hs : s.Intersecting) (ha : a ∈ s) : a ≠ ⊥
-- Mathlib/Topology/Bases.lean
/-- A point `a` is in the closure of `s` iff all basis sets containing `a` intersect `s`. -/
theorem IsTopologicalBasis.mem_closure_iff {b : Set (Set α)} (hb : IsTopologicalBasis b) {s : Set α}
    {a : α} : a ∈ closure s ↔ ∀ o ∈ b, a ∈ o → (o ∩ s).Nonempty
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp] lemma toFinset_Icc (a b : α) [Fintype (Icc a b)] : (Icc a b).toFinset = Finset.Icc a b
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem abelianizationCongr_refl :
    (MulEquiv.refl G).abelianizationCongr = MulEquiv.refl (Abelianization G)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Parallelogram law -/
theorem parallelogram_law {x y : E} : ⟪x + y, x + y⟫ + ⟪x - y, x - y⟫ = 2 * (⟪x, x⟫ + ⟪y, y⟫)
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem uniformity_basis_edist_le :
    (𝓤 α).HasBasis (fun ε : ℝ≥0∞ => 0 < ε) fun ε => { p : α × α | edist p.1 p.2 ≤ ε }
-- Mathlib/FieldTheory/SeparableDegree.lean
theorem natSepDegree_X_pow {n : ℕ} : (X ^ n : F[X]).natSepDegree = if n = 0 then 0 else 1
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A seminormed ring is a ring endowed with a seminorm which satisfies the inequality
`‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class SeminormedRing (α : Type*) extends Norm α, Ring α, PseudoMetricSpace α where
  /-- The distance is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = norm (x - y)
  /-- The norm is submultiplicative. -/
  norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp, reassoc]
theorem colimitFlipCompColimIsoColimitCompColim_ι_ι_hom (j) (k) :
    colimit.ι (F.flip.obj k) j ≫ colimit.ι (F.flip ⋙ colim) k ≫
      (colimitFlipCompColimIsoColimitCompColim F).hom =
        (colimit.ι _ k ≫ colimit.ι (F ⋙ colim) j : _ ⟶ colimit (F⋙ colim))
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem nextCoeff_C_eq_zero (c : R) : nextCoeff (C c) = 0
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem quasispectrumRestricts_iff_spectrumRestricts_inr (S : Type*) {R A : Type*} [Semifield R]
    [Field S] [NonUnitalRing A] [Algebra R S] [Module R A] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [IsScalarTower R S A] {a : A} {f : S → R} :
    QuasispectrumRestricts a f ↔ SpectrumRestricts (a : Unitization S A) f
-- Mathlib/Data/Finset/Slice.lean
@[simp] lemma sized_singleton : ({s} : Set (Finset α)).Sized r ↔ s.card = r
-- Mathlib/NumberTheory/FLT/Three.lean
/-- `Solution` is the same as `Solution'` with the additional assumption that `λ ^ 2 ∣ a + b`. -/
structure Solution extends Solution' hζ where
  hab : λ ^ 2 ∣ a + b
-- Mathlib/GroupTheory/PGroup.lean
/-- If a p-group acts on `α` and the cardinality of `α` is a multiple
  of `p`, and the action has one fixed point, then it has another fixed point. -/
theorem exists_fixed_point_of_prime_dvd_card_of_fixed_point (hpα : p ∣ Nat.card α) {a : α}
    (ha : a ∈ fixedPoints G α) : ∃ b, b ∈ fixedPoints G α ∧ a ≠ b
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mul_mk'_eq_mk'_of_mul (x₁ x₂) (y : S) : f.toMap x₁ * f.mk' x₂ y = f.mk' (x₁ * x₂) y
-- Mathlib/CategoryTheory/Generator.lean
theorem IsSeparator.def {G : C} :
    IsSeparator G → ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : G ⟶ X, h ≫ f = h ≫ g) → f = g
-- Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
theorem isUnit_of_isUnit_ι {m : M} (h : IsUnit (ι Q m)) : IsUnit (Q m)
-- Mathlib/Algebra/Ring/Parity.lean
lemma two_mul_div_two_add_one_of_odd (h : Odd n) : 2 * (n / 2) + 1 = n
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_add_const_uIcc : (fun x => x + a) '' [[b, c]] = [[b + a, c + a]]
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- If `ξ` is rational, then the good rational approximations to `ξ` have bounded
numerator and denominator. -/
theorem den_le_and_le_num_le_of_sub_lt_one_div_den_sq {ξ q : ℚ}
    (h : |ξ - q| < 1 / (q.den : ℚ) ^ 2) :
    q.den ≤ ξ.den ∧ ⌈ξ * q.den⌉ - 1 ≤ q.num ∧ q.num ≤ ⌊ξ * q.den⌋ + 1
-- Mathlib/Order/Filter/SmallSets.lean
theorem comap_smallSets (l : Filter β) (f : α → Set β) :
    comap f l.smallSets = l.lift' (preimage f ∘ powerset)
-- Mathlib/Data/Set/Image.lean
/-- If the only elements outside `s` are those left fixed by `σ`, then mapping by `σ` has no effect.
-/
theorem image_perm {s : Set α} {σ : Equiv.Perm α} (hs : { a : α | σ a ≠ a } ⊆ s) : σ '' s = s
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma traceForm_isSymm : LinearMap.IsSymm (traceForm R L M)
-- Mathlib/Algebra/Module/Bimodule.lean
theorem smul_mem (p : Submodule (A ⊗[R] B) M) (a : A) {m : M} (hm : m ∈ p) : a • m ∈ p
-- Mathlib/GroupTheory/Coprod/Basic.lean
/-- Isomorphism between `M ∗ PUnit` and `M`. -/
@[simps! (config := .asFn)]
def coprodUnit : AddMonoid.Coprod M PUnit ≃+ M
-- Mathlib/NumberTheory/Harmonic/Bounds.lean
theorem log_add_one_le_harmonic (n : ℕ) :
    Real.log ↑(n+1) ≤ harmonic n
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- Measure `μ` *has no atoms* if the measure of each singleton is zero.

NB: Wikipedia assumes that for any measurable set `s` with positive `μ`-measure,
there exists a measurable `t ⊆ s` such that `0 < μ t < μ s`. While this implies `μ {x} = 0`,
the converse is not true. -/
class NoAtoms {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  measure_singleton : ∀ x, μ {x} = 0
-- Mathlib/Data/List/Basic.lean
/-- `intercalate [x]` is the left inverse of `splitOn x`  -/
theorem intercalate_splitOn (x : α) [DecidableEq α] : [x].intercalate (xs.splitOn x) = xs
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive]
theorem Commute.function_commute_mul_right (h : Commute a b) :
    Function.Commute (· * a) (· * b)
-- Mathlib/Data/Set/Basic.lean
theorem MemUnion.elim {x : α} {a b : Set α} {P : Prop} (H₁ : x ∈ a ∪ b) (H₂ : x ∈ a → P)
    (H₃ : x ∈ b → P) : P
-- Mathlib/Data/Nat/Factorization/Defs.lean
@[simp]
theorem factorization_zero_right (n : ℕ) : n.factorization 0 = 0
-- Mathlib/Data/Int/Lemmas.lean
theorem natAbs_inj_of_nonneg_of_nonneg {a b : ℤ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    natAbs a = natAbs b ↔ a = b
-- Mathlib/Data/Pi/Interval.lean
theorem card_Iio : (Iio b).card = (∏ i, (Iic (b i)).card) - 1
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem exists_of_linearIndependent_of_finite_span {t : Finset V}
    (hs : LinearIndependent K (fun x => x : s → V)) (hst : s ⊆ (span K ↑t : Submodule K V)) :
    ∃ t' : Finset V, ↑t' ⊆ s ∪ ↑t ∧ s ⊆ ↑t' ∧ t'.card = t.card
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem sum_card_orderOf_eq_card_pow_eq_one [Fintype G] [DecidableEq G] (hn : n ≠ 0) :
    (∑ m ∈ (Finset.range n.succ).filter (· ∣ n),
        (Finset.univ.filter fun x : G => orderOf x = m).card) =
      (Finset.univ.filter fun x : G => x ^ n = 1).card
-- Mathlib/FieldTheory/SplittingField/Construction.lean
theorem adjoin_rootSet : Algebra.adjoin K (f.rootSet (SplittingField f)) = ⊤
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
nonrec theorem neg (hf : CircleIntegrable f c R) : CircleIntegrable (-f) c R
-- Mathlib/RingTheory/RingHom/FinitePresentation.lean
/-- Being finitely-presented is preserved by localizations. -/
theorem finitePresentation_localizationPreserves : LocalizationPreserves @FinitePresentation
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[simp]
lemma FixedPoints.mem_addSubmonoid (a : α) : a ∈ addSubmonoid M α ↔ ∀ m : M, m • a = a
-- Mathlib/RingTheory/Nilpotent/Basic.lean
lemma isNilpotent_sum {ι : Type*} {s : Finset ι} {f : ι → R}
    (hnp : ∀ i ∈ s, IsNilpotent (f i)) :
    IsNilpotent (∑ i ∈ s, f i)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[elab_as_elim]
protected theorem mul_induction_on {I J : FractionalIdeal S P} {C : P → Prop} {r : P}
    (hr : r ∈ I * J) (hm : ∀ i ∈ I, ∀ j ∈ J, C (i * j)) (ha : ∀ x y, C x → C y → C (x + y)) :
    C r
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_Ico (r s : β) : Convex 𝕜 (Ico r s)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem le_one_iff_exists_coeIdeal {J : FractionalIdeal S P} :
    J ≤ (1 : FractionalIdeal S P) ↔ ∃ I : Ideal R, ↑I = J
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem seq_destruct_cons (a : α) (s) : Seq.destruct (cons a s) = some (some a, s)
-- Mathlib/Topology/Category/CompHausLike/Limits.lean
lemma finiteCoproduct.hom_ext {B : CompHausLike P} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_nonneg_ae (hs : MeasurableSet s) (hf : ∀ᵐ x ∂μ, x ∈ s → 0 ≤ f x) :
    0 ≤ ∫ x in s, f x ∂μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_add_mod (a b : Int) : b * a.div b + mod a b = a
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp]
theorem sum_neg (xs : IntList) : (-xs).sum = -(xs.sum)
-- Mathlib/Data/NNReal/Basic.lean
@[simp] theorem coe_toRealHom : ⇑toRealHom = toReal
-- Mathlib/MeasureTheory/Covering/Vitali.lean
/-- The measurable Vitali covering theorem. Assume one is given a family `t` of closed sets with
nonempty interior, such that each `a ∈ t` is included in a ball `B (x, r)` and covers a definite
proportion of the ball `B (x, 3 r)` for a given measure `μ` (think of the situation where `μ` is
a doubling measure and `t` is a family of balls). Consider a (possibly non-measurable) set `s`
at which the family is fine, i.e., every point of `s` belongs to arbitrarily small elements of `t`.
Then one can extract from `t` a disjoint subfamily that covers almost all `s`.

For more flexibility, we give a statement with a parameterized family of sets.
-/
theorem exists_disjoint_covering_ae [MetricSpace α] [MeasurableSpace α] [OpensMeasurableSpace α]
    [SecondCountableTopology α] (μ : Measure α) [IsLocallyFiniteMeasure μ] (s : Set α) (t : Set ι)
    (C : ℝ≥0) (r : ι → ℝ) (c : ι → α) (B : ι → Set α) (hB : ∀ a ∈ t, B a ⊆ closedBall (c a) (r a))
    (μB : ∀ a ∈ t, μ (closedBall (c a) (3 * r a)) ≤ C * μ (B a))
    (ht : ∀ a ∈ t, (interior (B a)).Nonempty) (h't : ∀ a ∈ t, IsClosed (B a))
    (hf : ∀ x ∈ s, ∀ ε > (0 : ℝ), ∃ a ∈ t, r a ≤ ε ∧ c a = x) :
    ∃ u ⊆ t, u.Countable ∧ u.PairwiseDisjoint B ∧ μ (s \ ⋃ a ∈ u, B a) = 0
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem _root_.LinearMap.BilinForm.toQuadraticMap_isOrtho [IsCancelAdd R]
    [NoZeroDivisors R] [CharZero R] {B : BilinMap R M R} {x y : M} (h : B.IsSymm) :
    B.toQuadraticMap.IsOrtho x y ↔ B.IsOrtho x y
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
/-- The open sets of an open subscheme corresponds to the open sets containing in the image. -/
@[simps]
def IsOpenImmersion.opensEquiv {X Y : Scheme.{u}} (f : X ⟶ Y) [IsOpenImmersion f] :
    X.Opens ≃ { U : Y.Opens // U ≤ f.opensRange }
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diagonal_dotProduct (i : m) : diagonal v i ⬝ᵥ w = v i * w i
-- Mathlib/Topology/MetricSpace/Ultra/Basic.lean
lemma ball_subset_trichotomy :
    ball x r ⊆ ball y s ∨ ball y s ⊆ ball x r ∨ Disjoint (ball x r) (ball y s)
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem congr_mk {ra : α → α → Prop} {rb : β → β → Prop} (e : α ≃ β)
    (eq : ∀ a₁ a₂ : α, ra a₁ a₂ ↔ rb (e a₁) (e a₂)) (a : α) :
    Quot.congr e eq (Quot.mk ra a) = Quot.mk rb (e a)
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem dist_inv_inv [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b : G) : dist a⁻¹ b⁻¹ = dist a b
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
theorem coe_S : ↑ₘS = !![0, -1; 1, 0]
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ico_erase_left (a b : α) : (Ico a b).erase a = Ioo a b
-- Mathlib/Topology/EMetricSpace/Basic.lean
@[simp]
theorem zero_eq_edist {x y : γ} : 0 = edist x y ↔ x = y
-- Mathlib/Algebra/Algebra/Tower.lean
theorem map_mem_span_algebraMap_image {S T : Type*} [CommSemiring S] [Semiring T] [Algebra R S]
    [Algebra R T] [Algebra S T] [IsScalarTower R S T] (x : S) (a : Set S)
    (hx : x ∈ Submodule.span R a) : algebraMap S T x ∈ Submodule.span R (algebraMap S T '' a)
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem iff_exists_open (f : X → Y) :
    IsLocallyConstant f ↔ ∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
@[simp, nolint simpNF]
theorem rightDual_ρ [RightRigidCategory V] (h : H) : Xᘁ.ρ h = (X.ρ (h⁻¹ : H))ᘁ
-- Mathlib/Topology/Separation.lean
theorem minimal_nonempty_open_eq_singleton [T0Space X] {s : Set X} (hs : IsOpen s)
    (hne : s.Nonempty) (hmin : ∀ t, t ⊆ s → t.Nonempty → IsOpen t → t = s) : ∃ x, s = {x}
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_cons {h} : b ∈ s.cons a h ↔ b = a ∨ b ∈ s