ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Image.lean
theorem image_eta (f : α → β) : f '' s = (fun x => f x) '' s
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem image_eq {Δ Δ' Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ Δ'} [Epi e] {i : Δ' ⟶ Δ''}
    [Mono i] (fac : e ≫ i = φ) : image φ = Δ'
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finSuccEquiv'_symm_none (i : Fin (n + 1)) : (finSuccEquiv' i).symm none = i
-- Mathlib/Data/Rat/Cast/CharZero.lean
@[simp]
theorem coe_cast_hom : ⇑(castHom α) = ((↑) : ℚ → α)
-- Mathlib/Algebra/Regular/Basic.lean
/-- The element `0` is left-regular if and only if `R` is trivial. -/
theorem isLeftRegular_zero_iff_subsingleton : IsLeftRegular (0 : R) ↔ Subsingleton R
-- Mathlib/RingTheory/Adjoin/Field.lean
theorem IsIntegral.minpoly_splits_tower_top [Algebra K L] [IsScalarTower R K L]
    (h : Splits (algebraMap R L) (minpoly R x)) :
    Splits (algebraMap K L) (minpoly K x)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_Ψ₂Sq : (W.map f).Ψ₂Sq = W.Ψ₂Sq.map f
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `balance2` function preserves the ordering invariants. -/
protected theorem Ordered.balance2 {l : RBNode α} {v : α} {r : RBNode α}
    (lv : l.All (cmpLT cmp · v)) (vr : r.All (cmpLT cmp v ·))
    (hl : l.Ordered cmp) (hr : r.Ordered cmp) : (balance2 l v r).Ordered cmp
-- Mathlib/LinearAlgebra/Dual.lean
theorem flip_bijective_iff₁ [FiniteDimensional K V₁] : Bijective B.flip ↔ Bijective B
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
@[simp]
theorem deriv_div (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) (hx : d x ≠ 0) :
    deriv (fun x => c x / d x) x = (deriv c x * d x - c x * deriv d x) / d x ^ 2
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is an algebraic extension of `K = Frac(A)` and `L` has no zero smul divisors by `A`,
then `L` is the localization of the integral closure `C` of `A` in `L` at `A⁰`. -/
theorem IsIntegralClosure.isLocalization [Algebra.IsAlgebraic K L] :
    IsLocalization (Algebra.algebraMapSubmonoid C A⁰) L
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem multiset_sum_sum_index [AddCommMonoid M] [AddCommMonoid N] (f : Multiset (α →₀ M))
    (h : α → M → N) (h₀ : ∀ a, h a 0 = 0)
    (h₁ : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) :
    f.sum.sum h = (f.map fun g : α →₀ M => g.sum h).sum
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
/-- `Real.sinh` as an `Equiv`. -/
@[simps]
def sinhEquiv : ℝ ≃ ℝ
-- Mathlib/Topology/Homotopy/HSpaces.lean
theorem continuous_delayReflRight : Continuous fun p : I × Path x y => delayReflRight p.1 p.2
-- Mathlib/Topology/Inseparable.lean
theorem inseparable_def : (x ~ᵢ y) ↔ 𝓝 x = 𝓝 y
-- Mathlib/RingTheory/Artinian.lean
/-- If `∀ I > J, P I` implies `P J`, then `P` holds for all submodules. -/
theorem induction {P : Submodule R M → Prop} (hgt : ∀ I, (∀ J < I, P J) → P I) (I : Submodule R M) :
    P I
