ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Covering/LiminfLimsup.lean
/-- Given a sequence of subsets `sᵢ` of a metric space, together with a sequence of radii `rᵢ`
such that `rᵢ → 0`, the set of points which belong to infinitely many of the
`rᵢ`-thickenings of `sᵢ` is unchanged almost everywhere for a uniformly locally doubling measure if
the `rᵢ` are all scaled by a positive constant.

This lemma is a generalisation of Lemma 9 appearing on page 217 of
[J.W.S. Cassels, *Some metrical theorems in Diophantine approximation. I*](cassels1950).

See also `blimsup_cthickening_mul_ae_eq`.

NB: The `: Set α` type ascription is present because of
https://github.com/leanprover-community/mathlib/issues/16932. -/
theorem blimsup_thickening_mul_ae_eq (p : ℕ → Prop) (s : ℕ → Set α) {M : ℝ} (hM : 0 < M) (r : ℕ → ℝ)
    (hr : Tendsto r atTop (𝓝 0)) :
    (blimsup (fun i => thickening (M * r i) (s i)) atTop p : Set α) =ᵐ[μ]
      (blimsup (fun i => thickening (r i) (s i)) atTop p : Set α)
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem pullback_eq_top_of_mem (S : Sieve X) {f : Y ⟶ X} : S f → S.pullback f = ⊤
-- Mathlib/Data/Set/Card.lean
theorem Nat.card_coe_set_eq (s : Set α) : Nat.card s = s.ncard
-- Mathlib/Data/List/Basic.lean
@[deprecated getElem_set_of_ne (since := "2024-06-12")]
theorem get_set_of_ne {l : List α} {i j : ℕ} (h : i ≠ j) (a : α)
    (hj : j < (l.set i a).length) :
    (l.set i a).get ⟨j, hj⟩ = l.get ⟨j, by simpa using hj⟩
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem derivative_rootMultiplicity_of_root [CharZero R] {p : R[X]} {t : R} (hpt : p.IsRoot t) :
    p.derivative.rootMultiplicity t = p.rootMultiplicity t - 1
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mul_eq_closure_mul_set (M N : AddSubmonoid R) :
    M * N = closure ((M : Set R) * (N : Set R))
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem get_drop (n m : ℕ) (s : Stream' α) : get (drop m s) n = get s (n + m)
-- Mathlib/Data/Nat/Digits.lean
/-- The addition of ofDigits of two lists is equal to ofDigits of digit-wise addition of them-/
theorem ofDigits_add_ofDigits_eq_ofDigits_zipWith_of_length_eq {b : ℕ} {l1 l2 : List ℕ}
    (h : l1.length = l2.length) :
    ofDigits b l1 + ofDigits b l2 = ofDigits b (l1.zipWith (· + ·) l2)
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma toLowerSet_inj {a b : α} : toLowerSet a = toLowerSet b ↔ a = b
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_filter {s : Finset α} {a : α} : a ∈ s.filter p ↔ a ∈ s ∧ p a
-- Mathlib/CategoryTheory/Elements.lean
@[simp]
theorem fromCostructuredArrow_obj_mk (F : Cᵒᵖ ⥤ Type v) {X : C} (f : yoneda.obj X ⟶ F) :
    (fromCostructuredArrow F).obj (op (CostructuredArrow.mk f)) = ⟨op X, yonedaEquiv.1 f⟩
-- Mathlib/Topology/Basic.lean
/-- The image of a dense set under a continuous map with dense range is a dense set. -/
theorem DenseRange.dense_image {f : X → Y} (hf' : DenseRange f) (hf : Continuous f)
    (hs : Dense s) : Dense (f '' s)
-- Mathlib/RingTheory/Ideal/Pointwise.lean
theorem smul_closure (a : M) (s : Set R) : a • span s = span (a • s)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem card_Ioo_eq_card_Ioc_sub_one (a b : α) : (Ioo a b).card = (Ioc a b).card - 1
-- Mathlib/Topology/Bornology/BoundedOperation.lean
/-- A typeclass saying that `(p : R × R) ↦ p.1 * p.2` maps any product of bounded sets to a bounded
set. This property automatically holds for non-unital seminormed rings, but it also holds, e.g.,
for `ℝ≥0`. -/
class BoundedMul (R : Type*) [Bornology R] [Mul R] : Prop where
  isBounded_mul : ∀ {s t : Set R},
    Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s * t)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem aemeasurable_iInf {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨅ i, f i b) μ
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem coe_neg (D : Derivation R A M) : ⇑(-D) = -D
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem finite_Ioc : (Ioc a b).Finite
-- Mathlib/NumberTheory/Modular.lean
/-- First Fundamental Domain Lemma: Any `z : ℍ` can be moved to `𝒟` by an element of
`SL(2,ℤ)` -/
theorem exists_smul_mem_fd (z : ℍ) : ∃ g : SL(2, ℤ), g • z ∈ 𝒟
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toNat_append (x : BitVec m) (y : BitVec n) :
    (x ++ y).toNat = x.toNat <<< n ||| y.toNat
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem maximum?_replicate [Max α] {n : Nat} {a : α} (w : max a a = a) :
    (replicate n a).maximum? = if n = 0 then none else some a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem add_mul_ediv_right (a b : Int) {c : Int} (H : c ≠ 0) : (a + b * c) / c = a / c + b
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.of_inf_right {f g : Filter X} (H : ClusterPt x <| f ⊓ g) :
    ClusterPt x g
-- Mathlib/Data/Set/Countable.lean
theorem Countable.image {s : Set α} (hs : s.Countable) (f : α → β) : (f '' s).Countable
-- Mathlib/Topology/Connected/Basic.lean
lemma connectedSpace_iff_univ : ConnectedSpace α ↔ IsConnected (univ : Set α)
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma coyoneda_exact₃ {X : C} (f : X ⟶ T.obj₃) (hf : f ≫ T.mor₃ = 0) :
    ∃ (g : X ⟶ T.obj₂), f = g ≫ T.mor₂
-- Mathlib/Order/WithBot.lean
theorem coe_injective : Injective ((↑) : α → WithTop α)
-- Mathlib/FieldTheory/IsSepClosed.lean
theorem exists_eq_mul_self [IsSepClosed k] (x : k) [h2 : NeZero (2 : k)] : ∃ z, x = z * z
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_Ico_mul [Ring α] (x : α) {m n : ℕ} (hmn : m ≤ n) :
    (∑ i ∈ Finset.Ico m n, x ^ i) * (x - 1) = x ^ n - x ^ m
-- Mathlib/Order/Bounded.lean
theorem unbounded_lt_iff [LinearOrder α] : Unbounded (· < ·) s ↔ ∀ a, ∃ b ∈ s, a ≤ b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean
/-- For a unital C⋆-subalgebra `S` of `A` and `x : S`, if `↑x : A` is invertible in `A`, then
`x` is invertible in `S`. -/
theorem StarSubalgebra.coe_isUnit {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A)) {x : S} :
    IsUnit (x : A) ↔ IsUnit x
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- Writing explicitly the `n+1`-th derivative as the composition of a currying linear equiv,
and the `n`-th derivative of the derivative. -/
theorem iteratedFDerivWithin_succ_eq_comp_right {n : ℕ} (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) :
    iteratedFDerivWithin 𝕜 (n + 1) f s x =
      (continuousMultilinearCurryRightEquiv' 𝕜 n E F ∘
          iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f s y) s)
        x
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
theorem sheaf_eq_amalgamation (ℱ : Sheaf K A) {X : A} {U : D} {T : Sieve U} (hT)
    (x : FamilyOfElements _ T) (hx) (t) (h : x.IsAmalgamation t) :
    t = (ℱ.cond X T hT).amalgamate x hx
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
/-- If `s` is finite, the product of the elements of the list `factors C s x`
is the delta function at `x`. -/
theorem factors_prod_eq_basis (x : π C (· ∈ s)) :
    (factors C s x).prod = spanFinBasis C s x
