ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem normalizedFactors_zero : normalizedFactors (0 : α) = 0
-- Mathlib/Order/Interval/Finset/Box.lean
private lemma Icc_neg_mono : Monotone fun n : ℕ ↦ Icc (-n : α) n
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem sum_ofWithBot {M : Type*} [AddCommMonoid M] (boxes : Finset (WithBot (Box ι)))
    (le_of_mem : ∀ J ∈ boxes, (J : WithBot (Box ι)) ≤ I)
    (pairwise_disjoint : Set.Pairwise (boxes : Set (WithBot (Box ι))) Disjoint) (f : Box ι → M) :
    (∑ J ∈ (ofWithBot boxes le_of_mem pairwise_disjoint).boxes, f J) =
      ∑ J ∈ boxes, Option.elim' 0 f J
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
@[simp]
theorem arctan_eq_zero_iff {x : ℝ} : arctan x = 0 ↔ x = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem associated_iff_normalizedFactors_eq_normalizedFactors {x y : α} (hx : x ≠ 0) (hy : y ≠ 0) :
    x ~ᵤ y ↔ normalizedFactors x = normalizedFactors y
-- Mathlib/Order/Interval/Set/Image.lean
@[simp] lemma preimage_subtype_val_Icc (a b : {x // p x}) : (↑) ⁻¹' (Icc a.1 b) = Icc a b
-- Mathlib/Data/Finset/Basic.lean
theorem erase_subset_iff_of_mem (h : a ∈ t) : s.erase a ⊆ t ↔ s ⊆ t
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
/-- The split mono which appears in the factorisation `decompId P`. -/
@[simps]
def decompId_i (P : Karoubi C) : P ⟶ P.X
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem tendsto_approxOn_range_Lp_eLpNorm [BorelSpace E] {f : β → E} (hp_ne_top : p ≠ ∞)
    {μ : Measure β} (fmeas : Measurable f) [SeparableSpace (range f ∪ {0} : Set E)]
    (hf : eLpNorm f p μ < ∞) :
    Tendsto (fun n => eLpNorm (⇑(approxOn f fmeas (range f ∪ {0}) 0 (by simp) n) - f) p μ)
      atTop (𝓝 0)
-- Mathlib/RingTheory/Trace/Basic.lean
theorem traceMatrix_eq_embeddingsMatrixReindex_mul_trans [Fintype κ] (e : κ ≃ (L →ₐ[K] E)) :
    (traceMatrix K b).map (algebraMap K E) =
      embeddingsMatrixReindex K E b e * (embeddingsMatrixReindex K E b e)ᵀ
-- Mathlib/Data/Finset/Basic.lean
theorem subset_union_left {s₁ s₂ : Finset α} : s₁ ⊆ s₁ ∪ s₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arccos_of_le_neg_one {x : ℝ} (hx : x ≤ -1) : arccos x = π
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
@[simp]
theorem sum_toMatrix_smul_self [Fintype ι] : ∑ i : ι, e.toMatrix v i j • e i = v j
-- Mathlib/LinearAlgebra/Ray.lean
@[simp]
theorem sameRay_smul_left_iff {v : M} {r : R} : SameRay R (r • v) v ↔ 0 ≤ r ∨ v = 0
-- Mathlib/Order/RelClasses.lean
theorem IsPreorder.swap (r) [IsPreorder α r] : IsPreorder α (swap r)
-- Mathlib/Data/Finset/Density.lean
@[simp] lemma dens_eq_zero : dens s = 0 ↔ s = ∅
-- Mathlib/Topology/LocalAtTarget.lean
theorem Set.restrictPreimage_inducing (s : Set β) (h : Inducing f) :
    Inducing (s.restrictPreimage f)
-- Mathlib/CategoryTheory/Quotient.lean
@[simp]
theorem lift.isLift_hom (X : C) : (lift.isLift r F H).hom.app X = 𝟙 (F.obj X)
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem areaForm_apply_self (x : E) : ω x x = 0
-- Mathlib/Analysis/Convex/Hull.lean
@[simp]
theorem convexHull_nonempty_iff : (convexHull 𝕜 s).Nonempty ↔ s.Nonempty
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
@[symm]
theorem symm (h : IsMetricSeparated s t) : IsMetricSeparated t s
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem eq_zero_of_bot_submodule : ∀ b : (⊥ : Submodule R M), b = 0
-- Mathlib/LinearAlgebra/Dimension/Free.lean
theorem FiniteDimensional.finrank_of_not_finite
    (h : ¬Module.Finite R M) :
    finrank R M = 0
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem subset_pointwise_smul_iff {a : α} {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
/-- `P⁺⁺` is always a sheaf. -/
theorem isSheaf_plus_plus (P : Cᵒᵖ ⥤ D) : Presheaf.IsSheaf J (J.plusObj (J.plusObj P))
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.mem_closure_image {f : α → β} {s : Set α} {x : α}
    (h : ContinuousWithinAt f s x) (hx : x ∈ closure s) : f x ∈ closure (f '' s)
-- Mathlib/Topology/Bases.lean
theorem countable_countableBasis [SecondCountableTopology α] : (countableBasis α).Countable
-- Mathlib/Topology/Homotopy/Basic.lean
/-- If each `f₀ i : C(X, Y i)` is homotopic to `f₁ i : C(X, Y i)`, then `ContinuousMap.pi f₀` is
homotopic to `ContinuousMap.pi f₁`. -/
protected theorem piMap {X Y : ι → Type*} [∀ i, TopologicalSpace (X i)]
    [∀ i, TopologicalSpace (Y i)] {f₀ f₁ : ∀ i, C(X i, Y i)} (F : ∀ i, Homotopic (f₀ i) (f₁ i)) :
    Homotopic (.piMap f₀) (.piMap f₁)
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_le {S : Subalgebra R A} (H : s ⊆ S) : adjoin R s ≤ S
-- Mathlib/Data/Nat/Lattice.lean
theorem sSup_def {s : Set ℕ} (h : ∃ n, ∀ a ∈ s, a ≤ n) :
    sSup s = @Nat.find (fun n ↦ ∀ a ∈ s, a ≤ n) _ h
-- Mathlib/CategoryTheory/Preadditive/Mat.lean
@[reassoc (attr := simp)]
lemma ι_additiveObjIsoBiproduct_inv (F : Mat_ C ⥤ D) [Functor.Additive F] (M : Mat_ C) (i : M.ι) :
    biproduct.ι _ i ≫ (additiveObjIsoBiproduct F M).inv =
      F.map (biproduct.ι _ i ≫ M.isoBiproductEmbedding.inv)
-- Mathlib/Data/Finset/Basic.lean
theorem subset_erase {a : α} {s t : Finset α} : s ⊆ t.erase a ↔ s ⊆ t ∧ a ∉ s
-- Mathlib/Analysis/NormedSpace/MatrixExponential.lean
nonrec theorem exp_add_of_commute (A B : Matrix m m 𝔸) (h : Commute A B) :
    exp 𝕂 (A + B) = exp 𝕂 A * exp 𝕂 B
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- If a property holds for all points in balls of arbitrarily large radii, then it holds for all
points. -/
theorem forall_of_forall_mem_ball (p : α → Prop) (x : α)
    (H : ∃ᶠ R : ℝ in atTop, ∀ y ∈ ball x R, p y) (y : α) : p y
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem toReal_zero : (0 : Angle).toReal = 0
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- `liminf (xᵢ - c) = (liminf xᵢ) - c`. -/
lemma liminf_sub_const (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.liminf (fun i ↦ f i - c) F = Filter.liminf f F - c
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem of_d (j : α) : (of X d sq).d (j + 1) j = d j
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem apply_mem {s : S} (hs : s ∈ spectrum S a) : f s ∈ spectrum R a
-- Mathlib/Data/Set/Sups.lean
theorem infs_left_comm : s ⊼ (t ⊼ u) = t ⊼ (s ⊼ u)
-- Mathlib/Order/Disjoint.lean
theorem dual (h : IsCompl x y) : IsCompl (toDual x) (toDual y)
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem coe_inf [T2Space α] (s t : Compacts α) : (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem linear_mk' (e : P₁ ≃ P₂) (e' : V₁ ≃ₗ[k] V₂) (p h) : (mk' e e' p h).linear = e'
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem strictMono_iff_map_neg : StrictMono (f : α → β) ↔ ∀ a < 0, f a < 0
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem canonicalEquiv_spanSingleton {P'} [CommRing P'] [Algebra R P'] [IsLocalization S P']
    (x : P) :
    canonicalEquiv S P P' (spanSingleton S x) =
      spanSingleton S
        (IsLocalization.map P' (RingHom.id R)
          (fun y (hy : y ∈ S) => show RingHom.id R y ∈ S from hy) x)
-- Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean
/-- `triangleRotateShortComplex φ` is a degreewise split short exact sequence of
cochain complexes. -/
@[simps]
noncomputable def triangleRotateShortComplexSplitting (n : ℤ) :
    ((triangleRotateShortComplex φ).map (eval _ _ n)).Splitting
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem toReal_coe_ennreal : ∀ {x : ℝ≥0∞}, toReal (x : EReal) = ENNReal.toReal x
-- Mathlib/LinearAlgebra/Projection.lean
theorem linearProjOfIsCompl_idempotent (h : IsCompl p q) (x : E) :
    linearProjOfIsCompl p q h (linearProjOfIsCompl p q h x) = linearProjOfIsCompl p q h x
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma toUpperSet_specializes_toUpperSet {a b : α} :
    toUpperSet a ⤳ toUpperSet b ↔ b ≤ a
-- Mathlib/Algebra/Order/Floor.lean
/-- Natural division is the floor of field division. -/
theorem floor_div_eq_div (m n : ℕ) : ⌊(m : α) / n⌋₊ = m / n
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem rotate_nil (n : ℕ) : ([] : List α).rotate n = []
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp]
theorem pi_apply [Fintype ι] (Q : ∀ i, QuadraticMap R (Mᵢ i) P) (x : ∀ i, Mᵢ i) :
    pi Q x = ∑ i, Q i (x i)
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_iUnion_le_tsum_nat : ∀ s : ℕ → Set α,
    extend m (⋃ i, s i) ≤ ∑' i, extend m (s i)
-- Mathlib/Topology/Germ.lean
@[simp]
theorem sliceRight_coe [TopologicalSpace Y] {y : Y} (f : X × Y → Z) :
    (↑f : Germ (𝓝 (x, y)) Z).sliceRight = fun y' ↦ f (x, y')
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem Monotone.quasiconvexOn (hf : Monotone f) : QuasiconvexOn 𝕜 univ f
-- Mathlib/Algebra/Module/Basic.lean
/-- If `E` is a vector space over two division rings `R` and `S`, then scalar multiplications
agree on inverses of integer numbers in `R` and `S`. -/
theorem inv_intCast_smul_eq {E : Type*} (R S : Type*) [AddCommGroup E] [DivisionRing R]
    [DivisionRing S] [Module R E] [Module S E] (n : ℤ) (x : E) : (n⁻¹ : R) • x = (n⁻¹ : S) • x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem add_nat_eq {a : Cardinal} (n : ℕ) (ha : ℵ₀ ≤ a) : a + n = a
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[simp]
theorem eLpNorm'_exponent_zero {f : α → F} : eLpNorm' f 0 μ = 1
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem Filter.EventuallyEq.lineDifferentiableWithinAt_iff_of_mem
    (h : f₀ =ᶠ[𝓝[s] x] f₁) (hx : x ∈ s) :
    LineDifferentiableWithinAt 𝕜 f₀ s x v ↔ LineDifferentiableWithinAt 𝕜 f₁ s x v
-- Mathlib/Order/LatticeIntervals.lean
protected lemma isCompl_iff [Lattice α] [BoundedOrder α] {x y : Iic a} :
    IsCompl x y ↔ Disjoint (x : α) (y : α) ∧ (x : α) ⊔ (y : α) = a
-- Mathlib/Order/CompleteLatticeIntervals.lean
theorem subset_sInf_of_not_bddBelow [Inhabited s] {t : Set s} (ht : ¬BddBelow t) :
    sInf t = default
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_update_ne_zero (p : R[X]) (n : ℕ) {a : R} (ha : a ≠ 0) :
    support (p.update n a) = insert n p.support
-- Mathlib/Algebra/CharP/ExpChar.lean
/-- The exponential characteristic is one if the characteristic is zero. -/
theorem expChar_one_of_char_zero (q : ℕ) [hp : CharP R 0] [hq : ExpChar R q] : q = 1
-- Mathlib/Data/ULift.lean
@[simp]
theorem «exists» {p : PLift α → Prop} : (∃ x, p x) ↔ ∃ x : α, p (PLift.up x)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_add_eq_right_of_natDegree_lt (h : natDegree p < natDegree q) :
    natDegree (p + q) = natDegree q
-- Mathlib/Algebra/Group/Defs.lean
/-- An additive semigroup is a type with an associative `(+)`. -/
@[ext]
class AddSemigroup (G : Type u) extends Add G where
  /-- Addition is associative -/
  protected add_assoc : ∀ a b c : G, a + b + c = a + (b + c)
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem isSheaf_of_iso_iff {P P' : Cᵒᵖ ⥤ A} (e : P ≅ P') : IsSheaf J P ↔ IsSheaf J P'
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem chromaticNumber_bddBelow : BddBelow { n : ℕ | G.Colorable n }
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[simp]
theorem kernelSubobjectIsoComp_hom_arrow {X' : C} (f : X' ⟶ X) [IsIso f] (g : X ⟶ Y) [HasKernel g] :
    (kernelSubobjectIsoComp f g).hom ≫ (kernelSubobject g).arrow =
      (kernelSubobject (f ≫ g)).arrow ≫ f
-- Mathlib/Data/Multiset/Dedup.lean
@[simp]
theorem dedup_nsmul {s : Multiset α} {n : ℕ} (h0 : n ≠ 0) : (n • s).dedup = s.dedup
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem finite_dist_eq (x y : e.finiteSubspace) : dist x y = (e (x - y)).toReal
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuous_unique [Unique ι] {F : ι → X → α} :
    Equicontinuous F ↔ Continuous (F default)
-- Mathlib/Order/BoundedOrder.lean
theorem StrictAnti.apply_eq_bot_iff (hf : StrictAnti f) : f a = f ⊥ ↔ a = ⊥
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
/-- Let `M` be a smooth σ-compact manifold with a metric. Let `K : ι → Set M` be a locally finite
family of closed sets, let `U : ι → Set M` be a family of open sets such that `K i ⊆ U i` for all
`i`. Then there exists a positive smooth function `δ : M → ℝ≥0` such that for any `i` and `x ∈ K i`,
we have `Metric.closedBall x (δ x) ⊆ U i`. -/
theorem Metric.exists_smooth_forall_closedBall_subset {M} [MetricSpace M] [ChartedSpace H M]
    [SmoothManifoldWithCorners I M] [SigmaCompactSpace M] {K : ι → Set M} {U : ι → Set M}
    (hK : ∀ i, IsClosed (K i)) (hU : ∀ i, IsOpen (U i)) (hKU : ∀ i, K i ⊆ U i)
    (hfin : LocallyFinite K) :
    ∃ δ : C^∞⟮I, M; 𝓘(ℝ, ℝ), ℝ⟯,
      (∀ x, 0 < δ x) ∧ ∀ (i), ∀ x ∈ K i, Metric.closedBall x (δ x) ⊆ U i
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem inclusion_inj_on_objects {S T : Subgroupoid C} (h : S ≤ T) :
    Function.Injective (inclusion h).obj
-- Mathlib/Computability/Primrec.lean
theorem encdec : Primrec fun n => encode (@decode α _ n)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
lemma map_mk (g : A →+* B)
    (comap_le : P ≤ Q.comap g) (hg : ∀ i, ∀ a ∈ 𝒜 i, g a ∈ ℬ i) (x) :
    map 𝒜 ℬ g comap_le hg (mk x) =
    mk ⟨x.1, ⟨_, hg _ _ x.2.2⟩, ⟨_, hg _ _ x.3.2⟩, comap_le x.4⟩
-- Mathlib/Data/Stream/Init.lean
theorem tails_eq (s : Stream' α) : tails s = tail s::tails (tail s)
-- Mathlib/GroupTheory/Perm/Support.lean
theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x }
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : ⋃ b, Ioo a b = Ioi a
-- Mathlib/Combinatorics/Additive/Corner/Defs.lean
lemma isCorner_image (hf : IsAddFreimanIso 2 s t f) (hAs : A ⊆ s ×ˢ s)
    (hx₁ : x₁ ∈ s) (hy₁ : y₁ ∈ s) (hx₂ : x₂ ∈ s) (hy₂ : y₂ ∈ s) :
    IsCorner (Prod.map f f '' A) (f x₁) (f y₁) (f x₂) (f y₂) ↔ IsCorner A x₁ y₁ x₂ y₂
-- Mathlib/LinearAlgebra/StdBasis.lean
theorem iSup_range_stdBasis_le_iInf_ker_proj (I J : Set ι) (h : Disjoint I J) :
    ⨆ i ∈ I, range (stdBasis R φ i) ≤ ⨅ i ∈ J, ker (proj i : (∀ i, φ i) →ₗ[R] φ i)
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.image_closure {f : α → β} {s : Set α} (hf : ContinuousOn f (closure s)) :
    f '' closure s ⊆ closure (f '' s)
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem vsub_subset_vsub_left : t₁ ⊆ t₂ → s -ᵥ t₁ ⊆ s -ᵥ t₂
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem nnnorm_indicatorConstLp_le :
    ‖indicatorConstLp p hs hμs c‖₊ ≤ ‖c‖₊ * (μ s).toNNReal ^ (1 / p.toReal)
-- Mathlib/CategoryTheory/Idempotents/HomologicalComplex.lean
/-- The functor `HomologicalComplex (Karoubi C) c ⥤ Karoubi (HomologicalComplex C c)`,
on morphisms -/
@[simps]
def map {K L : HomologicalComplex (Karoubi C) c} (f : K ⟶ L) : obj K ⟶ obj L
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
@[simp]
theorem order_zero : (0 : FormalMultilinearSeries 𝕜 E F).order = 0
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_biUnion_of_directed {η} {s : Set η} {t : η → Set M}
    (hs : DirectedOn (t ⁻¹'o (· ⊆ ·)) s) (h : ∀ a ∈ s, LinearIndependent R (fun x => x : t a → M)) :
    LinearIndependent R (fun x => x : (⋃ a ∈ s, t a) → M)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem mem_Lp_of_ae_le_mul {c : ℝ} {f : α →ₘ[μ] E} {g : Lp F p μ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) : f ∈ Lp E p μ
-- Mathlib/Order/Filter/Basic.lean
theorem NeBot.of_map : NeBot (f.map m) → NeBot f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma slope_of_Y_ne {x₁ x₂ y₁ y₂ : F} (hx : x₁ = x₂) (hy : y₁ ≠ W.negY x₂ y₂) :
    W.slope x₁ x₂ y₁ y₂ =
      (3 * x₁ ^ 2 + 2 * W.a₂ * x₁ + W.a₄ - W.a₁ * y₁) / (y₁ - W.negY x₁ y₁)
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
/-- The points with `v.limRatioMeas hρ x = ∞` have measure `0` for `μ`. -/
theorem measure_limRatioMeas_top : μ {x | v.limRatioMeas hρ x = ∞} = 0
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem inv_zetaUnit : ((zetaUnit⁻¹ : (ArithmeticFunction R)ˣ) : ArithmeticFunction R) = μ
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem toGerm_eq (f : α →ₘ[μ] β) : f.toGerm = (f : α → β)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[simp]
theorem integral_const (c : E) : ∫ _ in a..b, c = (b - a) • c
-- Mathlib/Data/Matrix/Basic.lean
theorem mulVec_smul_assoc [Fintype n] (A : Matrix m n α) (b : n → α) (a : α) :
    A *ᵥ (a • b) = a • A *ᵥ b
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhds_nhds_eq_uniformity_uniformity_prod {a b : α} :
    𝓝 a ×ˢ 𝓝 b = (𝓤 α).lift fun s : Set (α × α) =>
      (𝓤 α).lift' fun t => { y : α | (y, a) ∈ s } ×ˢ { y : α | (b, y) ∈ t }
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Working in continuous functions into a topological field,
a subalgebra of functions that separates points also separates points strongly.

By the hypothesis, we can find a function `f` so `f x ≠ f y`.
By an affine transformation in the field we can arrange so that `f x = a` and `f x = b`.
-/
theorem Subalgebra.SeparatesPoints.strongly {s : Subalgebra 𝕜 C(α, 𝕜)} (h : s.SeparatesPoints) :
    (s : Set C(α, 𝕜)).SeparatesPointsStrongly
-- Mathlib/Algebra/Lie/Submodule.lean
theorem idealRange_eq_map : f.idealRange = LieIdeal.map f ⊤
-- Mathlib/Order/Interval/Set/Basic.lean
theorem right_mem_Ioo : b ∈ Ioo a b ↔ False
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem getRight?_eq_none_iff {x : α ⊕ β} : x.getRight? = none ↔ x.isLeft
-- Mathlib/Algebra/MvPolynomial/Cardinal.lean
@[simp]
theorem cardinal_mk_eq_max_lift [Nonempty σ] [Nontrivial R] :
    #(MvPolynomial σ R) = max (max (Cardinal.lift.{u} #R) <| Cardinal.lift.{v} #σ) ℵ₀
-- Mathlib/Algebra/Module/Submodule/Basic.lean
protected theorem coe_sub (x y : p) : (↑(x - y) : M) = ↑x - ↑y
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem ofNat_add_aleph0 {n : ℕ} [Nat.AtLeastTwo n] : no_index (OfNat.ofNat n) + ℵ₀ = ℵ₀
-- Mathlib/Algebra/Module/GradedModule.lean
@[simp]
theorem smulAddMonoidHom_apply_of_of [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]
    {i j} (x : A i) (y : M j) :
    smulAddMonoidHom A M (DirectSum.of A i x) (of M j y) = of M (i +ᵥ j) (GSMul.smul x y)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_eq_add_tsum_ite {f : α → ℝ≥0} (hf : Summable f) (i : α) :
    ∑' x, f x = f i + ∑' x, ite (x = i) 0 (f x)
-- Mathlib/Order/Category/Preord.lean
/-- `OrderDual` as a functor. -/
@[simps]
def dual : Preord ⥤ Preord
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_subtypeₗᵢ : ⇑p.subtypeₗᵢ = p.subtype
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem prod_dvd_prod_of_dvd {S : Finset α} (g1 g2 : α → β) (h : ∀ a ∈ S, g1 a ∣ g2 a) :
    S.prod g1 ∣ S.prod g2
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem fmod_zero : ∀ a : Int, fmod a 0 = a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem pow_mul_meas_ge_le_norm (f : Lp E p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) (ε : ℝ≥0∞) :
    (ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal }) ^ (1 / p.toReal) ≤ ENNReal.ofReal ‖f‖
-- Mathlib/Topology/Covering.lean
theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTopology (F x)]
    (e : ∀ x, Trivialization (F x) f) (h : ∀ x, x ∈ (e x).baseSet) : IsCoveringMap f
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem cancel_left {g : sSupHom β γ} {f₁ f₂ : sSupHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem comap_apply (μ : Measure β) (s : Set α) : comap f μ s = μ (f '' s)
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem _root_.Set.exists_isOpen_le_add (A : Set α) (μ : Measure α) [OuterRegular μ] {ε : ℝ≥0∞}
    (hε : ε ≠ 0) : ∃ U, U ⊇ A ∧ IsOpen U ∧ μ U ≤ μ A + ε
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
/-- For `f : ℕ → G`, the product `∏' k, f (k + i)` tends to one. This does not require a
multipliability assumption on `f`, as otherwise all such products are one. -/
@[to_additive "For `f : ℕ → G`, the sum `∑' k, f (k + i)` tends to zero. This does not require a
summability assumption on `f`, as otherwise all such sums are zero."]
theorem tendsto_prod_nat_add [T2Space G] (f : ℕ → G) :
    Tendsto (fun i ↦ ∏' k, f (k + i)) atTop (𝓝 1)
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
theorem image.map_ι : image.map sq ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
theorem lowerCentralSeries_zero : lowerCentralSeries R L M 0 = ⊤
-- Mathlib/Data/Finite/Card.lean
theorem eq_of_subset_of_card_le (hsub : s ⊆ t) (hcard : Nat.card t ≤ Nat.card s) : s = t
-- Mathlib/Data/Seq/WSeq.lean
theorem destruct_terminates_of_get?_terminates {s : WSeq α} {n} (T : Terminates (get? s n)) :
    Terminates (destruct s)
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
lemma Integrable.piecewise [DecidablePred (· ∈ s)]
    (hs : MeasurableSet s) (hf : IntegrableOn f s μ) (hg : IntegrableOn g sᶜ μ) :
    Integrable (s.piecewise f g) μ
-- Mathlib/AlgebraicGeometry/Properties.lean
theorem affine_isReduced_iff (R : CommRingCat) :
    IsReduced (Spec R) ↔ _root_.IsReduced R
-- Mathlib/Data/Subtype.lean
theorem restrict_apply {α} {β : α → Type*} (f : ∀ x, β x) (p : α → Prop) (x : Subtype p) :
    restrict p f x = f x.1
-- Mathlib/Algebra/Lie/Submodule.lean
theorem inclusion_injective : Function.Injective (inclusion h)
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.hasFDerivAt_convolution_left [IsNegInvariant μ]
    (hcf : HasCompactSupport f) (hf : ContDiff 𝕜 1 f) (hg : LocallyIntegrable g μ) (x₀ : G) :
    HasFDerivAt (f ⋆[L, μ] g) ((fderiv 𝕜 f ⋆[L.precompL G, μ] g) x₀) x₀
-- Mathlib/Data/Finset/Card.lean
theorem subset_iff_eq_of_card_le (h : t.card ≤ s.card) : s ⊆ t ↔ s = t
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem refl_of [IsRefl α r] (a : α) : a ≺ a
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem edges_map : (p.map f).edges = p.edges.map (Sym2.map f)
-- Mathlib/Data/Finsupp/Basic.lean
/-- A version of `Finsupp.comapDomain_add` that's easier to use. -/
theorem comapDomain_add_of_injective (hf : Function.Injective f) (v₁ v₂ : β →₀ M) :
    comapDomain f (v₁ + v₂) hf.injOn =
      comapDomain f v₁ hf.injOn + comapDomain f v₂ hf.injOn
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
theorem algebraMap_image : algebraMap R S '' quasispectrum R a = quasispectrum S a
-- Mathlib/Order/Defs.lean
theorem le_of_not_gt {a b : α} : ¬a > b → a ≤ b
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem type_sum_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
    [IsWellOrder β s] : type (Sum.Lex r s) = type r + type s
-- Mathlib/Topology/UnitInterval.lean
theorem one_minus_nonneg (x : I) : 0 ≤ 1 - (x : ℝ)
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma disjointSigma_ground_eq {h} : (Matroid.disjointSigma M h).E = ⋃ i : ι, (M i).E
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
/-- Suppose `X Y : SheafedSpace C`, where `C` is a concrete category,
whose forgetful functor reflects isomorphisms, preserves limits and filtered colimits.
Then a morphism `X ⟶ Y` that is a topological open embedding
is an open immersion iff every stalk map is an iso.
-/
theorem of_stalk_iso {X Y : SheafedSpace C} (f : X ⟶ Y) (hf : OpenEmbedding f.base)
    [H : ∀ x : X.1, IsIso (f.stalkMap x)] : SheafedSpace.IsOpenImmersion f
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- Alternative version of `List.prod_set` when the list is over a group -/
@[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
theorem prod_set' (L : List G) (n : ℕ) (a : G) :
    (L.set n a).prod = L.prod * if hn : n < L.length then (L.get ⟨n, hn⟩)⁻¹ * a else 1
-- Mathlib/Data/ZMod/Basic.lean
/-- So-named because the coercion is `Nat.cast` into `ZMod`. For `Nat.cast` into an arbitrary ring,
see `ZMod.natCast_val`. -/
theorem natCast_zmod_val {n : ℕ} [NeZero n] (a : ZMod n) : (a.val : ZMod n) = a
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem range_orderEmbOfFin (s : Finset α) {k : ℕ} (h : s.card = k) :
    Set.range (s.orderEmbOfFin h) = s