-- Mathlib/Data/NNReal/Basic.lean
nonrec theorem le_div_iff {a b r : ℝ≥0} (hr : r ≠ 0) : a ≤ b / r ↔ a * r ≤ b
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem single_sub {β : ι → Type v} [∀ i, AddGroup (β i)] (i : ι) (x y : β i) :
    single i (x - y) = single i x - single i y
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem coe_sigmaUnique {β : α → Type*} [∀ a, Unique (β a)] :
    (⇑(sigmaUnique α β) : (a : α) × (β a) → α) = Sigma.fst
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_inf_map_of_injective (p q : Submodule R M) : (p.map f ⊓ q.map f).comap f = p ⊓ q
-- Mathlib/Topology/Order/LocalExtr.lean
theorem isLocalExtrOn_const {b : β} : IsLocalExtrOn (fun _ => b) s a
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] theorem negSucc_ne_zero (n : Nat) : -[n+1] ≠ 0
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem coe_sub (f g : CuspForm Γ k) : ⇑(f - g) = f - g
-- Mathlib/Topology/DerivedSet.lean
@[simp]
lemma mem_derivedSet {A : Set X} {x : X} : x ∈ derivedSet A ↔ AccPt x (𝓟 A)
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma jacobiTheta₂_undef (z : ℂ) {τ : ℂ} (hτ : im τ ≤ 0) : jacobiTheta₂ z τ = 0
-- Mathlib/Order/Filter/Cocardinal.lean
@[simp] lemma cocardinal_aleph0_eq_cofinite :
    cocardinal (α := α) isRegular_aleph0 = cofinite
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Module.lean
lemma Module.isClosed_support [Module.Finite R M] :
    IsClosed (Module.support R M)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.disjoint_iff (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')
-- Mathlib/Data/Part.lean
theorem Mem.left_unique : Relator.LeftUnique ((· ∈ ·) : α → Part α → Prop)
-- Mathlib/Order/CompleteLattice.lean
theorem isGLB_biInf {s : Set β} {f : β → α} : IsGLB (f '' s) (⨅ x ∈ s, f x)
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem conj_ofReal (r : ℝ) : conj (r : K) = (r : K)
-- Mathlib/NumberTheory/Rayleigh.lean
/-- Let `0 < r ∈ ℝ` and `j ∈ ℤ`. Then either `j ∈ B'_r` or `B'_r` jumps over `j`. -/
private theorem hit_or_miss' (h : r > 0) :
    j ∈ {beattySeq' r k | k} ∨ ∃ k : ℤ, k ≤ j / r ∧ (j + 1) / r < k + 1
-- Mathlib/Analysis/Calculus/Darboux.lean
/-- **Darboux's theorem**: the image of a `Set.OrdConnected` set under `f'` is a `Set.OrdConnected`
set, `HasDerivWithinAt` version. -/
theorem Set.OrdConnected.image_hasDerivWithinAt {s : Set ℝ} (hs : OrdConnected s)
    (hf : ∀ x ∈ s, HasDerivWithinAt f (f' x) s x) : OrdConnected (f' '' s)
-- Mathlib/Computability/Primrec.lean
theorem nat_div2 : Primrec Nat.div2
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem limNthHom_one : limNthHom f_compat 1 = 1
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem algebraMap_apply' (p : R[X]) : algebraMap R[X] A⟦X⟧ p = map (algebraMap R A) p
-- Mathlib/RingTheory/Regular/RegularSequence.lean
@[simp] lemma ofList_append (rs₁ rs₂ : List R) :
    ofList (rs₁ ++ rs₂) = ofList rs₁ ⊔ ofList rs₂
-- Mathlib/Data/List/Basic.lean
theorem foldl_ext (f g : α → β → α) (a : α) {l : List β} (H : ∀ a : α, ∀ b ∈ l, f a b = g a b) :
    foldl f a l = foldl g a l
-- Mathlib/Data/Finset/Slice.lean
/-- `A` is in the `r`-th slice of `𝒜` iff it's in `𝒜` and has cardinality `r`. -/
theorem mem_slice : A ∈ 𝒜 # r ↔ A ∈ 𝒜 ∧ A.card = r
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
@[reassoc]
theorem diag_σ {X : C} : diag X ≫ σ = 0
-- Mathlib/Data/Option/NAry.lean
@[simp]
theorem map₂_none_left (f : α → β → γ) (b : Option β) : map₂ f none b = none
-- Mathlib/Order/Circular.lean
theorem sbtw_irrefl_left_right {a b : α} : ¬sbtw a b a
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
@[simp]
theorem restrictScalars.map_apply {R : Type u₁} {S : Type u₂} [Ring R] [Ring S] (f : R →+* S)
    {M M' : ModuleCat.{v} S} (g : M ⟶ M') (x) : (restrictScalars f).map g x = g x
-- Mathlib/Analysis/Convex/Hull.lean
theorem subset_convexHull : s ⊆ convexHull 𝕜 s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_lt_sub_of_le_of_lt {a b c d : Int}
  (hab : a ≤ b) (hcd : c < d) : a - d < b - c
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
theorem LinearIndependent.span_eq_top_of_card_eq_finrank {ι : Type*} [Nonempty ι]
    [Fintype ι] {b : ι → V} (lin_ind : LinearIndependent K b)
    (card_eq : Fintype.card ι = finrank K V) : span K (Set.range b) = ⊤
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem lineMap_eq_right_iff [NoZeroSMulDivisors k V1] {p₀ p₁ : P1} {c : k} :
    lineMap p₀ p₁ c = p₁ ↔ p₀ = p₁ ∨ c = 1
-- Mathlib/Data/Finset/Prod.lean
theorem Nonempty.product (hs : s.Nonempty) (ht : t.Nonempty) : (s ×ˢ t).Nonempty
-- Mathlib/Topology/Basic.lean
theorem IsClosed.interior_union_right (h : IsClosed t) :
    interior (s ∪ t) ⊆ interior s ∪ t
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
/-- If a binary fan `t` over `P Q` is a limit cone, then `t.swap` is a limit cone over `Q P`.
-/
@[simps]
def IsLimit.swapBinaryFan {P Q : C} {t : BinaryFan P Q} (I : IsLimit t) : IsLimit t.swap
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem comp_assoc (f : BiheytingHom γ δ) (g : BiheytingHom β γ) (h : BiheytingHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_le' (f : ι → α) (i : ι) : iInf f ≤ f i
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
/-- If `V : Π i, G i →ₗᵢ[𝕜] E` is an orthogonal family such that the supremum of the ranges of
`V i` is dense, then `(E, V)` is a Hilbert sum of `G`. -/
theorem IsHilbertSum.mk [∀ i, CompleteSpace <| G i] (hVortho : OrthogonalFamily 𝕜 G V)
    (hVtotal : ⊤ ≤ (⨆ i, LinearMap.range (V i).toLinearMap).topologicalClosure) :
    IsHilbertSum 𝕜 G V
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
@[simp]
lemma cfc_algebraMap (r : R) (f : R → R) : cfc f (algebraMap R A r) = algebraMap R A (f r)
-- Mathlib/Order/RelSeries.lean
@[simp] lemma head_eraseLast (p : RelSeries r) : p.eraseLast.head = p.head
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The product map of two `C^n` functions is `C^n`. -/
theorem ContDiff.prod_map {f : E → F} {g : E' → F'} (hf : ContDiff 𝕜 n f) (hg : ContDiff 𝕜 n g) :
    ContDiff 𝕜 n (Prod.map f g)
-- Mathlib/Topology/Algebra/GroupWithZero.lean
/-- `h x (f x / g x)` is continuous under certain conditions, even if the denominator is sometimes
  `0`. See docstring of `ContinuousAt.comp_div_cases`. -/
theorem Continuous.comp_div_cases {f g : α → G₀} (h : α → G₀ → β) (hf : Continuous f)
    (hg : Continuous g) (hh : ∀ a, g a ≠ 0 → ContinuousAt (↿h) (a, f a / g a))
    (h2h : ∀ a, g a = 0 → Tendsto (↿h) (𝓝 a ×ˢ ⊤) (𝓝 (h a 0))) :
    Continuous fun x => h x (f x / g x)
-- Mathlib/Algebra/BigOperators/Pi.lean
@[ext]
theorem RingHom.functions_ext [Finite I] (G : Type*) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)
    (H : ∀ (i : I) (x : f i), g (single i x) = h (single i x)) : g = h
-- Mathlib/Combinatorics/Configuration.lean
theorem one_lt_order [Finite P] [Finite L] : 1 < order P L
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem exists_eq_tmul_of_forall (x : TensorProduct R M N)
    (h : ∀ (m₁ m₂ : M) (n₁ n₂ : N), ∃ m n, m₁ ⊗ₜ n₁ + m₂ ⊗ₜ n₂ = m ⊗ₜ[R] n) :
    ∃ m n, x = m ⊗ₜ n
-- Mathlib/Data/Real/Irrational.lean
theorem sub_int (h : Irrational x) (m : ℤ) : Irrational (x - m)
-- Mathlib/Topology/Irreducible.lean
theorem IsIrreducible.isPreirreducible (h : IsIrreducible s) : IsPreirreducible s
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Young's inequality**, a version for nonnegative real numbers. -/
theorem young_inequality_of_nonneg {a b p q : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (hpq : p.IsConjExponent q) : a * b ≤ a ^ p / p + b ^ q / q
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_copy (f : A →⋆ₐ[R] B) (f' : A → B) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem toSmoothPartitionOfUnity_zero_of_zero {i : ι} {x : M} (h : fs i x = 0) :
    fs.toSmoothPartitionOfUnity i x = 0
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem refl_prod_refl :
    (PartialEquiv.refl α).prod (PartialEquiv.refl β) = PartialEquiv.refl (α × β)
-- Mathlib/FieldTheory/Minpoly/Field.lean
/-- If `L/K` is a field extension and an element `y` of `K` is a root of the minimal polynomial
of an element `x ∈ L`, then `y` maps to `x` under the field embedding. -/
theorem root {x : B} (hx : IsIntegral A x) {y : A} (h : IsRoot (minpoly A x) y) :
    algebraMap A B y = x
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem semiconjBy_iff_semiconj {f g₁ g₂ : CircleDeg1Lift} :
    SemiconjBy f g₁ g₂ ↔ Semiconj f g₁ g₂
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp]
theorem homOfLE_comp {x y z : X} (h : x ≤ y) (k : y ≤ z) :
    homOfLE h ≫ homOfLE k = homOfLE (h.trans k)
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
@[simp]
theorem comp_hom' {M N K : Bimod A B} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : Hom M K).hom = f.hom ≫ g.hom
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem insertNth_apply_same (i : Fin (n + 1)) (x : α i) (p : ∀ j, α (i.succAbove j)) :
    insertNth i x p i = x
-- Mathlib/Algebra/Star/Subsemiring.lean
/-- A (unital) star subsemiring is a non-associative ring which is closed under the `star`
operation. -/
structure StarSubsemiring (R : Type v) [NonAssocSemiring R] [Star R]
    extends Subsemiring R : Type v where
  /-- The `carrier` of a `StarSubsemiring` is closed under the `star` operation. -/
  star_mem' {a} : a ∈ carrier → star a ∈ carrier
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_eq_top (f : ι → α) : iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Postcomposing `f` with `Prod.snd` is `C^n` -/
theorem ContDiff.snd {f : E → F × G} (hf : ContDiff 𝕜 n f) : ContDiff 𝕜 n fun x => (f x).2
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
@[ext]
lemma ext' {F G : LaxMonoidalFunctor C D} {α β : F ⟶ G} (w : ∀ X : C, α.app X = β.app X) : α = β
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem keys_nil : @keys α β [] = []
-- Mathlib/Topology/PartitionOfUnity.lean
theorem continuous_toPOUFun (i : ι) : Continuous (f.toPOUFun i)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem iSup_le_sum {ι} (f : ι → Cardinal) : iSup f ≤ sum f
-- Mathlib/Logic/Nontrivial/Defs.lean
theorem exists_pair_ne (α : Type*) [Nontrivial α] : ∃ x y : α, x ≠ y
-- Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean
/-- Given an ideal `𝓟` of a commutative semiring `R`, we say that a polynomial `f : R[X]`
is *weakly Eisenstein at `𝓟`* if `∀ n, n < f.natDegree → f.coeff n ∈ 𝓟`. -/
@[mk_iff]
structure IsWeaklyEisensteinAt [CommSemiring R] (f : R[X]) (𝓟 : Ideal R) : Prop where
  mem : ∀ {n}, n < f.natDegree → f.coeff n ∈ 𝓟
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
@[simp] lemma zero_le' : 0 ≤ a
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem intervalIntegrable_iff_integrableOn_Ioo_of_le [NoAtoms μ] (hab : a ≤ b) :
    IntervalIntegrable f μ a b ↔ IntegrableOn f (Ioo a b) μ
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean
theorem isCompactOpen_iff_eq_finset_affine_union {X : Scheme} (U : Set X) :
    IsCompact U ∧ IsOpen U ↔ ∃ s : Set X.affineOpens, s.Finite ∧ U = ⋃ i ∈ s, i
-- Mathlib/Data/Nat/Defs.lean
lemma dvd_mul_of_div_dvd (h : b ∣ a) (hdiv : a / b ∣ c) : a ∣ b * c
-- Mathlib/Data/Real/EReal.lean
lemma sign_mul_inv_abs (a : EReal) : (sign a) * (a.abs : EReal)⁻¹ = a⁻¹
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_neg_le_of_le {p : R[X]} (hp : natDegree p ≤ m) : natDegree (-p) ≤ m
-- Mathlib/FieldTheory/Fixed.lean
theorem ne_one : minpoly G F x ≠ (1 : Polynomial (FixedPoints.subfield G F))
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
theorem coe_measurableEquiv : ⇑(EuclideanSpace.measurableEquiv ι) = WithLp.equiv 2 _
-- Mathlib/Order/Filter/Bases.lean
theorem generate_neBot_iff {s : Set (Set α)} :
    NeBot (generate s) ↔ ∀ t, t ⊆ s → t.Finite → (⋂₀ t).Nonempty
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_diff' (s : Set α) (hm : MeasurableSet t) (h_fin : μ t ≠ ∞) :
    μ (s \ t) = μ (s ∪ t) - μ t
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem div_I (z : K) : z / I = -(z * I)
-- Mathlib/Analysis/Convex/StoneSeparation.lean
/-- In a tetrahedron with vertices `x`, `y`, `p`, `q`, any segment `[u, v]` joining the opposite
edges `[x, p]` and `[y, q]` passes through any triangle of vertices `p`, `q`, `z` where
`z ∈ [x, y]`. -/
theorem not_disjoint_segment_convexHull_triple {p q u v x y z : E} (hz : z ∈ segment 𝕜 x y)
    (hu : u ∈ segment 𝕜 x p) (hv : v ∈ segment 𝕜 y q) :
    ¬Disjoint (segment 𝕜 u v) (convexHull 𝕜 {p, q, z})
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem HasMFDerivAt.mul (hp : HasMFDerivAt I 𝓘(𝕜, F') p z p')
    (hq : HasMFDerivAt I 𝓘(𝕜, F') q z q') :
    HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + q z • p' : E →L[𝕜] F')
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_max_mul_right (a b c : Nat) : max (a * c) (b * c) = max a b * c
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[simp] theorem modifyHead_nil (f : α → α) : [].modifyHead f = []
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- In the space `ℝ × ℝ`, the Hausdorff measure coincides exactly with the Lebesgue measure. -/
@[simp]
theorem hausdorffMeasure_prod_real : (μH[2] : Measure (ℝ × ℝ)) = volume
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem DirectSum.coeLinearMap_eq_dfinsupp_sum [DecidableEq σ] [DecidableEq R] [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) :
    (coeLinearMap fun i : M => weightedHomogeneousSubmodule R w i) x =
      DFinsupp.sum x (fun _ x => ↑x)
-- Mathlib/Data/List/Rotate.lean
theorem Nodup.rotate_congr_iff {l : List α} (hl : l.Nodup) {i j : ℕ} :
    l.rotate i = l.rotate j ↔ i % l.length = j % l.length ∨ l = []
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem ContinuousOn.div (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₀ : ∀ x ∈ s, g x ≠ 0) :
    ContinuousOn (f / g) s
-- Mathlib/MeasureTheory/Measure/Haar/Disintegration.lean
/-- To check that a property holds almost everywhere with respect to an additive Haar measure, it
suffices to check it almost everywhere along all translates of a given vector subspace. This is an
instance of a disintegration argument for additive Haar measures. -/
lemma ae_mem_of_ae_add_linearMap_mem [LocallyCompactSpace F] {s : Set F} (hs : MeasurableSet s)
    (h : ∀ y, ∀ᵐ x ∂μ, y + L x ∈ s) : ∀ᵐ y ∂ν, y ∈ s
-- Mathlib/CategoryTheory/EpiMono.lean
/-- In a category in which every monomorphism is split, every monomorphism splits. This is not an
    instance because it would create an instance loop. -/
theorem isSplitMono_of_mono [SplitMonoCategory C] {X Y : C} (f : X ⟶ Y) [Mono f] : IsSplitMono f
-- Mathlib/Data/Int/ModEq.lean
protected theorem add_right_cancel' (c : ℤ) (h : a + c ≡ b + c [ZMOD n]) : a ≡ b [ZMOD n]
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_add_const_Ici : (fun x => x + a) ⁻¹' Ici b = Ici (b - a)
-- Mathlib/Algebra/Order/Ring/WithTop.lean
lemma mul_eq_top_iff : a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.span_repr_eq [Nontrivial R] (x) :
    Span.repr R (Set.range v) x =
      (hv.repr x).equivMapDomain (Equiv.ofInjective _ hv.injective)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mul_eq_max' {a b : Cardinal} (h : ℵ₀ ≤ a * b) : a * b = max a b
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem le_add_right (a b : Ordinal) : a ≤ a + b
-- Mathlib/Logic/IsEmpty.lean
/-- subtypes by an all-false predicate are false. -/
theorem Subtype.isEmpty_of_false {p : α → Prop} (hp : ∀ a, ¬p a) : IsEmpty (Subtype p)
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[elementwise, simp]
theorem ofRestrict_invApp {C : Type*} [Category C] (X : PresheafedSpace C) {Y : TopCat}
    {f : Y ⟶ TopCat.of X.carrier} (h : OpenEmbedding f) (U : Opens (X.restrict h).carrier) :
    (PresheafedSpace.IsOpenImmersion.ofRestrict X h).invApp U = 𝟙 _
-- Mathlib/SetTheory/Cardinal/PartENat.lean
theorem toPartENat_apply_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : toPartENat c = ⊤
-- Mathlib/Analysis/Calculus/SmoothSeries.lean
/-- Consider a series of smooth functions, with summable uniform bounds on the successive
derivatives. Then the iterated derivative of the sum is the sum of the iterated derivative. -/
theorem iteratedFDeriv_tsum_apply (hf : ∀ i, ContDiff 𝕜 N (f i))
    (hv : ∀ k : ℕ, (k : ℕ∞) ≤ N → Summable (v k))
    (h'f : ∀ (k : ℕ) (i : α) (x : E), (k : ℕ∞) ≤ N → ‖iteratedFDeriv 𝕜 k (f i) x‖ ≤ v k i) {k : ℕ}
    (hk : (k : ℕ∞) ≤ N) (x : E) :
    iteratedFDeriv 𝕜 k (fun y => ∑' n, f n y) x = ∑' n, iteratedFDeriv 𝕜 k (f n) x
-- Mathlib/Order/UpperLower/Basic.lean
theorem Set.OrdConnected.upperClosure_inter_lowerClosure (h : s.OrdConnected) :
    ↑(upperClosure s) ∩ ↑(lowerClosure s) = s
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem mem_comap {s : NonUnitalSubsemiring S} {f : F} {x : R} : x ∈ s.comap f ↔ f x ∈ s
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem mclosure_preimage_le (f : M →ₙ* N) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lTensor_trans : (f ≪≫ₗ g).lTensor M = f.lTensor M ≪≫ₗ g.lTensor M
-- Mathlib/Data/Nat/PartENat.lean
@[simp, norm_cast]
theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n
-- Mathlib/Algebra/Pointwise/Stabilizer.lean
@[to_additive]
lemma mem_stabilizer_finset {s : Finset α} : a ∈ stabilizer G s ↔ ∀ b, a • b ∈ s ↔ b ∈ s
-- Mathlib/Order/Circular.lean
@[simp]
theorem mem_cIoo {a b x : α} : x ∈ cIoo a b ↔ sbtw a x b
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
theorem StrictConvexSpace.of_norm_combo_ne_one
    (h :
      ∀ x y : E,
        ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b : ℝ, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1) :
    StrictConvexSpace ℝ E
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
theorem uniformCauchySeqOn_ball_of_deriv {r : ℝ} (hf' : UniformCauchySeqOn f' l (Metric.ball x r))
    (hf : ∀ n : ι, ∀ y : 𝕜, y ∈ Metric.ball x r → HasDerivAt (f n) (f' n y) y)
    (hfg : Cauchy (map (fun n => f n x) l)) : UniformCauchySeqOn f l (Metric.ball x r)
-- Mathlib/FieldTheory/KummerExtension.lean
lemma root_X_pow_sub_C_ne_zero_iff {n : ℕ} {a : K} (H : Irreducible (X ^ n - C a)) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0 ↔ a ≠ 0
-- Mathlib/Order/Basic.lean
@[simp]
theorem mk_lt_mk : (a₁, b₁) < (a₂, b₂) ↔ a₁ < a₂ ∧ b₁ ≤ b₂ ∨ a₁ ≤ a₂ ∧ b₁ < b₂
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `add_tsub_assoc_of_le` for the equality. -/
theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c)
-- Mathlib/Data/Set/Function.lean
theorem MapsTo.union (h₁ : MapsTo f s₁ t) (h₂ : MapsTo f s₂ t) : MapsTo f (s₁ ∪ s₂) t
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem supp_subset_range (h : natDegree p < m) : p.support ⊆ Finset.range m
-- Mathlib/Analysis/Convex/Cone/Pointed.lean
@[simp]
theorem mem_comap {f : E →ₗ[𝕜] F} {S : PointedCone 𝕜 F} {x : E} : x ∈ S.comap f ↔ f x ∈ S
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Bool.of_not_eq_true : {b : Bool} → ¬ (b = true) → b = false
-- Mathlib/Probability/Kernel/Basic.lean
@[simp]
theorem setLIntegral_restrict (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞)
    (t : Set β) : ∫⁻ b in t, f b ∂κ.restrict hs a = ∫⁻ b in t ∩ s, f b ∂κ a
-- Mathlib/Algebra/Associated/Basic.lean
theorem associated_iff_eq {x y : α} : x ~ᵤ y ↔ x = y
-- Mathlib/NumberTheory/Harmonic/GammaDeriv.lean
lemma hasDerivAt_Gamma_nat (n : ℕ) :
    HasDerivAt Gamma (n ! * (-γ + harmonic n)) (n + 1)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- Composing a multilinear map with the identity linear map in each argument. -/
@[simp]
theorem compLinearMap_id (g : MultilinearMap R M₁' M₂) :
    (g.compLinearMap fun _ => LinearMap.id) = g
-- Mathlib/ModelTheory/FinitelyGenerated.lean
theorem cg_def : CG L M ↔ (⊤ : L.Substructure M).CG
-- Mathlib/Analysis/Complex/Isometry.lean
theorem rotation_ne_conjLIE (a : circle) : rotation a ≠ conjLIE
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
@[reassoc]
lemma add_comp (f₁ f₂ : X' ⟶ Y') (g : Y' ⟶ Z') :
    add W eX eY f₁ f₂ ≫ g = add W eX eZ (f₁ ≫ g) (f₂ ≫ g)
-- Mathlib/Order/SymmDiff.lean
theorem codisjoint_bihimp_sup : Codisjoint (a ⇔ b) (a ⊔ b)
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem div_tendsto_atTop_of_degree_gt' (hdeg : Q.degree < P.degree)
    (hpos : 0 < P.leadingCoeff / Q.leadingCoeff) :
    Tendsto (fun x => eval x P / eval x Q) atTop atTop
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem repr_fract_apply (m : E) (i : ι) : b.repr (fract b m) i = Int.fract (b.repr m i)
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[reassoc (attr := simp)]
theorem imageMonoIsoSource_inv_ι [Mono f] : (imageMonoIsoSource f).inv ≫ image.ι f = f
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem _root_.Disjoint.edgeSet {H₁ H₂ : Subgraph G} (h : Disjoint H₁ H₂) :
    Disjoint H₁.edgeSet H₂.edgeSet