ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma smul_fin3 (P : Fin 3 → R) (u : R) : u • P = ![u ^ 2 * P x, u ^ 3 * P y, u * P z]
-- Mathlib/Data/Matroid/Restrict.lean
@[simp] theorem base_restrict_iff (hX : X ⊆ M.E := by aesop_mat) :
    (M ↾ X).Base I ↔ M.Basis I X
-- Mathlib/Order/Filter/Extr.lean
theorem IsMinOn.add (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x + g x) s a
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem coeff_mk (x : ℕ → R) : (mk p x).coeff = x
-- Mathlib/GroupTheory/PGroup.lean
@[simp]
theorem powEquiv_symm_apply {n : ℕ} (hn : p.Coprime n) (g : G) :
    (hG.powEquiv hn).symm g = g ^ (orderOf g).gcdB n
-- Mathlib/Order/ConditionallyCompleteLattice/Group.lean
@[to_additive]
theorem ciSup_mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, g i * h j ≤ a) : iSup g * iSup h ≤ a
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem interedges_biUnion (s : Finset ι) (t : Finset κ) (f : ι → Finset α) (g : κ → Finset α) :
    G.interedges (s.biUnion f) (t.biUnion g) =
      (s ×ˢ t).biUnion fun ab ↦ G.interedges (f ab.1) (g ab.2)
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem IsOpen.uniqueMDiffWithinAt (hs : IsOpen s) (xs : x ∈ s) : UniqueMDiffWithinAt I s x
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
/-- The `1`-cocycle given by the differential on a cochain complex. -/
@[simps!]
def diff : Cocycle K K 1
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
/-- If `IsCyclotomicExtension {1} A B`, then the image of `A` in `B` equals `B`. -/
theorem singleton_one [h : IsCyclotomicExtension {1} A B] : (⊥ : Subalgebra A B) = ⊤
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem not_succ_isLimit (o) : ¬IsLimit (succ o)
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
/-- A total complex shape symmetry contains the data and properties which allow the
identification of the two total complex functors
`HomologicalComplex₂ C c₁ c₂ ⥤ HomologicalComplex C c₁₂`
and `HomologicalComplex₂ C c₂ c₁ ⥤ HomologicalComplex C c₁₂` via the flip. -/
class TotalComplexShapeSymmetry [TotalComplexShape c₁ c₂ c₁₂] [TotalComplexShape c₂ c₁ c₁₂] where
  symm (i₁ : I₁) (i₂ : I₂) : ComplexShape.π c₂ c₁ c₁₂ ⟨i₂, i₁⟩ = ComplexShape.π c₁ c₂ c₁₂ ⟨i₁, i₂⟩
  /-- the signs involved in the symmetry isomorphism of the total complex -/
  σ (i₁ : I₁) (i₂ : I₂) : ℤˣ
  σ_ε₁ {i₁ i₁' : I₁} (h₁ : c₁.Rel i₁ i₁') (i₂ : I₂) :
    σ i₁ i₂ * ComplexShape.ε₁ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ = ComplexShape.ε₂ c₂ c₁ c₁₂ ⟨i₂, i₁⟩ * σ i₁' i₂
  σ_ε₂ (i₁ : I₁) {i₂ i₂' : I₂} (h₂ : c₂.Rel i₂ i₂') :
    σ i₁ i₂ * ComplexShape.ε₂ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ = ComplexShape.ε₁ c₂ c₁ c₁₂ ⟨i₂, i₁⟩ * σ i₁ i₂'
