ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean
@[simp]
theorem rTensorBot_symm_apply (a : A) : A.rTensorBot.symm a = a ⊗ₜ[R] 1
-- Mathlib/Algebra/Ring/Center.lean
@[simp]
theorem neg_mem_center [NonUnitalNonAssocRing M] {a : M} (ha : a ∈ Set.center M) :
    -a ∈ Set.center M
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem map_prod_of_subset_primeFactors [CommSemiring R] {f : ArithmeticFunction R}
    (h_mult : ArithmeticFunction.IsMultiplicative f) (l : ℕ)
    (t : Finset ℕ) (ht : t ⊆ l.primeFactors) :
    f (∏ a ∈ t, a) = ∏ a ∈ t, f a
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
/-- A function `f` continuous on a compact set `K` is integrable on this set with respect to any
locally finite measure. -/
theorem ContinuousOn.integrableOn_compact'
    (hK : IsCompact K) (h'K : MeasurableSet K) (hf : ContinuousOn f K) :
    IntegrableOn f K μ
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a negative constant, `fun x ↦ f x / r` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
lemma tendsto_div_const_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ Tendsto f l atTop
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Icc_union_Ico : Ico a c ⊆ Icc a b ∪ Ico b c
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
protected theorem IsVonNBounded.add (hs : IsVonNBounded 𝕜 s) (ht : IsVonNBounded 𝕜 t) :
    IsVonNBounded 𝕜 (s + t)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma measurable_compl : Measurable ((·ᶜ) : Set α → Set α)
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The definition of `cyclotomic n R` commutes with any ring homomorphism. -/
@[simp]
theorem map_cyclotomic (n : ℕ) {R S : Type*} [Ring R] [Ring S] (f : R →+* S) :
    map f (cyclotomic n R) = cyclotomic n S
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
@[simp]
theorem mem_unop {x : R} {S : Subring Rᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_congr (e : α ≃ β) : #α = #β
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp] lemma exp_one_pow (n : ℕ) : exp 1 ^ n = exp n
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_mulHom_mk (f : α → β) (h₁ h₂ h₃) :
    ((⟨⟨f, h₁⟩, h₂, h₃⟩ : α →ₙ+* β) : α →ₙ* β) = ⟨f, h₁⟩
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma D₂_totalShift₁XIso_hom (n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + x = n₀') (h₁ : n₁ + x = n₁') :
    ((shiftFunctor₁ C x).obj K).D₂ (up ℤ) n₀ n₁ ≫ (K.totalShift₁XIso x n₁ n₁' h₁).hom =
      x.negOnePow • ((K.totalShift₁XIso x n₀ n₀' h₀).hom ≫ K.D₂ (up ℤ) n₀' n₁')
-- Mathlib/FieldTheory/KrullTopology.lean
/-- The map `E ↦ Gal(L/E)` is inclusion-reversing -/
theorem IntermediateField.fixingSubgroup.antimono {K L : Type*} [Field K] [Field L] [Algebra K L]
    {E1 E2 : IntermediateField K L} (h12 : E1 ≤ E2) : E2.fixingSubgroup ≤ E1.fixingSubgroup
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioi_subset_Ici_self : Ioi a ⊆ Ici a
-- Mathlib/Order/Filter/Partial.lean
theorem tendsto_iff_rtendsto (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ RTendsto (Function.graph f) l₁ l₂
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousWithinAt_prod_of_discrete_right [DiscreteTopology β]
    {f : α × β → γ} {s : Set (α × β)} {x : α × β} :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt (f ⟨·, x.2⟩) {a | (a, x.2) ∈ s} x.1
-- Mathlib/RingTheory/Nullstellensatz.lean
@[simp (high)]
theorem IsPrime.vanishingIdeal_zeroLocus (P : Ideal (MvPolynomial σ k)) [h : P.IsPrime] :
    vanishingIdeal (zeroLocus P) = P
-- Mathlib/Algebra/AddTorsor.lean
@[simp]
theorem mk_vadd_mk (v : G) (v' : G') (p : P) (p' : P') : (v, v') +ᵥ (p, p') = (v +ᵥ p, v' +ᵥ p')
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem not_mem_iff {r : R} {a : A} : r ∉ σ a ↔ IsUnit (↑ₐ r - a)
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem Basis.restrictScalars_apply (i : ι) : (b.restrictScalars R i : M) = b i
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S) : M) = 1
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem smoothWithinAt_univ : SmoothWithinAt I I' f univ x ↔ SmoothAt I I' f x
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_comp_le_essSup_map_measure (hf : AEMeasurable f μ) :
    essSup (g ∘ f) μ ≤ essSup g (Measure.map f μ)
-- Mathlib/Probability/Martingale/Basic.lean
protected theorem adapted (hf : Martingale f ℱ μ) : Adapted ℱ f
-- Mathlib/Data/Finset/Fold.lean
theorem fold_op_rel_iff_and {r : β → β → Prop} (hr : ∀ {x y z}, r x (op y z) ↔ r x y ∧ r x z)
    {c : β} : r c (s.fold op b f) ↔ r c b ∧ ∀ x ∈ s, r c (f x)
-- Mathlib/Data/Fin/Basic.lean
/-- `Fin.castAdd` as an `Embedding`, `castAddEmb m i` embeds `i : Fin n` in `Fin (n+m)`.
See also `Fin.natAddEmb` and `Fin.addNatEmb`. -/
@[simps! apply]
def castAddEmb (m) : Fin n ↪ Fin (n + m)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[ext]
theorem ext {x y : Class.{u}} : (∀ z : ZFSet.{u}, x z ↔ y z) → x = y
-- Mathlib/Algebra/Homology/DerivedCategory/Basic.lean
lemma quotient_obj_mem_subcategoryAcyclic_iff_exactAt (K : CochainComplex C ℤ) :
    (subcategoryAcyclic C).P ((quotient _ _).obj K) ↔ ∀ (n : ℤ), K.ExactAt n
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem adj_of_mem_incidenceSet (h : a ≠ b) (ha : e ∈ G.incidenceSet a)
    (hb : e ∈ G.incidenceSet b) : G.Adj a b
-- Mathlib/CategoryTheory/Monoidal/Cartesian/Comon_.lean
@[simp] theorem comul_eq_diag (A : Comon_ C) : A.comul = diag A.X
-- Mathlib/Topology/StoneCech.lean
theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b
-- Mathlib/Topology/Connected/PathConnected.lean
@[continuity]
theorem trans_continuous_family {ι : Type*} [TopologicalSpace ι]
    {a b c : ι → X} (γ₁ : ∀ t : ι, Path (a t) (b t)) (h₁ : Continuous ↿γ₁)
    (γ₂ : ∀ t : ι, Path (b t) (c t)) (h₂ : Continuous ↿γ₂) :
    Continuous ↿fun t => (γ₁ t).trans (γ₂ t)
-- Mathlib/Algebra/Algebra/Basic.lean
theorem mul_sub_algebraMap_commutes [Ring A] [Algebra R A] (x : A) (r : R) :
    x * (x - algebraMap R A r) = (x - algebraMap R A r) * x
-- Mathlib/Data/Sym/Sym2.lean
theorem fromRel_irreflexive {sym : Symmetric r} :
    Irreflexive r ↔ ∀ {z}, z ∈ fromRel sym → ¬IsDiag z
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem replace_replicate_self [LawfulBEq α] {a : α} (h : 0 < n) :
    (replicate n a).replace a b = b :: replicate (n - 1) a
-- Mathlib/Data/Matrix/Basic.lean
theorem mulVec_vecMul [Fintype n] [Fintype o] (A : Matrix m n α) (B : Matrix o n α) (x : o → α) :
    A *ᵥ (x ᵥ* B) = (A * Bᵀ) *ᵥ x
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma map_equiv_traceDual [NoZeroSMulDivisors A B] (I : Submodule B (FractionRing B)) :
    (traceDual A (FractionRing A) I).map (FractionRing.algEquiv B L) =
      traceDual A K (I.map (FractionRing.algEquiv B L))
-- Mathlib/Data/Finsupp/Multiset.lean
@[simp] lemma coe_equivNatSum_apply_apply (s : Sym α n) (a : α) :
    (equivNatSum α n s : α →₀ ℕ) a = (s : Multiset α).count a
-- Mathlib/Data/Complex/Basic.lean
lemma div_ofReal (z : ℂ) (x : ℝ) : z / x = ⟨z.re / x, z.im / x⟩
-- Mathlib/GroupTheory/FreeGroup/IsFreeGroup.lean
/-- If a group satisfies the universal property of a free group with respect to a given type, then
it is free. Here, the universal property is expressed as in `IsFreeGroup.lift` and its
properties. -/
lemma ofLift {G : Type u} [Group G] (X : Type u) (of : X → G)
    (lift : ∀ {H : Type u} [Group H], (X → H) ≃ (G →* H))
    (lift_of : ∀ {H : Type u} [Group H], ∀ (f : X → H) (a), lift f (of a) = f a) :
    IsFreeGroup G
-- Mathlib/NumberTheory/LSeries/Convergence.lean
lemma LSeriesSummable.abscissaOfAbsConv_le {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    abscissaOfAbsConv f ≤ s.re
-- Mathlib/Topology/Order.lean
theorem nhds_nhdsAdjoint_same (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) a = pure a ⊔ f
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma toKaehler_surjective : Function.Surjective P.toKaehler
-- Mathlib/Data/Rel.lean
theorem core_inter (s t : Set β) : r.core (s ∩ t) = r.core s ∩ r.core t
-- Mathlib/Data/List/Basic.lean
theorem Sublist.antisymm (s₁ : l₁ <+ l₂) (s₂ : l₂ <+ l₁) : l₁ = l₂
-- Mathlib/Algebra/GroupWithZero/Hom.lean
@[ext] lemma ext ⦃f g : α →*₀ β⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem map_eq_zero_iff {x : M} : e x = 0 ↔ x = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma c_relation : 1728 * W.Δ = W.c₄ ^ 3 - W.c₆ ^ 2
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- The preimage of a set `s` under a linear equiv `f` has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. -/
@[simp]
theorem addHaar_preimage_linearEquiv (f : E ≃ₗ[ℝ] E) (s : Set E) :
    μ (f ⁻¹' s) = ENNReal.ofReal |LinearMap.det (f.symm : E →ₗ[ℝ] E)| * μ s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma CFC.eq_one_of_spectrum_subset_one (h_spec : spectrum R a ⊆ {1}) (ha : p a := by cfc_tac) :
    a = 1
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem AEEqFun.eLpNorm_compMeasurePreserving {ν : MeasureTheory.Measure β} (g : β →ₘ[ν] E)
    (hf : MeasurePreserving f μ ν) :
    eLpNorm (g.compMeasurePreserving f hf) p μ = eLpNorm g p ν
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedValue_sub_eq_sum [AddCommGroup β] (hle : τ ≤ π) :
    stoppedValue u π - stoppedValue u τ = fun ω =>
      (∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω
-- Mathlib/Probability/Independence/Kernel.lean
theorem iIndep.indep {m : ι → MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α}
    (h_indep : iIndep m κ μ) {i j : ι} (hij : i ≠ j) : Indep (m i) (m j) κ μ
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem comp_toLinearMap_symm_eq (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₃] M₃) :
    g.comp e₁₂.symm.toLinearMap = f ↔ g = f.comp e₁₂.toLinearMap
-- Mathlib/Data/List/Lex.lean
theorem head!_le_of_lt [Preorder α] [Inhabited α] (l l' : List α) (h : l' < l) (hl' : l' ≠ []) :
    l'.head! ≤ l.head!
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
@[simp]
theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅
-- Mathlib/Computability/TuringMachine.lean
theorem BlankExtends.above_of_le {Γ} [Inhabited Γ] {l l₁ l₂ : List Γ} :
    BlankExtends l₁ l → BlankExtends l₂ l → l₁.length ≤ l₂.length → BlankExtends l₁ l₂
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepFun.comp {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    {mγ : MeasurableSpace γ} {mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'}
    (hfg : IndepFun f g κ μ) (hφ : Measurable φ) (hψ : Measurable ψ) :
    IndepFun (φ ∘ f) (ψ ∘ g) κ μ
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
/-- `Nat.cast : ℕ → α` as an `OrderEmbedding` -/
@[simps! (config := .asFn)]
def castOrderEmbedding : ℕ ↪o α
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem dvd_count_pow [Nontrivial α] [DecidableEq (Associates α)] {a : Associates α} (ha : a ≠ 0)
    {p : Associates α} (hp : Irreducible p) (k : ℕ) : k ∣ count p (a ^ k).factors
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem comp_assoc (f : SupHom γ δ) (g : SupHom β γ) (h : SupHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
@[simp]
theorem _root_.CategoryTheory.zero_map [HasZeroObject D] [HasZeroMorphisms D] {X Y : C}
    (f : X ⟶ Y) : (0 : C ⥤ D).map f = 0
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma comap_id' (κ : Kernel α β) : comap κ (fun a ↦ a) measurable_id = κ
-- Mathlib/Init/Algebra/Classes.lean
theorem symm [IsSymm α r] {a b : α} : a ≺ b → b ≺ a
-- Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
theorem even.lift_ι (f : EvenHom Q A) (m₁ m₂ : M) :
    even.lift Q f ((even.ι Q).bilin m₁ m₂) = f.bilin m₁ m₂
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp] lemma op_inv_braiding (X Y : C) : (β_ X Y).inv.op = (β_ (op Y) (op X)).inv
-- Mathlib/Data/Finite/Defs.lean
theorem Finite.ofBijective [Finite α] {f : α → β} (h : Bijective f) : Finite β
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma closedEmbedding_starAlgHom {a : A} {φ : C(spectrum S a, S) →⋆ₐ[S] A}
    (hφ : ClosedEmbedding φ) {f : C(S, R)} (h : SpectrumRestricts a f)
    (halg : UniformEmbedding (algebraMap R S)) [CompactSpace (spectrum S a)] :
    ClosedEmbedding (h.starAlgHom φ)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem diam_range : Metric.diam (range f) = Metric.diam (univ : Set E)
-- Mathlib/Topology/Basic.lean
/-- If `f x ≤ g x` in a neighbourhood of `x`, then for `y` sufficiently close to `x` we have
`f x ≤ g x` in a neighbourhood of `y`. -/
theorem Filter.EventuallyLE.eventuallyLE_nhds [LE α] {f g : X → α} (h : f ≤ᶠ[𝓝 x] g) :
    ∀ᶠ y in 𝓝 x, f ≤ᶠ[𝓝 y] g
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem apply_order_ne_zero (hp : p ≠ 0) : p p.order ≠ 0
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem prod_const' (ι : Type u) (a : Cardinal.{u}) : (prod fun _ : ι => a) = a ^ #ι
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- A point in a metric space belongs to the (open) `δ`-thickening of a subset `E` if and only if
it is at distance less than `δ` from some point of `E`. -/
theorem mem_thickening_iff {E : Set X} {x : X} : x ∈ thickening δ E ↔ ∃ z ∈ E, dist x z < δ
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem get_mk_zero : ∀ {l : List α} (h : 0 < l.length), l.get ⟨0, h⟩ = l.head (length_pos.mp h)
-- Mathlib/Data/Set/Card.lean
theorem Finite.encard_lt_encard (ht : t.Finite) (h : s ⊂ t) : s.encard < t.encard
-- Mathlib/Probability/Process/PartitionFiltration.lean
lemma measurableSet_partitionFiltration_of_mem (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) {s : Set α}
    (hs : s ∈ memPartition t n) :
    MeasurableSet[partitionFiltration ht n] s
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n
-- Mathlib/Data/Analysis/Filter.lean
theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem eq_symm_apply {x y} : y = e.symm x ↔ e y = x
-- Mathlib/Analysis/NormedSpace/QuaternionExponential.lean
theorem normSq_exp (q : ℍ[ℝ]) : normSq (exp ℝ q) = exp ℝ q.re ^ 2
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- The image of `R` in `S` is linearly disjoint with any other submodules. -/
theorem one_right : M.LinearDisjoint (1 : Submodule R S)
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
/-- When `E` is a topological module over a topological ring `R`, the class `SeparatingDual R E`
registers that continuous linear forms on `E` separate points of `E`. -/
@[mk_iff separatingDual_def]
class SeparatingDual (R V : Type*) [Ring R] [AddCommGroup V] [TopologicalSpace V]
    [TopologicalSpace R] [Module R V] : Prop :=
  /-- Any nonzero vector can be mapped by a continuous linear map to a nonzero scalar. -/
  exists_ne_zero' : ∀ (x : V), x ≠ 0 → ∃ f : V →L[R] R, f x ≠ 0
-- Mathlib/Topology/Order.lean
theorem induced_id [t : TopologicalSpace α] : t.induced id = t
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem div_eq_of_eq_mul' {a b c : G} (h : a = b * c) : a / b = c
-- Mathlib/Data/Set/Basic.lean
theorem eq_of_not_mem_of_mem_insert : b ∈ insert a s → b ∉ s → b = a
-- Mathlib/Data/DFinsupp/NeLocus.lean
theorem not_mem_neLocus {f g : Π₀ a, N a} {a : α} : a ∉ f.neLocus g ↔ f a = g a
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_sup [IsTrans α r] [IsDirected α r] :
    IsBounded r f → IsBounded r g → IsBounded r (f ⊔ g)
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map.isMaximal (hf : Function.Bijective f) {I : Ideal R} (H : IsMaximal I) :
    IsMaximal (map f I)
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
@[simp]
theorem compression_self (u : α) (s : Finset α) : 𝓒 u u s = s
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem inclusion_injective {S T : Subalgebra R A} (h : S ≤ T) : Function.Injective (inclusion h)
-- Mathlib/Data/Option/Basic.lean
theorem elim_apply {f : γ → α → β} {x : α → β} {i : Option γ} {y : α} :
    i.elim x f y = i.elim (x y) fun j => f j y
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem smul_univ₀ {s : Set α} (hs : ¬s ⊆ 0) : s • (univ : Set β) = univ
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_le_iff : sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and itself are linearly disjoint, if `M` is flat,
if any two elements of `M` are commutative, then the rank of `M` is at most one. -/
theorem rank_le_one_of_commute_of_flat_of_self (H : M.LinearDisjoint M) [Module.Flat R M]
    (hc : ∀ (m n : M), Commute m.1 n.1) : Module.rank R M ≤ 1
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSpace_le {ι} [SemilatticeSup ι] {f : Filtration ι m} {τ : Ω → ι}
    [IsCountablyGenerated (atTop : Filter ι)] (hτ : IsStoppingTime f τ) :
    hτ.measurableSpace ≤ m
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem opow_principal_add_of_principal_add {a} (ha : Principal (· + ·) a) (b : Ordinal) :
    Principal (· + ·) (a^b)
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
theorem totalDegree_sub (a b : MvPolynomial σ R) :
    (a - b).totalDegree ≤ max a.totalDegree b.totalDegree
-- Mathlib/Order/Disjoint.lean
lemma Codisjoint.ne_bot_of_ne_top (h : Codisjoint a b) (ha : a ≠ ⊤) : b ≠ ⊥
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toFinsupp_union (s t : Multiset α) : toFinsupp (s ∪ t) = toFinsupp s ⊔ toFinsupp t
-- Mathlib/Analysis/Convex/Uniform.lean
theorem exists_forall_closed_ball_dist_add_le_two_mul_sub (hε : 0 < ε) (r : ℝ) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ r → ∀ ⦃y⦄, ‖y‖ ≤ r → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 * r - δ
-- Mathlib/LinearAlgebra/StdBasis.lean
theorem disjoint_stdBasis_stdBasis (I J : Set ι) (h : Disjoint I J) :
    Disjoint (⨆ i ∈ I, range (stdBasis R φ i)) (⨆ i ∈ J, range (stdBasis R φ i))
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
private theorem eps_pos {ε : ℝ} {n : ℕ} (h : 100 ≤ (4 : ℝ) ^ n * ε ^ 5) : 0 < ε
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : s) : R) = 0
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma binaryProductTriangle_distinguished (X₁ X₂ : C) :
    binaryProductTriangle X₁ X₂ ∈ distTriang C
-- Mathlib/Order/GameAdd.lean
theorem GameAdd.fst {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(a₁, b) s(a₂, b)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The Dirichlet character mod `0` corresponds to `δ`. -/
lemma modZero_eq_delta {χ : DirichletCharacter ℂ 0} : ↗χ = δ
-- Mathlib/Data/Finset/Basic.lean
theorem mem_of_mem_filter {s : Finset α} (x : α) (h : x ∈ s.filter p) : x ∈ s
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp]
theorem coe_sub : ⇑(X - Y) = X - Y
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get?_set (a : Array α) (i : Fin a.size) (j : Nat) (v : α) :
    (a.set i v)[j]? = if i.1 = j then some v else a[j]?
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive]
theorem unop_inf (S₁ S₂ : Subgroup Gᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop
-- Mathlib/Topology/Support.lean
theorem tsupport_mul_subset_right {α : Type*} [MulZeroClass α] {f g : X → α} :
    (tsupport fun x => f x * g x) ⊆ tsupport g
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extend_nhds_of_boundaryless [I.Boundaryless] {x : M} (hx : x ∈ f.source) :
    map (f.extend I) (𝓝 x) = 𝓝 (f.extend I x)
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma llr_smul_left [IsFiniteMeasure μ] [Measure.HaveLebesgueDecomposition μ ν]
    (hμν : μ ≪ ν) (c : ℝ≥0∞) (hc : c ≠ 0) (hc_ne_top : c ≠ ∞) :
    llr (c • μ) ν =ᵐ[μ] fun x ↦ llr μ ν x + log c.toReal
-- Mathlib/Order/WithBot.lean
@[simp]
theorem toDual_apply_top : WithTop.toDual (⊤ : WithTop α) = ⊥
-- Mathlib/Computability/Primrec.lean
theorem list_join : Primrec (@List.join α)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffWithinAt.snd {f : N → M × M'} {s : Set N} {x : N}
    (hf : ContMDiffWithinAt J (I.prod I') n f s x) :
    ContMDiffWithinAt J I' n (fun x => (f x).2) s x
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_bot : restrictScalars S (⊥ : Submodule R M) = ⊥
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
lemma disjoint_sdiff_neighborFinset_image :
    Disjoint (G.edgeFinset \ G.incidenceFinset t) ((G.neighborFinset s).image (s(·, t)))
-- Mathlib/Algebra/Algebra/Subalgebra/Operations.lean
theorem mem_of_span_eq_top_of_smul_pow_mem
    (s : Set S) (l : s →₀ S) (hs : Finsupp.total s S S (↑) l = 1)
    (hs' : s ⊆ S') (hl : ∀ i, l i ∈ S') (x : S) (H : ∀ r : s, ∃ n : ℕ, (r : S) ^ n • x ∈ S') :
    x ∈ S'
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_mul_of_not_infinitesimal_neg_infinitePos {x y : ℝ*} :
    ¬Infinitesimal x → x < 0 → InfinitePos y → InfiniteNeg (x * y)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp] lemma coe_toHom (f : G ↪g H) : ⇑f.toHom = f
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem fix_eval (f) : (fix f).eval =
    PFun.fix fun v => (f.eval v).map fun v =>
      if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail
-- Mathlib/Algebra/CharP/Defs.lean
lemma natCast_eq_natCast : (a : R) = b ↔ a ≡ b [MOD p]
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
/-- Corollary of Chinese Remainder Theorem: if `Iᵢ` are pairwise coprime ideals in a
commutative ring then given elements `xᵢ` you can find `r` with `r - xᵢ ∈ Iᵢ` for all `i`. -/
lemma exists_forall_sub_mem_ideal {R : Type*} [CommRing R] {ι : Type*} [Finite ι]
    {I : ι → Ideal R} (hI : Pairwise fun i j ↦ IsCoprime (I i) (I j)) (x : ι → R) :
    ∃ r : R, ∀ i, r - x i ∈ I i
-- Mathlib/Algebra/Category/ModuleCat/Free.lean
/-- In the commutative diagram
```
    f     g
 X₁ --→ X₂ --→ X₃
 ↑      ↑      ↑
v|     u|     w|
 ι  → ι ⊕ ι' ← ι'
```
where the top row is an exact sequence of modules and the maps on the bottom are `Sum.inl` and
`Sum.inr`. If `v` spans `X₁` and `w` spans `X₃`, then `u` spans `X₂`. -/
theorem span_exact {β : Type*} {u : ι ⊕ β → S.X₂} (huv : u ∘ Sum.inl = S.f ∘ v)
    (hv : ⊤ ≤ span R (range v))
    (hw : ⊤ ≤ span R (range (S.g ∘ u ∘ Sum.inr))) :
    ⊤ ≤ span R (range u)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem eq_mul_of_mul_inv_eq (h : a * c⁻¹ = b) : a = b * c
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
@[simp]
lemma self_iff (μ : Measure α) : μ ⟂ₘ μ ↔ μ = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem multispan_map_snd (a) : I.multispan.map (WalkingMultispan.Hom.snd a) = I.snd a
-- Mathlib/Analysis/Analytic/Meromorphic.lean
@[simp]
lemma inv_iff {f : 𝕜 → 𝕜} {x : 𝕜} :
    MeromorphicAt f⁻¹ x ↔ MeromorphicAt f x
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem inl_one [One R] [Zero A] : (inl 1 : Unitization R A) = 1
-- Mathlib/Data/Set/Lattice.lean
@[gcongr]
theorem sInter_subset_sInter {S T : Set (Set α)} (h : S ⊆ T) : ⋂₀ T ⊆ ⋂₀ S
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- The image of a Haar measure under a continuous surjective proper group homomorphism is again
a Haar measure. See also `MulEquiv.isHaarMeasure_map`. -/
@[to_additive
"The image of an additive Haar measure under a continuous surjective proper additive group
homomorphism is again an additive Haar measure. See also `AddEquiv.isAddHaarMeasure_map`."]
theorem isHaarMeasure_map [BorelSpace G] [TopologicalGroup G] {H : Type*} [Group H]
    [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H] [T2Space H] [TopologicalGroup H]
    (f : G →* H) (hf : Continuous f) (h_surj : Surjective f)
    (h_prop : Tendsto f (cocompact G) (cocompact H)) : IsHaarMeasure (Measure.map f μ)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma epi_τ₂_of_exact_of_epi {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₂ : S₂.Exact) [Epi S₁.g] [Epi S₂.g] [Epi φ.τ₁] [Epi φ.τ₃] : Epi φ.τ₂
-- Mathlib/Probability/Kernel/WithDensity.lean
theorem withDensity_kernel_sum [Countable ι] (κ : ι → Kernel α β) (hκ : ∀ i, IsSFiniteKernel (κ i))
    (f : α → β → ℝ≥0∞) :
    @withDensity _ _ _ _ (Kernel.sum κ) (isSFiniteKernel_sum hκ) f =
      Kernel.sum fun i => withDensity (κ i) f