-- Mathlib/CategoryTheory/Triangulated/TriangleShift.lean
@[simp]
lemma shiftFunctorAdd'_eq (a b c : ℤ) (h : a + b = c) :
    CategoryTheory.shiftFunctorAdd' (Triangle C) a b c h =
      Triangle.shiftFunctorAdd' C a b c h
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_add_left {f : α → ℝ≥0∞} (hf : Measurable f) (g : α → ℝ≥0∞) :
    μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g
-- Mathlib/Analysis/Convex/Basic.lean
theorem Antitone.convex_gt (hf : Antitone f) (r : β) : Convex 𝕜 { x | r < f x }
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem UniformInducing.cauchy_map_iff {f : α → β} (hf : UniformInducing f) {F : Filter α} :
    Cauchy (map f F) ↔ Cauchy F
-- Mathlib/RingTheory/Localization/Basic.lean
theorem of_le (N : Submonoid R) (h₁ : M ≤ N) (h₂ : ∀ r ∈ N, IsUnit (algebraMap R S r)) :
    IsLocalization N S
-- Mathlib/Algebra/Lie/Submodule.lean
theorem submodule_span_le_lieSpan : Submodule.span R s ≤ lieSpan R L s
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
theorem matPolyEquiv_symm_map_eval (M : (Matrix n n R)[X]) (r : R) :
    (matPolyEquiv.symm M).map (eval r) = M.eval (scalar n r)
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem tendsto_norm_atTop_atTop : Tendsto (norm : ℝ → ℝ) atTop atTop
-- Mathlib/Topology/Sets/Opens.lean
theorem «forall» {p : Opens α → Prop} : (∀ U, p U) ↔ ∀ (U : Set α) (hU : IsOpen U), p ⟨U, hU⟩
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
/-- The homogeneous degree bounds the total degree.