-- Mathlib/Data/Finset/Basic.lean
theorem filter_union (s₁ s₂ : Finset α) : (s₁ ∪ s₂).filter p = s₁.filter p ∪ s₂.filter p
-- Mathlib/CategoryTheory/Localization/Predicate.lean
lemma Construction.wIso_eq_isoOfHom {X Y : C} (f : X ⟶ Y) (hf : W f) :
    Construction.wIso f hf = isoOfHom W.Q W f hf
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.prod_left_iff : IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x
-- Mathlib/Algebra/Ring/Commute.lean
lemma neg_pow (a : R) (n : ℕ) : (-a) ^ n = (-1) ^ n * a ^ n
-- Mathlib/GroupTheory/GroupAction/Hom.lean
theorem one_apply (a : A) : (1 : A →+[M] A) a = a
-- Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean
/-- If there exists a morphism `a → b` in a free groupoid, then there also exists a zigzag
from `a` to `b` in the generating quiver. -/
theorem path_nonempty_of_hom {G} [Groupoid.{u, u} G] [IsFreeGroupoid G] {a b : G} :
    Nonempty (a ⟶ b) → Nonempty (Path (symgen a) (symgen b))
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem ofNat_zero_le (n : Nat) : 0 ≤ (↑n : Int)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem inter_eq_of_inter_eq_of_eqOn {e' : PartialEquiv α β} (h : e.IsImage s t)
    (h' : e'.IsImage s t) (hs : e.source ∩ s = e'.source ∩ s) (heq : EqOn e e' (e.source ∩ s)) :
    e.target ∩ t = e'.target ∩ t
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
@[simp, nolint simpNF]
theorem leftDual_ρ [LeftRigidCategory V] (h : H) : (ᘁX).ρ h = ᘁX.ρ (h⁻¹ : H)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
protected theorem mul {β} [MonoidWithZero β] {f g : α →ₛ β} (hf : f.FinMeasSupp μ)
    (hg : g.FinMeasSupp μ) : (f * g).FinMeasSupp μ
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
theorem NormedAddGroupHom.ker_completion {f : NormedAddGroupHom G H} {C : ℝ}
    (h : f.SurjectiveOnWith f.range C) :
    (f.completion.ker : Set <| Completion G) = closure (toCompl.comp <| incl f.ker).range
-- Mathlib/Algebra/Category/ModuleCat/EpiMono.lean
theorem range_eq_top_of_epi [Epi f] : LinearMap.range f = ⊤
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem prod_inf_prod {S T : NonUnitalStarSubalgebra R A} {S₁ T₁ : NonUnitalStarSubalgebra R B} :
    S.prod S₁ ⊓ T.prod T₁ = (S ⊓ T).prod (S₁ ⊓ T₁)
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem coe_one : ((1 : (𝓞 K)ˣ) : K) = (1 : K)
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
protected theorem contMDiff (h : M ≃ₘ^n⟮I, I'⟯ M') : ContMDiff I I' n h
-- Mathlib/Data/PFunctor/Multivariate/M.lean
theorem M.dest'_eq_dest' {α : TypeVec n} {x : P.last.M} {a₁ : P.A}
    {f₁ : P.last.B a₁ → P.last.M} (h₁ : PFunctor.M.dest x = ⟨a₁, f₁⟩) {a₂ : P.A}
    {f₂ : P.last.B a₂ → P.last.M} (h₂ : PFunctor.M.dest x = ⟨a₂, f₂⟩) (f' : M.Path P x ⟹ α) :
    M.dest' P h₁ f' = M.dest' P h₂ f'
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
/-- A block matrix `A.fromBlocks B C D` is symmetric,
    if `A` and `D` are symmetric and `Bᵀ = C`. -/
theorem IsSymm.fromBlocks {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
    {D : Matrix n n α} (hA : A.IsSymm) (hBC : Bᵀ = C) (hD : D.IsSymm) :
    (A.fromBlocks B C D).IsSymm
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
/-- An s-finite measure `μ` is sigma-finite iff `μ μ.sigmaFiniteSetᶜ = 0`. -/
lemma measure_compl_sigmaFiniteSet_eq_zero_iff_sigmaFinite (μ : Measure α) [SFinite μ] :
    μ μ.sigmaFiniteSetᶜ = 0 ↔ SigmaFinite μ
-- Mathlib/Algebra/MvPolynomial/Expand.lean
@[simp]
theorem expand_monomial (p : ℕ) (d : σ →₀ ℕ) (r : R) :
    expand p (monomial d r) = C r * ∏ i ∈ d.support, (X i ^ p) ^ d i
-- Mathlib/Data/Rat/Cast/Defs.lean
@[norm_cast]
lemma cast_add_of_ne_zero (hq : (q.den : α) ≠ 0) (hr : (r.den : α) ≠ 0) :
    ↑(q + r) = (q + r : α)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b
-- Mathlib/Topology/Constructions.lean
@[continuity, fun_prop]
theorem continuous_subtype_val : Continuous (@Subtype.val X p)
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Card.lean
/-- The cardinal of the set of linearly independent vectors over a finite dimensional vector space
over a finite field. -/
theorem card_linearIndependent {k : ℕ} (hk : k ≤ n) :
    Nat.card { s : Fin k → V // LinearIndependent K s } =
      ∏ i : Fin k, (q ^ n - q ^ i.val)
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.eq_one_of_isUnit (hm : Monic p) (hpu : IsUnit p) : p = 1
-- Mathlib/Data/Set/Finite.lean
theorem finite_lt_nat (n : ℕ) : Set.Finite { i | i < n }
-- Mathlib/Order/Filter/Bases.lean
/-- If `s : ι → Set α` is an indexed family of sets, then finite intersections of `s i` form a basis
of `⨅ i, 𝓟 (s i)`.  -/
theorem hasBasis_iInf_principal_finite {ι : Type*} (s : ι → Set α) :
    (⨅ i, 𝓟 (s i)).HasBasis (fun t : Set ι => t.Finite) fun t => ⋂ i ∈ t, s i
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem left_inv (x : A ⊗ R[X]) : invFun R A ((toFunAlgHom R A) x) = x
-- Mathlib/NumberTheory/Bernoulli.lean
theorem bernoulli'_spec (n : ℕ) :
    (∑ k ∈ range n.succ, (n.choose (n - k) : ℚ) / (n - k + 1) * bernoulli' k) = 1
-- Mathlib/CategoryTheory/Localization/Resolution.lean
/-- The composition of morphisms in `Φ.LeftResolution X₂`. -/
@[simps]
def Hom.comp {L L' L'' : Φ.LeftResolution X₂}
    (φ : Hom L L') (ψ : Hom L' L'') :
    Hom L L''
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Sublist.filter (p : α → Bool) {l₁ l₂} (s : l₁ <+ l₂) : filter p l₁ <+ filter p l₂
-- Mathlib/Algebra/LinearRecurrence.lean
/-- If `u` is a solution to `E` and `init` designates its first `E.order` values,
  then `∀ n, u n = E.mkSol init n`. -/
theorem eq_mk_of_is_sol_of_eq_init {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u)
    (heq : ∀ n : Fin E.order, u n = init n) : ∀ n, u n = E.mkSol init n
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_set_coe_eq_finprod_mem (s : Set α) : ∏ᶠ j : s, f j = ∏ᶠ i ∈ s, f i
-- Mathlib/RingTheory/Valuation/Basic.lean
/-- If `v` is an additive valuation on a division ring then `v(x) = ⊤` iff `x = 0`. -/
@[simp]
theorem top_iff [Nontrivial Γ₀] (v : AddValuation K Γ₀) {x : K} : v x = (⊤ : Γ₀) ↔ x = 0
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem mapRange.addEquiv_toAddMonoidHom (f : M ≃+ N) :
    ((mapRange.addEquiv f : (α →₀ _) ≃+ _) : _ →+ _) =
      (mapRange.addMonoidHom f.toAddMonoidHom : (α →₀ _) →+ _)
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive (attr := continuity, fun_prop)]
theorem Continuous.const_smul (hg : Continuous g) (c : M) : Continuous fun x => c • g x
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem Iic_inf [SemilatticeInf α] (a b : α) : Iic (a ⊓ b) = Iic a ⊓ Iic b
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma bot_ne_ofNat (n : ℕ) [n.AtLeastTwo] : (⊥ : WithBot α) ≠ no_index (OfNat.ofNat n)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem isFiniteMeasure_withDensity_ofReal {f : α → ℝ} (hfi : HasFiniteIntegral f μ) :
    IsFiniteMeasure (μ.withDensity fun x => ENNReal.ofReal <| f x)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
/-- The "clifford conjugate" maps to the quaternion conjugate. -/
theorem toQuaternion_star (c : CliffordAlgebra (Q c₁ c₂)) :
    toQuaternion (star c) = star (toQuaternion c)
-- Mathlib/CategoryTheory/Pi/Basic.lean
@[simp]
theorem id_apply (X : ∀ i, C i) (i) : (𝟙 X : ∀ i, X i ⟶ X i) i = 𝟙 (X i)
-- Mathlib/MeasureTheory/Function/L1Space.lean
@[simp]
theorem integrable_const [IsFiniteMeasure μ] (c : β) : Integrable (fun _ : α => c) μ
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
Noetherian. -/
theorem IsIntegralClosure.isNoetherianRing [IsIntegrallyClosed A] [IsNoetherianRing A] :
    IsNoetherianRing C
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean
@[simp]
theorem differentiableAt_tan {x : ℂ} : DifferentiableAt ℂ tan x ↔ cos x ≠ 0
-- Mathlib/Data/DFinsupp/Basic.lean
theorem finite_support (f : Π₀ i, β i) : Set.Finite { i | f i ≠ 0 }
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem set_eq_modifyNth (a : α) : ∀ n (l : List α), set l n a = modifyNth (fun _ => a) n l
-- Mathlib/Logic/Equiv/Fintype.lean
theorem extendSubtype_apply_of_mem (e : { x // p x } ≃ { x // q x }) (x) (hx : p x) :
    e.extendSubtype x = e ⟨x, hx⟩
-- Mathlib/CategoryTheory/Dialectica/Basic.lean
@[ext] theorem hom_ext {X Y : Dial C} {x y : X ⟶ Y} (hf : x.f = y.f) (hF : x.F = y.F) : x = y
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc (attr := simp)]
theorem pentagon_inv (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (i : d ⟶ e) :
    f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i =
      (α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
/-- Auxiliary lemma for `rnDeriv_withDensity_right`. -/
lemma rnDeriv_withDensity_withDensity_rnDeriv_right (μ ν : Measure α) [SigmaFinite μ]
    [SigmaFinite ν] (hf : AEMeasurable f ν) (hf_ne_zero : ∀ᵐ x ∂ν, f x ≠ 0)
    (hf_ne_top : ∀ᵐ x ∂ν, f x ≠ ∞) :
    (ν.withDensity (μ.rnDeriv ν)).rnDeriv (ν.withDensity f) =ᵐ[ν] μ.rnDeriv (ν.withDensity f)
-- Mathlib/LinearAlgebra/Dual.lean
theorem dual_rank_eq [Module.Finite K V] :
    Cardinal.lift.{uK,uV} (Module.rank K V) = Module.rank K (Dual K V)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem truncate_cast {h : w = v} : (cast h x).truncate k = x.truncate k
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_map_measure (hg : AEStronglyMeasurable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : eLpNormEssSup g (Measure.map f μ) = eLpNormEssSup (g ∘ f) μ
-- Mathlib/GroupTheory/Finiteness.lean
@[to_additive]
theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem zero_le_toSignedMeasure : 0 ≤ μ.toSignedMeasure
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive zero_lt_one_add_norm_sq]
theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem deriv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
    deriv (fun y => (c y) (u y)) x = deriv c x (u x) + c x (deriv u x)
-- Mathlib/Topology/Connected/LocallyConnected.lean
theorem locallyConnectedSpace_of_connected_bases {ι : Type*} (b : α → ι → Set α) (p : α → ι → Prop)
    (hbasis : ∀ x, (𝓝 x).HasBasis (p x) (b x))
    (hconnected : ∀ x i, p x i → IsPreconnected (b x i)) : LocallyConnectedSpace α
-- Mathlib/Algebra/AlgebraicCard.lean
theorem cardinal_mk_le_max : #{ x : A // IsAlgebraic R x } ≤ max #R ℵ₀
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem find_eq_some_iff {p : Fin n → Prop} [DecidablePred p] {i : Fin n} :
    Fin.find p = some i ↔ p i ∧ ∀ j, p j → i ≤ j
-- Mathlib/Algebra/Ring/Commute.lean
lemma neg_pow' (a : R) (n : ℕ) : (-a) ^ n = a ^ n * (-1) ^ n
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
/-- One can bound `‖w‖^n * ‖D^k (𝓕 f) w‖` in terms of integrals of the derivatives of `f` (or order
at most `n`) multiplied by powers of `v` (of order at most `k`). -/
lemma pow_mul_norm_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖))
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) (w : V) :
    ‖w‖ ^ n * ‖iteratedFDeriv ℝ k (𝓕 f) w‖ ≤ (2 * π) ^ k * (2 * k + 2) ^ n *
      ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
        ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖
-- Mathlib/Algebra/CharP/Algebra.lean
/-- If `R →+* A` is injective, and `A` is of characteristic `p`, then `R` is also of
characteristic `p`. Similar to `RingHom.charZero`. -/
theorem RingHom.charP {R A : Type*} [NonAssocSemiring R] [NonAssocSemiring A] (f : R →+* A)
    (H : Function.Injective f) (p : ℕ) [CharP A p] : CharP R p
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_card (l : List α) : card (l : Multiset α) = length l
-- Mathlib/SetTheory/Game/PGame.lean
/-- `x + 0` is equivalent to `x`. -/
theorem add_zero_equiv (x : PGame.{u}) : x + 0 ≈ x
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_eq_nhdsWithin' {a : α} {s t u : Set α} (hs : s ∈ 𝓝 a) (h₂ : t ∩ s = u ∩ s) :
    𝓝[t] a = 𝓝[u] a
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem eq_true_of_true_le : ∀ {x : Bool}, true ≤ x → x = true
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[to_additive (attr := simp)]
theorem one_compContinuous [TopologicalSpace γ] (f : C(γ, α)) : (1 : α →ᵇ β).compContinuous f = 1
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem one_den : (1 : Rat).den = 1
-- Mathlib/Topology/Metrizable/Basic.lean
/-- Given an inducing map of a topological space into a pseudo metrizable space, the source space
is also pseudo metrizable. -/
theorem _root_.Inducing.pseudoMetrizableSpace [PseudoMetrizableSpace Y] {f : X → Y}
    (hf : Inducing f) : PseudoMetrizableSpace X
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_Ici_iff : b ∈ Ici a ↔ a ≤ b
-- Mathlib/Order/ULift.lean
@[simp] theorem down_sdiff [SDiff α] (a b : ULift α) : down (a \ b) = down a \ down b
-- Mathlib/Topology/ContinuousFunction/Basic.lean
theorem liftCover_restrict {i : ι} : (liftCover S φ hφ hS).restrict (S i) = φ i
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
theorem wronskian_self_eq_zero (a : R[X]) : wronskian a a = 0
-- Mathlib/Order/Filter/EventuallyConst.lean
lemma eventuallyConst_atTop [SemilatticeSup α] [Nonempty α] :
    EventuallyConst f atTop ↔ (∃ i, ∀ j, i ≤ j → f j = f i)
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
/-- Unlike `support_congr`, which assumes that `∀ (x ∈ g.support), f x = g x)`, here
we have the weaker assumption that `∀ (x ∈ f.support), f x = g x`. -/
theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.support ⊆ g.support)
    (h' : ∀ x ∈ f.support, f x = g x) : f = g
-- Mathlib/RingTheory/PowerSeries/Basic.lean
protected theorem subsingleton_iff : Subsingleton R⟦X⟧ ↔ Subsingleton R
-- Mathlib/NumberTheory/VonMangoldt.lean
theorem vonMangoldt_apply_pow {n k : ℕ} (hk : k ≠ 0) : Λ (n ^ k) = Λ n
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem withTop_comp (f : InfHom β γ) (g : InfHom α β) :
    (f.comp g).withTop = f.withTop.comp g.withTop
-- Mathlib/Order/Filter/Prod.lean
theorem tendsto_diag : Tendsto (fun i => (i, i)) f (f ×ˢ f)
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
/-- The `changeLevel` map is injective (except in the degenerate case `m = 0`). -/
lemma changeLevel_injective {m : ℕ} [NeZero m] (hm : n ∣ m) :
    Function.Injective (changeLevel (R := R) hm)
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem mul_rpow_of_ne_top {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) (z : ℝ) :
    (x * y) ^ z = x ^ z * y ^ z
-- Mathlib/Topology/MetricSpace/Algebra.lean
@[to_additive]
theorem lipschitz_with_lipschitz_const_mul :
    ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_sub_mul_pow (a : Nat) {m n : Nat} (h : m ≤ n) :
    a ^ (n - m) * a ^ m = a ^ n
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem ContMDiff.div_const (hf : ContMDiff I' I n f) :
    ContMDiff I' I n (fun x ↦ f x / c)
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
theorem eq_neg_one_iff' {a : ℕ} : legendreSym p a = -1 ↔ ¬IsSquare (a : ZMod p)
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualLift_injective : Function.Injective W.dualLift
-- Mathlib/Topology/ContinuousOn.lean
theorem Continuous.comp_continuousOn {g : β → γ} {f : α → β} {s : Set α} (hg : Continuous g)
    (hf : ContinuousOn f s) : ContinuousOn (g ∘ f) s
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_of_mem_groupoid (hG : G.LocalInvariantProp G Q) (hQ : ∀ y, Q id univ y)
    {f : PartialHomeomorph H H} (hf : f ∈ G) : LiftPropOn Q f f.source
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma intCast_left : Commute (n : α) a
-- Mathlib/Data/List/GetD.lean
theorem getI_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getI n = default
-- Mathlib/Data/Semiquot.lean
theorem eq_mk_of_mem {q : Semiquot α} {a : α} (h : a ∈ q) : q = @mk _ a q.1 h
-- Mathlib/Data/ZMod/Basic.lean
lemma eq_one_of_isUnit_natCast {n : ℕ} (h : IsUnit (n : ZMod 0)) : n = 1
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem natDegree_le_of_dvd {p q : R[X]} (h1 : p ∣ q) (h2 : q ≠ 0) : p.natDegree ≤ q.natDegree
-- Mathlib/Algebra/RingQuot.lean
@[simp]
theorem mkAlgHom_coe (s : A → A → Prop) : (mkAlgHom S s : A →+* RingQuot s) = mkRingHom s
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
/-- Hölder's inequality, as an inequality on the `ℒp` seminorm of an elementwise operation
`fun x => b (f x) (g x)`. -/
theorem eLpNorm_le_eLpNorm_mul_eLpNorm'_of_norm {p q r : ℝ≥0∞} (hf : AEStronglyMeasurable f μ)
    (hg : AEStronglyMeasurable g μ) (b : E → F → G)
    (h : ∀ᵐ x ∂μ, ‖b (f x) (g x)‖ ≤ ‖f x‖ * ‖g x‖) (hpqr : 1 / p = 1 / q + 1 / r) :
    eLpNorm (fun x => b (f x) (g x)) p μ ≤ eLpNorm f q μ * eLpNorm g r μ
-- Mathlib/Order/LiminfLimsup.lean
lemma limsup_piecewise {s : Set β} [DecidablePred (· ∈ s)] {v} :
    limsup (s.piecewise u v) f = blimsup u f (· ∈ s) ⊔ blimsup v f (· ∉ s)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem add_mul_left_right : IsRelPrime x (y + x * z)
-- Mathlib/LinearAlgebra/Basis.lean
theorem constr_eq {g : ι → M'} {f : M →ₗ[R] M'} (h : ∀ i, g i = f (b i)) :
    constr (M' := M') b S g = f
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
theorem add_apply (f g : P →ᴬ[R] W) (x : P) : (f + g) x = f x + g x
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
protected theorem exists_not_mem_row (μ : YoungDiagram) (i : ℕ) : ∃ j, (i, j) ∉ μ
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiff_snd : ContMDiff (I.prod J) J n (@Prod.snd M N)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem det_ne_zero_of_left_inverse [Nontrivial α] (h : B * A = 1) : A.det ≠ 0
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem exists_primitive_element_lt_of_isComplex {w₀ : InfinitePlace K} (hw₀ : IsComplex w₀)
    {B : ℝ≥0} (hB : minkowskiBound K ↑1 < convexBodyLT'Factor K * B) :
    ∃ a : 𝓞 K, ℚ⟮(a : K)⟯ = ⊤ ∧
      ∀ w : InfinitePlace K, w a < Real.sqrt (1 + B ^ 2)
-- Mathlib/CategoryTheory/Localization/HomEquiv.lean
lemma homEquiv_eq (G : D₁ ⥤ D₂) (e : L₁ ⋙ G ≅ L₂) (f : L₁.obj X ⟶ L₁.obj Y) :
    homEquiv W L₁ L₂ f = e.inv.app X ≫ G.map f ≫ e.hom.app Y
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
@[simp] theorem SatisfiesM_Option_eq : SatisfiesM (m := Option) p x ↔ ∀ a, x = some a → p a
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (a : AdicCauchySequence I M) :
    map I g (map I f a) = map I (g ∘ₗ f) a
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
@[simp] lemma mulSupport_zero : mulSupport (0 : ι → R) = univ
-- Mathlib/Algebra/Polynomial/Reverse.lean
theorem reverse_mul {f g : R[X]} (fg : f.leadingCoeff * g.leadingCoeff ≠ 0) :
    reverse (f * g) = reverse f * reverse g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem deriv_sinh : deriv sinh = cosh
-- Mathlib/LinearAlgebra/Span.lean
/-- Given an element `x` of a module `M` over `R`, the natural map from
    `R` to scalar multiples of `x`. See also `LinearMap.ringLmapEquivSelf`. -/
@[simps!]
def toSpanSingleton (x : M) : R →ₗ[R] M
-- Mathlib/Order/BoundedOrder.lean
theorem max_top_left [OrderTop α] (a : α) : max ⊤ a = ⊤
-- Mathlib/Probability/Distributions/Exponential.lean
/-- The exponential pdf is positive for all positive reals -/
lemma exponentialPDFReal_pos {x r : ℝ} (hr : 0 < r) (hx : 0 < x) :
    0 < exponentialPDFReal r x
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem coeff_modMonomial_of_not_le {s' s : σ →₀ ℕ} (x : MvPolynomial σ R) (h : ¬s ≤ s') :
    coeff s' (x %ᵐᵒⁿᵒᵐⁱᵃˡ s) = coeff s' x
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
theorem IntermediateField.algHomEquivAlgHomOfSplits_apply_apply (L : IntermediateField F A)
    (hL : ∀ x : K, (minpoly F x).Splits (algebraMap F L)) (f : K →ₐ[F] L) (x : K) :
    algHomEquivAlgHomOfSplits A L hL f x = algebraMap L A (f x)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma coe_eq_ofNat (n : ℕ) [n.AtLeastTwo] (m : α) :
    (m : WithTop α) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n
-- Mathlib/Data/Finset/Pointwise/Interval.lean
@[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d)
-- Mathlib/Topology/Order.lean
theorem le_generateFrom {t : TopologicalSpace α} {g : Set (Set α)} (h : ∀ s ∈ g, IsOpen s) :
    t ≤ generateFrom g
-- Mathlib/Data/Multiset/Basic.lean
theorem erase_add_left_neg {a : α} (s) {t : Multiset α} (h : a ∉ t) :
    (s + t).erase a = s.erase a + t
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
/-- The residue of `Λ` at `s = 0` is equal to `-f₀`. -/
theorem Λ_residue_zero :
    Tendsto (fun s : ℂ ↦ s • P.Λ s) (𝓝[≠] 0) (𝓝 (-P.f₀))
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem uniformContinuous_completionSeparationQuotientEquiv_symm :
    UniformContinuous (completionSeparationQuotientEquiv α).symm
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
protected theorem injective (e : P₁ ≃ᵃL[k] P₂) : Injective e
-- Mathlib/LinearAlgebra/Determinant.lean
theorem det_eq_one_of_subsingleton [Subsingleton M] (f : M →ₗ[R] M) :
    LinearMap.det (f : M →ₗ[R] M) = 1