ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Probability/Kernel/Composition.lean
theorem lintegral_fst (κ : Kernel α (β × γ)) (a : α) {g : β → ℝ≥0∞} (hg : Measurable g) :
    ∫⁻ c, g c ∂fst κ a = ∫⁻ bc : β × γ, g bc.fst ∂κ a
-- Mathlib/Data/Set/Prod.lean
theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t
-- Mathlib/Order/Bounds/Basic.lean
theorem Set.Nonempty.bddBelow_upperBounds (hs : s.Nonempty) : BddBelow (upperBounds s)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem real_inner_comm (x y : F) : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
theorem continuous_inl [Zero M] : Continuous (inl : R → tsze R M)
-- Mathlib/Order/Closure.lean
@[simp]
theorem closure_top : c ⊤ = ⊤
-- Mathlib/Data/Subtype.lean
theorem coind_injective {α β} {f : α → β} {p : β → Prop} (h : ∀ a, p (f a)) (hf : Injective f) :
    Injective (coind f h)
-- Mathlib/Algebra/Algebra/Opposite.lean
theorem toAlgHom_unop (f : Aᵐᵒᵖ ≃ₐ[R] Bᵐᵒᵖ) : f.unop.toAlgHom = AlgHom.unop f.toAlgHom
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem _root_.map_finset_sup [SemilatticeSup β] [OrderBot β]
    [FunLike F α β] [SupBotHomClass F α β]
    (f : F) (s : Finset ι) (g : ι → α) : f (s.sup g) = s.sup (f ∘ g)
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
@[simp]
theorem cycleOf_pow_apply_self (f : Perm α) [DecidableRel f.SameCycle] (x : α) :
    ∀ n : ℕ, (cycleOf f x ^ n) x = (f ^ n) x