See also `MvPolynomial.IsHomogeneous.totalDegree` when `φ` is non-zero. -/
lemma totalDegree_le (hφ : IsHomogeneous φ n) : φ.totalDegree ≤ n
-- Mathlib/Data/Finite/Card.lean
theorem one_lt_card_iff_nontrivial [Finite α] : 1 < Nat.card α ↔ Nontrivial α
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, `M'` and `N'` are submodules of `M` and `N`,
respectively, such that `M` and `N'` are flat, then `M'` and `N'` are also linearly disjoint. -/
theorem of_le_of_flat_left (H : M.LinearDisjoint N) {M' N' : Submodule R S}
    (hm : M' ≤ M) (hn : N' ≤ N) [Module.Flat R M] [Module.Flat R N'] :
    M'.LinearDisjoint N'
-- Mathlib/Topology/Order/LawsonTopology.lean
@[simp, nolint simpNF]
lemma ofLawson_inj {a b : WithLawson α} : ofLawson a = ofLawson b ↔ a = b
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
@[reassoc (attr := simp)]
lemma inr_f_triangle_mor₃_f (p : ℤ) : (inr φ).f p ≫ (triangle φ).mor₃.f p = 0
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem eqToHom_f {C₁ C₂ : HomologicalComplex V c} (h : C₁ = C₂) (n : ι) :
    HomologicalComplex.Hom.f (eqToHom h) n =
      eqToHom (congr_fun (congr_arg HomologicalComplex.X h) n)
-- Mathlib/Data/Matroid/Sum.lean
lemma Indep.eq_union_image_of_disjointSum {h I} (hI : (disjointSum M N h).Indep I) :
    ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousAt.finset_inf_apply (hs : ∀ i ∈ s, ContinuousAt (f i) x) :
    ContinuousAt (fun a ↦ s.inf (f · a)) x
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
nonrec theorem _root_.IsUnit.stronglyMeasurable_const_smul_iff {_ : MeasurableSpace α} {c : M}
    (hc : IsUnit c) :
    (StronglyMeasurable fun x => c • f x) ↔ StronglyMeasurable f
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected theorem ContMDiffOn.coordChangeL
    (hf : ContMDiffOn IM IB n f s) (he : MapsTo f s e.baseSet) (he' : MapsTo f s e'.baseSet) :
    ContMDiffOn IM 𝓘(𝕜, F →L[𝕜] F) n (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F)) s
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem _root_.LinearMap.annihilator_le_of_surjective (f : M →ₗ[R] M')
    (hf : Function.Surjective f) : Module.annihilator R M ≤ Module.annihilator R M'
-- Mathlib/Topology/Instances/ENNReal.lean
theorem inv_liminf {ι : Sort _} {x : ι → ℝ≥0∞} {l : Filter ι} :
    (liminf x l)⁻¹ = limsup (fun i => (x i)⁻¹) l
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
/-- Given a commutative diagram
    X --f--> Y --g--> Z
    |        |        |
    |        |        |
    v        v        v
    X' -f'-> Y' -g'-> Z'
with horizontal arrows composing to zero,
then we obtain a commutative square
   X ---> kernel g
   |         |
   |         | kernel.map
   |         |
   v         v
   X' --> kernel g'
-/
theorem kernel.lift_map {X Y Z X' Y' Z' : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasKernel g] (w : f ≫ g = 0)
    (f' : X' ⟶ Y') (g' : Y' ⟶ Z') [HasKernel g'] (w' : f' ≫ g' = 0) (p : X ⟶ X') (q : Y ⟶ Y')
    (r : Z ⟶ Z') (h₁ : f ≫ q = p ≫ f') (h₂ : g ≫ r = q ≫ g') :
    kernel.lift g f w ≫ kernel.map g g' q r h₂ = p ≫ kernel.lift g' f' w'
-- Mathlib/Probability/Distributions/Uniform.lean
theorem mem_support_ofMultiset_iff (a : α) : a ∈ (ofMultiset s hs).support ↔ a ∈ s.toFinset
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem isUnitTrinomial_iff :
    p.IsUnitTrinomial ↔ p.support.card = 3 ∧ ∀ k ∈ p.support, IsUnit (p.coeff k)
-- Mathlib/Algebra/Regular/SMul.lean
protected
lemma IsSMulRegular.eq_zero_of_smul_eq_zero [Zero M] [SMulZeroClass R M]
    {r : R} {x : M} (h1 : IsSMulRegular M r) (h2 : r • x = 0) : x = 0
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp]
theorem hasFDerivAtFilter_pi' :
    HasFDerivAtFilter Φ Φ' x L ↔
      ∀ i, HasFDerivAtFilter (fun x => Φ x i) ((proj i).comp Φ') x L
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[ext] theorem USize.ext : {x y : USize} → x.toNat = y.toNat → x = y
-- Mathlib/LinearAlgebra/StdBasis.lean
@[simp]
theorem basisFun_equivFun : (Pi.basisFun R η).equivFun = LinearEquiv.refl _ _
-- Mathlib/Topology/Instances/ENNReal.lean
@[norm_cast]
protected theorem hasSum_coe {f : α → ℝ≥0} {r : ℝ≥0} :
    HasSum (fun a => (f a : ℝ≥0∞)) ↑r ↔ HasSum f r
-- Mathlib/LinearAlgebra/Matrix/AbsoluteValue.lean
theorem det_sum_le {ι : Type*} (s : Finset ι) {A : ι → Matrix n n R} {abv : AbsoluteValue R S}
    {x : S} (hx : ∀ k i j, abv (A k i j) ≤ x) :
    abv (det (∑ k ∈ s, A k)) ≤
      Nat.factorial (Fintype.card n) • (Finset.card s • x) ^ Fintype.card n
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_le_one_div (h1 : 0 < a) (h2 : a ≤ 1) : 1 ≤ 1 / a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
lemma cos_quadratic_upper_bound (hx : |x| ≤ π) : cos x ≤ 1 - 2 / π ^ 2 * x ^ 2
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
/-- If a function is analytic on a set `s`, so are its successive derivatives. -/
theorem AnalyticOn.iterated_deriv [CompleteSpace F] (h : AnalyticOn 𝕜 f s) (n : ℕ) :
    AnalyticOn 𝕜 (_root_.deriv^[n] f) s
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
lemma coeFn_mk (μ : Measure Ω) (hμ) :
    DFunLike.coe (F := ProbabilityMeasure Ω) ⟨μ, hμ⟩ = fun s ↦ (μ s).toNNReal
-- Mathlib/Probability/Kernel/Composition.lean
theorem lintegral_prod (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel α γ) [IsSFiniteKernel η]
    (a : α) {g : β × γ → ℝ≥0∞} (hg : Measurable g) :
    ∫⁻ c, g c ∂(κ ×ₖ η) a = ∫⁻ b, ∫⁻ c, g (b, c) ∂η a ∂κ a
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem cmp_compares : ∀ a b : NONote, (cmp a b).Compares a b
-- Mathlib/Data/Real/Irrational.lean
theorem of_rat_mul : Irrational (q * x) → Irrational x
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem ae_of_ae_trim (hm : m ≤ m0) {μ : Measure α} {P : α → Prop} (h : ∀ᵐ x ∂μ.trim hm, P x) :
    ∀ᵐ x ∂μ, P x
-- Mathlib/Order/Basic.lean
theorem le_imp_le_iff_lt_imp_lt {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β} :
    a ≤ b → c ≤ d ↔ d < c → b < a
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[simp]
theorem intCast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R)
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
/-- If `l : Filter ℂ` is an "exponential comparison filter", then for any complex `a` and any
positive real `b`, we have `(fun z ↦ z ^ a) =o[l] (fun z ↦ exp (b * z))`. -/
theorem isLittleO_cpow_exp (hl : IsExpCmpFilter l) (a : ℂ) {b : ℝ} (hb : 0 < b) :
    (fun z => z ^ a) =o[l] fun z => exp (b * z)
-- Mathlib/Algebra/Order/AbsoluteValue.lean
lemma abv_eq_zero {x} : abv x = 0 ↔ x = 0
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem ContinuousLinearMap.integrable_comp {φ : α → H} (L : H →L[𝕜] E) (φ_int : Integrable φ μ) :
    Integrable (fun a : α => L (φ a)) μ
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem coe_of_injective_castSucc_symm {n : ℕ} (i : Fin n.succ) (hi) :
    ((Equiv.ofInjective castSucc (castSucc_injective _)).symm ⟨i, hi⟩ : ℕ) = i
-- Mathlib/FieldTheory/Finite/Basic.lean
lemma pow_card_sub_one {p : ℕ} [Fact p.Prime] (a : ZMod p) :
    a ^ (p - 1) = if a ≠ 0 then 1 else 0
-- Mathlib/Data/Int/ModEq.lean
theorem modEq_iff_add_fac {a b n : ℤ} : a ≡ b [ZMOD n] ↔ ∃ t, b = a + n * t
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
/-- In a real normed space, the image of the unit ball under scalar multiplication by a positive
constant `r` is the ball of radius `r`. -/
theorem smul_unitBall_of_pos {r : ℝ} (hr : 0 < r) : r • ball (0 : E) 1 = ball (0 : E) r
-- Mathlib/Topology/MetricSpace/Basic.lean
theorem dist_ne_zero {x y : γ} : dist x y ≠ 0 ↔ x ≠ y
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem isClosed_C1 : IsClosed (C1 C ho)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem ult_eq_not_carry (x y : BitVec w) : x.ult y = !carry w x (~~~y) true
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem reindexFinsetRange_apply (x : Finset.univ.image b) : b.reindexFinsetRange x = x
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- If `f` is a continuous multilinear map in finitely many variables on `E` and `m` is an element
of `∀ i, E i` such that one of the `m i` has norm `0`, then `f m` has norm `0`.

Note that we cannot drop the continuity assumption because `f (m : Unit → E) = f (m ())`,
where the domain has zero norm and the codomain has a nonzero norm
does not satisfy this condition. -/
lemma norm_map_coord_zero (hf : Continuous f) {m : ∀ i, E i} {i : ι} (hi : ‖m i‖ = 0) :
    ‖f m‖ = 0
-- Mathlib/Tactic/CC/Lemmas.lean
theorem or_eq_of_eq {a b : Prop} (h : a = b) : (a ∨ b) = a
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Removal.lean
lemma regularityReduced_edges_card_aux [Nonempty α] (hε : 0 < ε) (hP : P.IsEquipartition)
    (hPε : P.IsUniform G (ε/8)) (hP' : 4 / ε ≤ P.parts.card) :
    2 * (G.edgeFinset.card - (G.regularityReduced P (ε/8) (ε/4)).edgeFinset.card : ℝ)
      < 2 * ε * (card α ^ 2 : ℕ)
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
nonrec theorem SmoothOn.smul {f : M → 𝕜} {g : M → V} (hf : SmoothOn I 𝓘(𝕜) f s)
    (hg : SmoothOn I 𝓘(𝕜, V) g s) : SmoothOn I 𝓘(𝕜, V) (fun p => f p • g p) s
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem triangle_bimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) :
    (associatorBimod M (regular Y) N).hom ≫ whiskerLeft M (leftUnitorBimod N).hom =
      whiskerRight (rightUnitorBimod M).hom N
-- Mathlib/Algebra/Regular/Basic.lean
/-- If all multiplications cancel on the left then every element is left-regular. -/
@[to_additive "If all additions cancel on the left then every element is add-left-regular."]
theorem IsLeftRegular.all [Mul R] [IsLeftCancelMul R] (g : R) : IsLeftRegular g
-- Mathlib/Topology/MetricSpace/Closeds.lean
/-- By definition, the edistance on `Closeds α` is given by the Hausdorff edistance -/
theorem Closeds.edist_eq {s t : Closeds α} : edist s t = hausdorffEdist (s : Set α) t
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
theorem mkDerivationₗ_X (f : σ → A) (i : σ) : mkDerivationₗ R f (X i) = f i
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_nonneg_of_ae (hf : 0 ≤ᵐ[μ] f) : 0 ≤ ∫ x in s, f x ∂μ
-- Mathlib/LinearAlgebra/Determinant.lean
/-- Conjugating a linear map by a linear equiv does not change its determinant. -/
@[simp]
theorem det_conj {N : Type*} [AddCommGroup N] [Module A N] (f : M →ₗ[A] M) (e : M ≃ₗ[A] N) :
    LinearMap.det ((e : M →ₗ[A] N) ∘ₗ f ∘ₗ (e.symm : N →ₗ[A] M)) = LinearMap.det f
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem unop_inf (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem as_sum_range (p : R[X]) : p = ∑ i ∈ range (p.natDegree + 1), monomial i (coeff p i)
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@[simp]
lemma linearIsometryEquiv_coe_apply (u : unitary (H →L[𝕜] H)) :
    linearIsometryEquiv u = (u : H →L[𝕜] H)
-- Mathlib/Data/List/Basic.lean
theorem sizeOf_lt_sizeOf_of_mem [SizeOf α] {x : α} {l : List α} (hx : x ∈ l) :
    SizeOf.sizeOf x < SizeOf.sizeOf l
-- Mathlib/Data/Vector/Basic.lean
/-- The last element of a `Vector`, given that the vector is at least one element. -/
theorem last_def {v : Vector α (n + 1)} : v.last = v.get (Fin.last n)
-- Mathlib/Order/Lattice.lean
@[simp]
theorem right_lt_sup : b < a ⊔ b ↔ ¬a ≤ b
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive (attr := simp)]
lemma locallyLipschitz_inv_iff : LocallyLipschitz f⁻¹ ↔ LocallyLipschitz f
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepFun.ae_eq {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    {f' : Ω → β} {g' : Ω → β'} (hfg : IndepFun f g κ μ)
    (hf : ∀ᵐ a ∂μ, f =ᵐ[κ a] f') (hg : ∀ᵐ a ∂μ, g =ᵐ[κ a] g') :
    IndepFun f' g' κ μ
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_false (p : Prop) : (p ∧ False) = False
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- Helper function for constructing morphisms between coequalizer cotridents.
-/
@[simps]
def Cotrident.mkHom [Nonempty J] {s t : Cotrident f} (k : s.pt ⟶ t.pt)
    (w : s.π ≫ k = t.π := by aesop_cat) : s ⟶ t
-- Mathlib/Data/Int/Cast/Basic.lean
@[simp, norm_cast]
theorem cast_zero : ((0 : ℤ) : R) = 0
-- Mathlib/RingTheory/Ideal/Quotient.lean
@[simp]
theorem quotEquivOfEq_mk {R : Type*} [CommRing R] {I J : Ideal R} (h : I = J) (x : R) :
    quotEquivOfEq h (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J x
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_empty : extend m ∅ = 0
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
theorem one_leftUnitor {M : Mon_ C} :
    ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one
-- Mathlib/Algebra/Category/ModuleCat/Injective.lean
lemma ModuleCat.enoughInjectives : EnoughInjectives (ModuleCat.{max v u} R)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measurable_spanningSetsIndex (μ : Measure α) [SigmaFinite μ] :
    Measurable (spanningSetsIndex μ)
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem restrictNonposSeq_disjoint : Pairwise (Disjoint on restrictNonposSeq s i)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_comp (g : InfTopHom βᵒᵈ γᵒᵈ) (f : InfTopHom αᵒᵈ βᵒᵈ) :
    SupBotHom.dual.symm (g.comp f) =
      (SupBotHom.dual.symm g).comp (SupBotHom.dual.symm f)
-- Mathlib/Data/Finset/PImage.lean
@[simp, norm_cast]
theorem coe_pimage : (s.pimage f : Set β) = f.image s
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem mk_factors_self (f : X ⟶ Y) [Mono f] : (mk f).Factors f
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_dist_dist_le (x y x' y' : α) : dist (dist x y) (dist x' y') ≤ dist x x' + dist y y'
-- Mathlib/Order/RelIso/Basic.lean
/-- The map `coe_fn : (r ≃r s) → (α → β)` is injective. Lean fails to parse
`function.injective (fun e : r ≃r s ↦ (e : α → β))`, so we use a trick to say the same. -/
theorem coe_fn_injective : Injective fun f : r ≃r s => (f : α → β)
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance left (X Y : C) [MonoidalCoherence X Y] :
    MonoidalCoherence (𝟙_ C ⊗ X) Y
-- Mathlib/Data/Set/Lattice.lean
theorem sUnion_union (S T : Set (Set α)) : ⋃₀(S ∪ T) = ⋃₀S ∪ ⋃₀T
-- Mathlib/NumberTheory/Divisors.lean
theorem eq_properDivisors_of_subset_of_sum_eq_sum {s : Finset ℕ} (hsub : s ⊆ n.properDivisors) :
    ((∑ x ∈ s, x) = ∑ x ∈ n.properDivisors, x) → s = n.properDivisors
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem toWeakDualBCNN_continuous : Continuous fun μ : ProbabilityMeasure Ω => μ.toWeakDualBCNN
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma countable_countableGeneratingSet [MeasurableSpace α] [h : CountablyGenerated α] :
    Set.Countable (countableGeneratingSet α)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem derivBFamily_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : IsRegular c)
    (hι : o.card < c) (hc' : c ≠ ℵ₀) (hf : ∀ (i hi), ∀ b < c.ord, f i hi b < c.ord) {a} :
    a < c.ord → derivBFamily.{u, u} o f a < c.ord
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_plift_up (f : PLift ι → Set α) : ⋃ i, f (PLift.up i) = ⋃ i, f i
-- Mathlib/Algebra/Order/Ring/Cast.lean
@[simp, norm_cast]
lemma cast_min : ↑(min a b) = (min a b : R)
-- Mathlib/Data/Setoid/Basic.lean
theorem ker_apply_mk_out {f : α → β} (a : α) : f (haveI := Setoid.ker f; ⟦a⟧.out) = f a
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem _root_.isSelfAdjoint_iff [Star R] {x : R} : IsSelfAdjoint x ↔ star x = x
-- Mathlib/Data/PNat/Xgcd.lean
theorem start_v (a b : ℕ+) : (start a b).v = ⟨a, b⟩
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma ofNat_eq_coe (n : ℕ) [n.AtLeastTwo] (m : α) :
    no_index (OfNat.ofNat n) = (m : WithTop α) ↔ OfNat.ofNat n = m
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp]
theorem dist_le_zero {x y : γ} : dist x y ≤ 0 ↔ x = y