-- Mathlib/MeasureTheory/Measure/Tilted.lean
lemma lintegral_tilted (f : α → ℝ) (g : α → ℝ≥0∞) :
    ∫⁻ x, g x ∂(μ.tilted f)
      = ∫⁻ x, ENNReal.ofReal (exp (f x) / ∫ x, exp (f x) ∂μ) * (g x) ∂μ
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
    (π₀ : Prepartition I) :
    (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r =>
      { π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion }
-- Mathlib/Order/Basic.lean
theorem lt_of_lt_of_eq' : b < c → a = b → a < c
-- Mathlib/Order/JordanHolder.lean
theorem lt_succ (s : CompositionSeries X) (i : Fin s.length) :
    s (Fin.castSucc i) < s (Fin.succ i)
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem HasStrictFDerivAt.log (hf : HasStrictFDerivAt f f' x) (hx : f x ≠ 0) :
    HasStrictFDerivAt (fun x => log (f x)) ((f x)⁻¹ • f') x
-- Mathlib/Topology/Constructions.lean
@[fun_prop]
theorem ContinuousAt.prod {f : X → Y} {g : X → Z} {x : X} (hf : ContinuousAt f x)
    (hg : ContinuousAt g x) : ContinuousAt (fun x => (f x, g x)) x
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
protected theorem inf_comm (a b : CauSeq α abs) : a ⊓ b = b ⊓ a
-- Mathlib/Algebra/Star/Pointwise.lean
@[simp]
theorem nonempty_star [InvolutiveStar α] {s : Set α} : s⋆.Nonempty ↔ s.Nonempty
-- Mathlib/Algebra/Homology/HomologicalComplexAbelian.lean
lemma shortExact_iff_degreewise_shortExact :
    S.ShortExact ↔ ∀ (i : ι), (S.map (eval C c i)).ShortExact
-- Mathlib/Topology/CompactOpen.lean
nonrec lemma _root_.ContinuousAt.compCM (hg : ContinuousAt g a) (hf : ContinuousAt f a) :
    ContinuousAt (fun x ↦ (g x).comp (f x)) a
-- Mathlib/Order/Filter/Lift.lean
theorem lift_principal {s : Set α} (hg : Monotone g) : (𝓟 s).lift g = g s
-- Mathlib/Order/Circular.lean
/-- The order of the `↔` has been chosen so that `rw [sbtw_cyclic]` cycles to the right while
`rw [← sbtw_cyclic]` cycles to the left (thus following the prepended arrow). -/
theorem sbtw_cyclic {a b c : α} : sbtw a b c ↔ sbtw c a b
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem _root_.Matrix.Nondegenerate.toLinearMap₂ {M : Matrix ι ι R₁} (h : M.Nondegenerate)
    (b : Basis ι R₁ M₁) : (toLinearMap₂ b b M).SeparatingLeft
-- Mathlib/Algebra/Group/Hom/End.lean
@[simp]
theorem AddMonoidHom.coe_flip_mul :
    ⇑(AddMonoidHom.mul : R →+ R →+ R).flip = AddMonoidHom.mulRight
-- Mathlib/Data/Multiset/Interval.lean
theorem card_Ioc :
    (Finset.Ioc s t).card = ∏ i ∈ s.toFinset ∪ t.toFinset, (t.count i + 1 - s.count i) - 1
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_atBot_iff_of_monotone [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β}
    (hf : Monotone f) : Tendsto f atBot atBot ↔ ∀ b : β, ∃ a : α, f a ≤ b
-- Mathlib/CategoryTheory/SingleObj.lean
/-- Construct a natural transformation between functors `SingleObj M ⥤ C` by
giving a compatible morphism `SingleObj.star M`. -/
@[simps]
def natTrans {F G : SingleObj M ⥤ C} (u : F.obj (SingleObj.star M) ⟶ G.obj (SingleObj.star M))
    (h : ∀ a : M, F.map a ≫ u = u ≫ G.map a) : F ⟶ G
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsionBy.mk_smul (a b : R) (x : torsionBy R M a) :
    Ideal.Quotient.mk (R ∙ a) b • x = b • x
-- Mathlib/Data/List/AList.lean
@[simp]
theorem lookup_union_eq_some {a} {b : β a} {s₁ s₂ : AList β} :
    lookup a (s₁ ∪ s₂) = some b ↔ lookup a s₁ = some b ∨ a ∉ s₁ ∧ lookup a s₂ = some b
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem span_pair_mul_span_pair (w x y z : R) :
    (span {w, x} : Ideal R) * span {y, z} = span {w * y, w * z, x * y, x * z}
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If a formal multilinear series `p` represents the zero function at `x : E`, then the
terms `p n (fun i ↦ y)` appearing in the sum are zero for any `n : ℕ`, `y : E`. -/
theorem HasFPowerSeriesAt.apply_eq_zero {p : FormalMultilinearSeries 𝕜 E F} {x : E}
    (h : HasFPowerSeriesAt 0 p x) (n : ℕ) : ∀ y : E, (p n fun _ => y) = 0
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
/-- If `f` is continuous on the circle `|z - c| = R`, `R > 0`, the `‖f z‖` is less than or equal to
`C : ℝ` on this circle, and this norm is strictly less than `C` at some point `z` of the circle,
then `‖∮ z in C(c, R), f z‖ < 2 * π * R * C`. -/
theorem norm_integral_lt_of_norm_le_const_of_lt {f : ℂ → E} {c : ℂ} {R C : ℝ} (hR : 0 < R)
    (hc : ContinuousOn f (sphere c R)) (hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C)
    (hlt : ∃ z ∈ sphere c R, ‖f z‖ < C) : ‖∮ z in C(c, R), f z‖ < 2 * π * R * C
-- Mathlib/NumberTheory/BernoulliPolynomials.lean
theorem derivative_bernoulli (k : ℕ) :
    Polynomial.derivative (bernoulli k) = k * bernoulli (k - 1)
-- Mathlib/Algebra/Lie/Submodule.lean
theorem sInf_coe_toSubmodule' (S : Set (LieSubmodule R L M)) :
    (↑(sInf S) : Submodule R M) = ⨅ N ∈ S, (N : Submodule R M)
-- Mathlib/Data/PNat/Prime.lean
theorem gcd_eq_left {m n : ℕ+} : m ∣ n → m.gcd n = m
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
protected theorem mul_dvd_mul_left (a : Nat) (h : b ∣ c) : a * b ∣ a * c
-- Mathlib/Tactic/FunProp/ContDiff.lean
/-- Original version `ContDiff.differentiable_iteratedDeriv` introduces a new variable `(n:ℕ∞)`
and `funProp` can't work with such theorem. The theorem should be state where `n` is explicitly
the smallest possible value i.e. `n=m+1`.

In conjunction with `ContDiff.of_le` we can recover the full power of the original theorem.  -/
theorem ContDiff.differentiable_iteratedDeriv' {m : ℕ} {f : K → F}
    (hf : ContDiff K (m+1) f) : Differentiable K (iteratedDeriv m f)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distance to a singleton is the distance to the unique point in this singleton. -/
@[simp]
theorem infDist_singleton : infDist x {y} = dist x y
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem comap_iSup {m : ι → MeasurableSpace α} : (⨆ i, m i).comap g = ⨆ i, (m i).comap g
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- If a power series converges at `w`, it converges absolutely at all `z` of smaller norm. -/
theorem summable_powerSeries_of_norm_lt {w z : α}
    (h : CauchySeq fun n ↦ ∑ i ∈ range n, f i * w ^ i) (hz : ‖z‖ < ‖w‖) :
    Summable fun n ↦ f n * z ^ n
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem singletonChartedSpace_mem_atlas_eq (h : e.source = Set.univ) (e' : PartialHomeomorph α H)
    (h' : e' ∈ (e.singletonChartedSpace h).atlas) : e' = e
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
@[simp]
theorem finrank_finsupp {ι : Type v} [Fintype ι] : finrank R (ι →₀ M) = card ι * finrank R M
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem normalCore_mono {H K : Subgroup G} (h : H ≤ K) : H.normalCore ≤ K.normalCore
-- Mathlib/Algebra/Lie/Character.lean
theorem lieCharacter_apply_of_mem_derived (χ : LieCharacter R L) {x : L}
    (h : x ∈ derivedSeries R L 1) : χ x = 0
-- Mathlib/Data/Finset/MulAntidiagonal.lean
@[to_additive]
theorem IsWF.mul (hs : s.IsWF) (ht : t.IsWF) : IsWF (s * t)
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_st' {x : ℝ*} (hx : ¬Infinite x) : IsSt x (st x)
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem conj_im (z : K) : im (conj z) = -im z
-- Mathlib/Data/Set/Opposite.lean
@[simp 1100]
theorem unop_mem_unop {s : Set αᵒᵖ} {a : αᵒᵖ} : unop a ∈ s.unop ↔ a ∈ s
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem coe_npowRec (f : α →ᵇ R) : ∀ n, ⇑(npowRec n f) = (⇑f) ^ n
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
private theorem div_nat_pos (n : ℕ) : 0 < 1 / (n + 1 : ℚ)
-- Mathlib/Topology/Algebra/Order/Field.lean
theorem eventually_nhdsWithin_pos_mul_left {x : 𝕜} (hx : 0 < x) {p : 𝕜 → Prop}
    (h : ∀ᶠ ε in 𝓝[>] 0, p ε) : ∀ᶠ ε in 𝓝[>] 0, p (x * ε)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem degree_div_le (p q : R[X]) : degree (p / q) ≤ degree p
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem inv_rpow (x : ℝ≥0) (y : ℝ) : x⁻¹ ^ y = (x ^ y)⁻¹
-- Mathlib/LinearAlgebra/PerfectPairing.lean
@[simp]
theorem toDualRight_apply (a : N) : p.toDualRight a = p.flip a
-- Mathlib/Data/Sum/Interval.lean
lemma Ico_inr_inr :
    Ico (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Ico b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding)
-- Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean
lemma prod_eq_zero (hi : i ∈ s) (h : f i = 0) : ∏ j ∈ s, f j = 0
-- Mathlib/Data/Sym/Sym2.lean
theorem diag_injective : Function.Injective (Sym2.diag : α → Sym2 α)
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
lemma nonempty_divisors : (divisors n).Nonempty ↔ n ≠ 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.pow {f : α → R} {g : α → 𝕜} (h : f =O[l] g) (n : ℕ) :
    (fun x => f x ^ n) =O[l] fun x => g x ^ n
-- Mathlib/Algebra/QuaternionBasis.lean
theorem lift_mul (x y : ℍ[R,c₁,c₂]) : q.lift (x * y) = q.lift x * q.lift y
-- Mathlib/CategoryTheory/Quotient.lean
@[simp]
lemma natTransLift_id (F : Quotient r ⥤ D) :
    natTransLift r (𝟙 (Quotient.functor r ⋙ F)) = 𝟙 _
-- Mathlib/Order/Heyting/Basic.lean
theorem hnot_le_iff_codisjoint_left : ￢a ≤ b ↔ Codisjoint b a
-- Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
/-- Bounding the norm of the iterated derivative of `B (f x) (g x)` in terms of the
iterated derivatives of `f` and `g` when `B` is bilinear of norm at most `1`:
`‖D^n (x ↦ B (f x) (g x))‖ ≤ ∑_{k ≤ n} n.choose k ‖D^k f‖ ‖D^{n-k} g‖` -/
theorem ContinuousLinearMap.norm_iteratedFDeriv_le_of_bilinear_of_le_one (B : E →L[𝕜] F →L[𝕜] G)
    {f : D → E} {g : D → F} {N : ℕ∞} (hf : ContDiff 𝕜 N f) (hg : ContDiff 𝕜 N g) (x : D) {n : ℕ}
    (hn : (n : ℕ∞) ≤ N) (hB : ‖B‖ ≤ 1) : ‖iteratedFDeriv 𝕜 n (fun y => B (f y) (g y)) x‖ ≤
      ∑ i ∈ Finset.range (n + 1),
        (n.choose i : ℝ) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_congr_iff (h₁ : ∀ y ∈ s, g' y = g y) : LiftPropOn P g' s ↔ LiftPropOn P g s
-- Mathlib/Tactic/Linarith/Lemmas.lean
lemma natCast_nonneg (α : Type u) [OrderedSemiring α] (n : ℕ) : (0 : α) ≤ n
-- Mathlib/RingTheory/Algebraic.lean
theorem isAlgebraic_zero [Nontrivial R] : IsAlgebraic R (0 : A)
-- Mathlib/Algebra/Order/Floor.lean
theorem le_of_ceil_le (h : ⌈a⌉₊ ≤ n) : a ≤ n
-- Mathlib/Order/Directed.lean
theorem exists_lt_of_directed_le [IsDirected β (· ≤ ·)] [Nontrivial β] : ∃ a b : β, a < b
-- Mathlib/Analysis/Convex/Slope.lean
/-- If `f : 𝕜 → 𝕜` is concave, then for any three points `x < y < z` the slope of the secant line of
`f` on `[x, y]` is greater than the slope of the secant line of `f` on `[y, z]`. -/
theorem ConcaveOn.slope_anti_adjacent (hf : ConcaveOn 𝕜 s f) {x y z : 𝕜} (hx : x ∈ s) (hz : z ∈ s)
    (hxy : x < y) (hyz : y < z) : (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
-- Mathlib/Order/Hom/Lattice.lean
theorem copy_eq (f : SupBotHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- If there is a homomorphism `f : α →+* β` and `β` is nontrivial, then `α` is nontrivial. -/
theorem domain_nontrivial [Nontrivial β] : Nontrivial α
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Construct a natural isomorphism between functors out of the walking parallel pair from
its components. -/
@[simps!]
def parallelPair.ext {F G : WalkingParallelPair ⥤ C} (zero : F.obj zero ≅ G.obj zero)
    (one : F.obj one ≅ G.obj one) (left : F.map left ≫ one.hom = zero.hom ≫ G.map left)
    (right : F.map right ≫ one.hom = zero.hom ≫ G.map right) : F ≅ G
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a
-- Mathlib/Order/Atoms.lean
theorem IsCoatom.of_isCoatom_coe_Ici {a : Set.Ici x} (ha : IsCoatom a) : IsCoatom (a : α)
-- Mathlib/Algebra/Ring/Parity.lean
@[parity_simps] lemma odd_add : Odd (m + n) ↔ (Odd m ↔ Even n)
-- Mathlib/Data/Fin/Basic.lean
/-- Embedding `Fin n` into `Fin (n + 1)` with a hole around zero embeds by `succ`. -/
@[simp] lemma succAbove_zero : succAbove (0 : Fin (n + 1)) = Fin.succ
-- Mathlib/Order/Filter/Ultrafilter.lean
protected theorem isAtom (f : Ultrafilter α) : IsAtom (f : Filter α)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingularLift_iff (P : Fin 3 → R) : W'.NonsingularLift ⟦P⟧ ↔ W'.Nonsingular P
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
lemma tprod_subtype_le {κ γ : Type*} [OrderedCommGroup γ] [UniformSpace γ] [UniformGroup γ]
    [OrderClosedTopology γ] [CompleteSpace γ] (f : κ → γ) (β : Set κ) (h : ∀ a : κ, 1 ≤ f a)
    (hf : Multipliable f) : (∏' (b : β), f b) ≤ (∏' (a : κ), f a)
-- Mathlib/Data/Sign.lean
@[simp]
theorem neg_one_le (a : SignType) : -1 ≤ a
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- In a complex Banach algebra, the spectral radius is always attained by some element of the
spectrum. -/
theorem exists_nnnorm_eq_spectralRadius : ∃ z ∈ spectrum ℂ a, (‖z‖₊ : ℝ≥0∞) = spectralRadius ℂ a
-- Mathlib/Order/Filter/Cofinite.lean
@[simp]
theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem consRecOn_cons {motive : Word M → Sort*} (i) (m : M i) (w : Word M) h1 h2
    (h_empty : motive empty)
    (h_cons : ∀ (i) (m : M i) (w) h1 h2, motive w → motive (cons m w h1 h2)) :
    consRecOn (cons m w h1 h2) h_empty h_cons = h_cons i m w h1 h2
      (consRecOn w h_empty h_cons)
-- Mathlib/Tactic/NormNum/BigOperators.lean
lemma Multiset.range_succ' {n nn n' : ℕ} (pn : NormNum.IsNat n nn) (pn' : nn = Nat.succ n') :
    Multiset.range n = n' ::ₘ Multiset.range n'
-- Mathlib/RingTheory/Binomial.lean
theorem multichoose_neg_self (n : ℕ) : multichoose (-n : ℤ) n = (-1)^n
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem lift_inl (n : N) : lift f₁ f₂ h (inl n) = f₁ n
-- Mathlib/Order/Filter/Basic.lean
theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α → β} :
    f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ x in F, x ∈ s → f x = g x
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem deriv_star (P : RegularExpression α) (a : α) : deriv P.star a = deriv P a * star P
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem basis_toMatrix_mul [Fintype κ] [Finite ι] [DecidableEq κ]
    (b₁ : Basis ι R M) (b₂ : Basis ι' R M) (b₃ : Basis κ R N) (A : Matrix ι' κ R) :
    b₁.toMatrix b₂ * A = LinearMap.toMatrix b₃ b₁ (toLin b₃ b₂ A)
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem coe_comp_orderHom (g : PseudoEpimorphism β γ) (f : PseudoEpimorphism α β) :
    (g.comp f : α →o γ) = (g : β →o γ).comp f
-- Mathlib/LinearAlgebra/Dual.lean
theorem toDual_inj (m : M) (a : b.toDual m = 0) : m = 0
-- Mathlib/Logic/Relator.lean
protected lemma refl (hr : ∀ a : α, r₁₁ a a) :
    LeftTotal r₁₁
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.algebraMap_intNorm_of_isGalois
    [IsDomain A] [IsIntegrallyClosed A] [IsDomain B] [IsIntegrallyClosed B]
    [Module.Finite A B] [NoZeroSMulDivisors A B] [IsGalois (FractionRing A) (FractionRing B)]
    {x : B} :
    algebraMap A B (Algebra.intNorm A B x) = ∏ σ : B ≃ₐ[A] B, σ x
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
    ∀ {x : M}, x ∈ s → x ∈ sSup S
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem length_eraseP_add_one {l : List α} {a} (al : a ∈ l) (pa : p a) :
    (l.eraseP p).length + 1 = l.length
-- .lake/packages/lean4/src/lean/Init/Data/Array/BasicAux.lean
theorem Array.of_push_eq_push {as bs : Array α} (h : as.push a = bs.push b) : as = bs ∧ a = b
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma div_dvd_iff_dvd_mul (h : b ∣ a) (hb : b ≠ 0) : a / b ∣ c ↔ a ∣ b * c
-- Mathlib/Topology/Compactness/SigmaCompact.lean
/-- A compact exhaustion eventually covers any compact set. -/
theorem exists_superset_of_isCompact {s : Set X} (hs : IsCompact s) : ∃ n, s ⊆ K n
-- Mathlib/Data/List/Basic.lean
theorem head?_append_of_ne_nil :
    ∀ (l₁ : List α) {l₂ : List α} (_ : l₁ ≠ []), head? (l₁ ++ l₂) = head? l₁
-- Mathlib/Order/Filter/Extr.lean
theorem isMaxFilter_dual_iff : IsMaxFilter (toDual ∘ f) l a ↔ IsMinFilter f l a
-- Mathlib/FieldTheory/SplittingField/IsSplittingField.lean
theorem adjoin_rootSet (f : K[X]) [IsSplittingField K L f] :
    Algebra.adjoin K (f.rootSet L : Set L) = ⊤
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem localTrivAt_def (b : B) : Z.localTriv (Z.indexAt b) = Z.localTrivAt b
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
@[simp]
theorem mem_weightedHomogeneousSubmodule (w : σ → M) (m : M) (p : MvPolynomial σ R) :
    p ∈ weightedHomogeneousSubmodule R w m ↔ p.IsWeightedHomogeneous w m
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
/-- An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p`
is a discrete valuation ring.
-/
theorem ofHasUnitMulPowIrreducibleFactorization {R : Type u} [CommRing R] [IsDomain R]
    (hR : HasUnitMulPowIrreducibleFactorization R) : DiscreteValuationRing R
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@[simp]
theorem liftAlternating_comp (g : N →ₗ[R] N') (f : ∀ i, M [⋀^Fin i]→ₗ[R] N) :
    (liftAlternating (R := R) (M := M) (N := N') fun i => g.compAlternatingMap (f i)) =
    g ∘ₗ liftAlternating (R := R) (M := M) (N := N) f
-- Mathlib/Computability/TMToPartrec.lean
theorem stepNormal.is_ret (c k v) : ∃ k' v', stepNormal c k v = Cfg.ret k' v'
-- Mathlib/Data/List/Basic.lean
theorem takeWhile_takeWhile (p q : α → Bool) (l : List α) :
    takeWhile p (takeWhile q l) = takeWhile (fun a => p a ∧ q a) l
-- Mathlib/Data/List/Sym.lean
theorem map_mk_disjoint_sym2 (x : α) (xs : List α) (h : x ∉ xs) :
    (map (fun y ↦ s(x, y)) xs).Disjoint xs.sym2
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
/-- A space is totally separated if any two points can be separated by two disjoint open sets
covering the whole space. -/
class TotallySeparatedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally separated space is totally separated. -/
  isTotallySeparated_univ : IsTotallySeparated (univ : Set α)
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem mono_lie_right (h : N ≤ N') : ⁅I, N⁆ ≤ ⁅I, N'⁆
-- Mathlib/Algebra/AddTorsor.lean
/-- If the same point subtracted from two points produces equal
results, those points are equal. -/
theorem vsub_left_cancel {p₁ p₂ p : P} (h : p₁ -ᵥ p = p₂ -ᵥ p) : p₁ = p₂
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
@[simp] lemma Spec.preimage_map : Spec.preimage (Spec.map φ) = φ
-- Mathlib/Data/Analysis/Filter.lean
theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.F a).Nonempty
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
/-- If the image of a morphism falls in a subpresheaf, then the morphism factors through it. -/
@[simps!]
def Subpresheaf.lift (f : F' ⟶ F) (hf : ∀ U x, f.app U x ∈ G.obj U) : F' ⟶ G.toPresheaf
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem revAt_invol {N i : ℕ} : (revAt N) (revAt N i) = i
-- Mathlib/Order/Iterate.lean
/-- If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
form a strictly monotone sequence. -/
theorem strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
    StrictMono fun n => f^[n] x
-- Mathlib/Order/ModularLattice.lean
theorem sup_inf_assoc_of_le {x : α} (y : α) {z : α} (h : x ≤ z) : (x ⊔ y) ⊓ z = x ⊔ y ⊓ z
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem eraseLead_natDegree_le (f : R[X]) : (eraseLead f).natDegree ≤ f.natDegree - 1
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degreeOf_mul_le (i : σ) (f g : MvPolynomial σ R) :
    degreeOf i (f * g) ≤ degreeOf i f + degreeOf i g
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.append_right {l₁ l₂ : List α} (t₁ : List α) (p : l₁ ~ l₂) : l₁ ++ t₁ ~ l₂ ++ t₁
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp) fst_comp_prod]
theorem fst_comp_prod (f : M →* N) (g : M →* P) : (fst N P).comp (f.prod g) = f
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem transpose_empty_cols (A : Matrix (Fin 0) m' α) : Aᵀ = of fun _ => ![]
-- Mathlib/Order/WithBot.lean
@[simp]
protected theorem not_top_lt (a : WithTop α) : ¬⊤ < a
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
/-- If `M` is a finite `R`-module, then the canonical map
`AdicCompletion I R ⊗[R] M →ₗ AdicCompletion I M` is surjective. -/
lemma ofTensorProduct_surjective_of_finite [Module.Finite R M] :
    Function.Surjective (ofTensorProduct I M)
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- See also `smul_finsum` for a version that works even when the support of `f` is not finite,
but with slightly stronger typeclass requirements. -/
theorem smul_finsum' {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M] (c : R) {f : ι → M}
    (hf : (support f).Finite) : (c • ∑ᶠ i, f i) = ∑ᶠ i, c • f i
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem prod_symm (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    (e.prod e').symm = e.symm.prod e'.symm
-- Mathlib/Data/Erased.lean
@[simp]
theorem nonempty_iff {α} : Nonempty (Erased α) ↔ Nonempty α
-- Mathlib/Data/Set/Card.lean
theorem ncard_union_le (s t : Set α) : (s ∪ t).ncard ≤ s.ncard + t.ncard
-- Mathlib/Data/Finset/Pointwise.lean
theorem image_div : (s / t).image (f : α → β) = s.image f / t.image f
-- Mathlib/Algebra/GCDMonoid/Finset.lean
lemma gcd_div_id_eq_one {s : Finset α} {a : α} (has : a ∈ s) (ha : a ≠ 0) :
    s.gcd (fun b ↦ b / s.gcd id) = 1
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem mem_dualCoannihilator {Φ : Submodule R (Module.Dual R M)} (x : M) :
    x ∈ Φ.dualCoannihilator ↔ ∀ φ ∈ Φ, (φ x : R) = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem deriv_cos {x : ℂ} : deriv cos x = -sin x
-- Mathlib/FieldTheory/IsSepClosed.lean
theorem algebraMap_surjective
    [IsSepClosed k] [Algebra k K] [Algebra.IsSeparable k K] :
    Function.Surjective (algebraMap k K)
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
lemma in₂₀_iff' :
    (graph t).Adj (in₂ c) (in₀ a) ↔ ∃ x : α × β × γ, x ∈ t ∧ x.2.2 = c ∧ x.1 = a
-- Mathlib/Algebra/Ring/Pi.lean
/-- `Function.const` as a `NonUnitalRingHom`. -/
@[simps]
def Pi.constNonUnitalRingHom (α β : Type*) [NonUnitalNonAssocSemiring β] : β →ₙ+* α → β
-- Mathlib/Topology/Connected/PathConnected.lean
/-- A topological space is locally path connected, at every point, path connected
neighborhoods form a neighborhood basis. -/
class LocPathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- Each neighborhood filter has a basis of path-connected neighborhoods. -/
  path_connected_basis : ∀ x : X, (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s) id