ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Lie/InvariantForm.lean
/--
A finite-dimensional Lie algebra over a field is semisimple
if it does not have non-trivial abelian ideals and it admits a
non-degenerate reflexive invariant bilinear form.
Here a form is *invariant* if it is compatible with the Lie bracket: `Φ ⁅x, y⁆ z = Φ x ⁅y, z⁆`.
-/
theorem isSemisimple_of_nondegenerate : IsSemisimple K L
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem card_sub {s t : Multiset α} (h : t ≤ s) : card (s - t) = card s - card t
-- Mathlib/Data/Complex/Abs.lean
@[simp]
theorem abs_natCast (n : ℕ) : Complex.abs n = n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.denote_le_cancelAux (ctx : Context) (fuel : Nat) (m₁ m₂ r₁ r₂ : Poly)
    (h : denote_le ctx (r₁.reverse ++ m₁, r₂.reverse ++ m₂)) : denote_le ctx (cancelAux fuel m₁ m₂ r₁ r₂)
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem length_toList (s : Finset α) : s.toList.length = s.card
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem le_opNorm_mul_prod_of_le {b : ι → ℝ} (hm : ∀ i, ‖m i‖ ≤ b i) : ‖f m‖ ≤ ‖f‖ * ∏ i, b i
-- Mathlib/RingTheory/Congruence/Basic.lean
protected theorem trans {x y z} : c x y → c y z → c x z
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- A version of `edist_le_range_sum_edist` with each intermediate distance replaced
with an upper estimate. -/
theorem edist_le_range_sum_of_edist_le {f : ℕ → α} (n : ℕ) {d : ℕ → ℝ≥0∞}
    (hd : ∀ {k}, k < n → edist (f k) (f (k + 1)) ≤ d k) :
    edist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, d i
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableAt_const : MDifferentiableAt I I' (fun _ : M => c) x
-- Mathlib/FieldTheory/Fixed.lean
theorem irreducible : Irreducible (minpoly G F x)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_nhdsWithin_iff {t : Set α} : s ∈ 𝓝[t] x ↔ ∃ ε > 0, ball x ε ∩ t ⊆ s
-- Mathlib/CategoryTheory/GradedObject/Trifunctor.lean
@[reassoc (attr := simp)]
lemma ι_mapBifunctorComp₂₃MapObjIso_hom (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J)
    (h : r (i₁, i₂, i₃) = j) :
    ιMapTrifunctorMapObj (bifunctorComp₂₃ F G₂₃) r X₁ X₂ X₃ i₁ i₂ i₃ j h ≫
      (mapBifunctorComp₂₃MapObjIso F G₂₃ ρ₂₃ X₁ X₂ X₃).hom j =
      ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem comap_top (f : R →ₙ+* S) : (⊤ : NonUnitalSubring S).comap f = ⊤
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumProdDistrib_symm_apply_right (b : β × γ) :
    (sumProdDistrib α β γ).symm (inr b) = (inr b.1, b.2)
-- Mathlib/Order/CompleteLattice.lean
/-- Introduction rule to prove that `b` is the infimum of `f`: it suffices to check that `b`
is smaller than `f i` for all `i`, and that this is not the case of any `w>b`.
See `ciInf_eq_of_forall_ge_of_forall_gt_exists_lt` for a version in conditionally complete
lattices. -/
theorem iInf_eq_of_forall_ge_of_forall_gt_exists_lt :
    (∀ i, b ≤ f i) → (∀ w, b < w → ∃ i, f i < w) → ⨅ i, f i = b
-- Mathlib/Logic/Function/Basic.lean
theorem Injective.bijective₂_of_surjective {g : γ → α} (hf : Injective f) (hg : Injective g)
    (S : Surjective (f ∘ g)) : Bijective f ∧ Bijective g
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_filter (p : α → Prop) [DecidablePred p] (f : α → β) :
    ∏ a ∈ s.filter p, f a = ∏ a ∈ s, if p a then f a else 1
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_uIcc (r s : β) : StrictConvex 𝕜 (uIcc r s)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem leadingCoeff_divByMonic_X_sub_C (p : R[X]) (hp : degree p ≠ 0) (a : R) :
    leadingCoeff (p /ₘ (X - C a)) = leadingCoeff p
-- Mathlib/Data/List/Basic.lean
theorem reverse_singleton (a : α) : reverse [a] = [a]
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem coe_toHom {f : M ≃[L] N} : (f.toHom : M → N) = (f : M → N)
-- Mathlib/Order/Filter/Basic.lean
theorem nonempty_of_mem {f : Filter α} [hf : NeBot f] {s : Set α} (hs : s ∈ f) : s.Nonempty
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_pos_iff_degree_pos : 0 < natDegree p ↔ 0 < degree p
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
@[simp]
lemma cotangentComplex_mk (x) : P.cotangentComplex (.mk x) = 1 ⊗ₜ .D _ _ x
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem one_def : (1 : E →ₗᵢ[R] E) = id
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
theorem covering_of_eq_top : S = ⊤ → S ∈ J X
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_eq_zero {a : R[X]} : a.toFinsupp = 0 ↔ a = 0
-- Mathlib/Data/Analysis/Topology.lean
protected theorem is_basis [T : TopologicalSpace α] (F : Realizer α) :
    TopologicalSpace.IsTopologicalBasis (Set.range F.F.f)
-- Mathlib/Analysis/Calculus/Deriv/Pow.lean
theorem hasStrictDerivAt_pow :
    ∀ (n : ℕ) (x : 𝕜), HasStrictDerivAt (fun x : 𝕜 ↦ x ^ n) ((n : 𝕜) * x ^ (n - 1)) x
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
/-- If the measure `μ.trim hm` is sigma-finite, then the conditional expectation of a measurable set
with finite measure is integrable. -/
theorem integrable_condexpIndSMul (hm : m ≤ m0) [SigmaFinite (μ.trim hm)] (hs : MeasurableSet s)
    (hμs : μ s ≠ ∞) (x : G) : Integrable (condexpIndSMul hm hs hμs x) μ
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem nonempty_of_pos_dist (h : 0 < G.dist u v) :
    (Set.univ : Set (G.Walk u v)).Nonempty
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem pell_eqz (n : ℕ) : xz a1 n * xz a1 n - d a1 * yz a1 n * yz a1 n = 1
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_X_mul (m) (s : σ) (p : MvPolynomial σ R) :
    coeff (Finsupp.single s 1 + m) (X s * p) = coeff m p
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem ofLeftInverse_symm_apply {g : B → A} {f : A →ₐ[R] B} (h : Function.LeftInverse g f)
    (x : f.range) : (ofLeftInverse h).symm x = g x
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_neg_iff (h : 0 < x) : log x < 0 ↔ x < 1
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem differentiable_circleMap (c : ℂ) (R : ℝ) : Differentiable ℝ (circleMap c R)
-- Mathlib/Order/Atoms.lean
@[simp]
theorem sSup_atoms_le_eq (b : α) : sSup { a : α | IsAtom a ∧ a ≤ b } = b
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp] lemma rpow_rpow_inv {y : ℝ} (hy : y ≠ 0) (x : ℝ≥0) : (x ^ y) ^ y⁻¹ = x
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem coe_piCongr_symm : ((h₁.piCongr h₂).symm :
    (∀ b, Z b) → ∀ a, W a) = fun f a => (h₂ a).symm (f (h₁ a))
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- If the average of a function `f` along a sequence of sets `aₙ` converges to `c` (more precisely,
we require that `⨍ y in a i, ‖f y - c‖ ∂μ` tends to `0`), then the integral of `gₙ • f` also tends
to `c` if `gₙ` is supported in `aₙ`, has integral converging to one and supremum at most `K / μ aₙ`.
-/
theorem tendsto_integral_smul_of_tendsto_average_norm_sub
    {ι : Type*} {a : ι → Set α} {l : Filter ι} {f : α → E} {c : E} {g : ι → α → ℝ} (K : ℝ)
    (hf : Tendsto (fun i ↦ ⨍ y in a i, ‖f y - c‖ ∂μ) l (𝓝 0))
    (f_int : ∀ᶠ i in l, IntegrableOn f (a i) μ)
    (hg : Tendsto (fun i ↦ ∫ y, g i y ∂μ) l (𝓝 1))
    (g_supp : ∀ᶠ i in l, Function.support (g i) ⊆ a i)
    (g_bound : ∀ᶠ i in l, ∀ x, |g i x| ≤ K / (μ (a i)).toReal) :
    Tendsto (fun i ↦ ∫ y, g i y • f y ∂μ) l (𝓝 c)
-- Mathlib/NumberTheory/Pell.lean
/-- The `y`-coordinate of a fundamental solution is a lower bound for the `y`-coordinate
of any positive solution. -/
theorem y_le_y {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x)
    (hay : 0 < a.y) : a₁.y ≤ a.y
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[reassoc, simp]
theorem comp_sub : f ≫ (g - g') = f ≫ g - f ≫ g'
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z
-- Mathlib/Order/GaloisConnection.lean
theorem sSup_image2_eq_sSup_sSup (h₁ : ∀ b, GaloisConnection (swap l b) (u₁ b))
    (h₂ : ∀ a, GaloisConnection (l a) (u₂ a)) : sSup (image2 l s t) = l (sSup s) (sSup t)
-- Mathlib/Algebra/Regular/SMul.lean
lemma of_injective {N F} [SMul R N] [FunLike F M N] [MulActionHomClass F R M N]
    (f : F) {r : R} (h1 : Function.Injective f) (h2 : IsSMulRegular N r) :
    IsSMulRegular M r
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_eq : ∃ a, a = a'
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialOn_congr' {s : Set E} (h : f =ᶠ[𝓝ˢ s] g) :
    CPolynomialOn 𝕜 f s ↔ CPolynomialOn 𝕜 g s
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
nonrec theorem neg_le_neg {i : Set α} (hi : MeasurableSet i) (h : v ≤[i] w) : -w ≤[i] -v
-- Mathlib/Combinatorics/Enumerative/DoubleCounting.lean
theorem card_mul_eq_card_mul [∀ a b, Decidable (r a b)]
    (hm : ∀ a ∈ s, (t.bipartiteAbove r a).card = m)
    (hn : ∀ b ∈ t, (s.bipartiteBelow r b).card = n) : s.card * m = t.card * n
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem exists_mem_compactCovering (x : X) : ∃ n, x ∈ compactCovering X n
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc (attr := simp)]
theorem triangle_assoc_comp_right (f : a ⟶ b) (g : b ⟶ c) :
    (α_ f (𝟙 b) g).inv ≫ (ρ_ f).hom ▷ g = f ◁ (λ_ g).hom
-- Mathlib/Data/Finset/Card.lean
@[gcongr]
theorem card_le_card : s ⊆ t → s.card ≤ t.card
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
@[simp]
theorem Units.inv_pos
    [ZeroLEOneClass α] [NeZero (R := α) 1] [PosMulStrictMono α]
    {u : αˣ} : (0 : α) < ↑u⁻¹ ↔ (0 : α) < u
-- Mathlib/CategoryTheory/Limits/ColimitLimit.lean
theorem map_id_right_eq_curry_swap_map {j j' : J} {f : j ⟶ j'} {k : K} :
    F.map ((f, 𝟙 k) : (j, k) ⟶ (j', k)) = ((curry.obj (Prod.swap K J ⋙ F)).obj k).map f
-- Mathlib/Algebra/CharP/Defs.lean
@[simp] lemma cast_eq_zero : (p : R) = 0
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
    (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) :
    -- Porting note: needed to add universe hint blsub.{u,v} in the line below
    blsub.{u,v} _ f =
      max (blsub.{u, v} a fun a' ha' => f (a' ♯ b) <| nadd_lt_nadd_right ha' b)
        (blsub.{u, v} b fun b' hb' => f (a ♯ b') <| nadd_lt_nadd_left hb' a)
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem im_star : (star a).im = -a.im
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast] theorem coe_neg (x : ℝ) : (↑(-x) : EReal) = -↑x
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.lt_right_of_left_lt (hf : ConvexOn 𝕜 s f) {x y z : E} (hx : x ∈ s) (hy : y ∈ s)
    (hz : z ∈ openSegment 𝕜 x y) (hxz : f x < f z) : f z < f y
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem dual_id : sInfHom.dual (sInfHom.id α) = sSupHom.id _
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side. -/
theorem norm_div_tan_oangle_add_right_of_oangle_eq_pi_div_two {x y : V}
    (h : o.oangle x y = ↑(π / 2)) : ‖y‖ / Real.Angle.tan (o.oangle x (x + y)) = ‖x‖
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
theorem IsIntegralClosure.isLocalization_of_isSeparable [Algebra.IsSeparable K L] :
    IsLocalization (Algebra.algebraMapSubmonoid C A⁰) L
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[reassoc (attr := simp)]
theorem OplaxMonoidalFunctor.right_unitality_hom (F : OplaxMonoidalFunctor C D) (X : C) :
    F.δ X (𝟙_ C) ≫ F.obj X ◁ F.η ≫ (ρ_ (F.obj X)).hom = F.map (ρ_ X).hom
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem IsBoundedBilinearMap.isBoundedLinearMap_left (h : IsBoundedBilinearMap 𝕜 f) (y : F) :
    IsBoundedLinearMap 𝕜 fun x => f (x, y)
-- Mathlib/Data/DFinsupp/NeLocus.lean
@[simp]
theorem neLocus_eq_empty {f g : Π₀ a, N a} : f.neLocus g = ∅ ↔ f = g
-- Mathlib/Control/Traversable/Lemmas.lean
@[functor_norm]
theorem traverse_comp (g : α → F β) (h : β → G γ) :
    traverse (Comp.mk ∘ map h ∘ g) =
      (Comp.mk ∘ map (traverse h) ∘ traverse g : t α → Comp F G (t γ))
-- Mathlib/Data/Set/Basic.lean
theorem SetCoe.forall' {s : Set α} {p : ∀ x, x ∈ s → Prop} :
    (∀ (x) (h : x ∈ s), p x h) ↔ ∀ x : s, p x.1 x.2
-- Mathlib/Algebra/Ring/Parity.lean
lemma Odd.of_mul_left (h : Odd (m * n)) : Odd m
-- Mathlib/Topology/Constructions.lean
theorem embedding_inr : Embedding (@inr X Y)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_add_Ioo : (fun x => a + x) ⁻¹' Ioo b c = Ioo (b - a) (c - a)
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem refl_mul (e : Perm α) : Equiv.refl α * e = e
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem dimensionLEOne : DimensionLEOne A
-- Mathlib/Analysis/NormedSpace/QuaternionExponential.lean
@[simp, norm_cast]
theorem exp_coe (r : ℝ) : exp ℝ (r : ℍ[ℝ]) = ↑(exp ℝ r)
-- Mathlib/Data/ENNReal/Operations.lean
protected theorem sub_eq_of_eq_add_rev (hb : b ≠ ∞) : a = b + c → a - b = c
-- Mathlib/RingTheory/Coalgebra/Hom.lean
protected theorem congr_fun {φ₁ φ₂ : A →ₗc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_def (a b : α) : { x | a ≤ x ∧ x ≤ b } = Icc a b
-- Mathlib/Data/ENNReal/Operations.lean
protected theorem sub_lt_of_lt_add (hac : c ≤ a) (h : a < b + c) : a - c < b
-- Mathlib/Analysis/Convex/AmpleSet.lean
/-- A whole vector space is ample. -/
@[simp]
theorem ampleSet_univ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] :
    AmpleSet (univ : Set F)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem sdiff_eq_empty_iff_subset : s \ t = ∅ ↔ s ⊆ t
-- Mathlib/CategoryTheory/Conj.lean
theorem conj_pow (f : End X) (n : ℕ) : α.conj (f ^ n) = α.conj f ^ n
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem out_injective : Function.Injective (Associates.out : _ → α)
-- Mathlib/Data/Option/NAry.lean
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g')
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
protected theorem lt_asymm {a b : Char} (h : a < b) : ¬ b < a
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- Any matrix can be written as the product of transvections, a diagonal matrix, and
transvections. -/
theorem exists_list_transvec_mul_diagonal_mul_list_transvec (M : Matrix n n 𝕜) :
    ∃ (L L' : List (TransvectionStruct n 𝕜)) (D : n → 𝕜),
      M = (L.map toMatrix).prod * diagonal D * (L'.map toMatrix).prod
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma truncatedInf_union_left (hs : a ∈ upperClosure s) (ht : a ∉ upperClosure t) :
    truncatedInf (s ∪ t) a = truncatedInf s a
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp] lemma deleteEdges_univ : G.deleteEdges Set.univ = ⊥
-- Mathlib/Algebra/Lie/Quotient.lean
@[simp]
theorem map_mk'_eq_bot_le : map (mk' N) N' = ⊥ ↔ N' ≤ N
-- Mathlib/Data/PEquiv.lean
theorem isSome_symm_get (f : α ≃. β) {a : α} (h : isSome (f a)) :
    isSome (f.symm (Option.get _ h))
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_le : (∀ b ∈ s, b ≤ a) → sSup s ≤ a
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem powersetCard_card_add (s : Multiset α) {i : ℕ} (hi : 0 < i) :
    s.powersetCard (card s + i) = 0
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem integrableOn_Icc_iff_integrableOn_Ico' (hb : μ {b} ≠ ∞) :
    IntegrableOn f (Icc a b) μ ↔ IntegrableOn f (Ico a b) μ
-- Mathlib/Computability/TuringMachine.lean
@[refl]
theorem Reaches₀.refl {σ} {f : σ → Option σ} (a : σ) : Reaches₀ f a a
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem filter_neg (p : α → Prop) [DecidablePred p] (f : α →₀ G) : filter p (-f) = -filter p f
-- Mathlib/RingTheory/Ideal/Basic.lean
/-- If P is not properly contained in any maximal ideal then it is not properly contained
  in any proper ideal -/
theorem maximal_of_no_maximal {P : Ideal α}
    (hmax : ∀ m : Ideal α, P < m → ¬IsMaximal m) (J : Ideal α) (hPJ : P < J) : J = ⊤
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `s` be a convex set in a real normed vector space `E`, let `f : E → G` be a function
differentiable within `s` in a neighborhood of `x : E` with derivative `f'`. Suppose that `f'` is
continuous within `s` at `x`. Then for any number `K : ℝ≥0` larger than `‖f' x‖₊`, `f` is Lipschitz
on some neighborhood of `x` within `s`. See also
`Convex.exists_nhdsWithin_lipschitzOnWith_of_hasFDerivWithinAt_of_nnnorm_lt` for a version
with an explicit estimate on the Lipschitz constant. -/
theorem exists_nhdsWithin_lipschitzOnWith_of_hasFDerivWithinAt (hs : Convex ℝ s) {f : E → G}
    (hder : ∀ᶠ y in 𝓝[s] x, HasFDerivWithinAt f (f' y) s y) (hcont : ContinuousWithinAt f' s x) :
    ∃ K, ∃ t ∈ 𝓝[s] x, LipschitzOnWith K f t
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem vanishingIdeal_anti_mono {s t : Set (ProjectiveSpectrum 𝒜)} (h : s ⊆ t) :
    vanishingIdeal t ≤ vanishingIdeal s
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
lemma homMk'_mk_id (f : S.obj Y ⟶ T) : homMk' (mk f) (𝟙 Y) = eqToHom (by aesop_cat)
-- Mathlib/RingTheory/Polynomial/Hermite/Gaussian.lean
/-- `hermite n` is (up to sign) the factor appearing in `deriv^[n]` of a gaussian -/
theorem deriv_gaussian_eq_hermite_mul_gaussian (n : ℕ) (x : ℝ) :
    deriv^[n] (fun y => Real.exp (-(y ^ 2 / 2))) x =
    (-1 : ℝ) ^ n * aeval x (hermite n) * Real.exp (-(x ^ 2 / 2))
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_notin_range {f : α → β} (x : α →₀ M) (a : β) (h : a ∉ Set.range f) :
    mapDomain f x a = 0
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma sign_cases_of_C_mul_pow_nonneg [PosMulStrictMono α]
    (h : ∀ n, 0 ≤ a * b ^ n) : a = 0 ∨ 0 < a ∧ 0 ≤ b
-- Mathlib/Analysis/Convex/Hull.lean
theorem convexHull_convexHull_union_left (s t : Set E) :
    convexHull 𝕜 (convexHull 𝕜 s ∪ t) = convexHull 𝕜 (s ∪ t)
-- Mathlib/Data/Finset/Pointwise/Interval.lean
@[to_additive Ico_add_Ioc_subset]
theorem Ico_mul_Ioc_subset' [LocallyFiniteOrder α] (a b c d : α) :
    Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)
-- Mathlib/Order/UpperLower/Basic.lean
lemma Ici_inf_erase (ha : a ∈ s) (has : ∀ b ∈ s, b ≤ a → b = a) : Ici a ⊓ s.erase a = s
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_nnnorm_eq_of_nonneg {f : α → ℝ} (h_nonneg : 0 ≤ f) :
    ∫⁻ x, ‖f x‖₊ ∂μ = ∫⁻ x, ENNReal.ofReal (f x) ∂μ
-- Mathlib/Data/Stream/Init.lean
theorem tail_zip (s₁ : Stream' α) (s₂ : Stream' β) :
    tail (zip f s₁ s₂) = zip f (tail s₁) (tail s₂)
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem mem_powerset {s t : Multiset α} : s ∈ powerset t ↔ s ≤ t
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability]
theorem measurableSet_eball : MeasurableSet (EMetric.ball x ε)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem testBit_mod_two_pow (x j i : Nat) :
    testBit (x % 2^j) i = (decide (i < j) && testBit x i)
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem mk_X : mk f X = root f
-- Mathlib/FieldTheory/Adjoin.lean
/-- Adjoining a finite subset is compact in the lattice of intermediate fields. -/
theorem adjoin_finset_isCompactElement (S : Finset E) :
    IsCompactElement (adjoin F S : IntermediateField F E)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem I_pow_four : I ^ 4 = 1
-- Mathlib/Topology/Algebra/Polynomial.lean
theorem exists_forall_norm_le [ProperSpace R] (p : R[X]) : ∃ x, ∀ y, ‖p.eval x‖ ≤ ‖p.eval y‖
-- Mathlib/GroupTheory/PGroup.lean
theorem to_subgroup (H : Subgroup G) : IsPGroup p H
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Function.comp_def {α β δ} (f : β → δ) (g : α → β) : f ∘ g = fun x => f (g x)
-- Mathlib/ModelTheory/Semantics.lean
theorem realize_constantsVarsEquiv [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
    {n} {φ : L[[α]].BoundedFormula β n} {v : β → M} {xs : Fin n → M} :
    (constantsVarsEquiv φ).Realize (Sum.elim (fun a => ↑(L.con a)) v) xs ↔ φ.Realize v xs
-- Mathlib/Topology/Filter.lean
@[simp]
theorem nhds_principal (s : Set α) : 𝓝 (𝓟 s) = 𝓟 (Iic (𝓟 s))
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem HasStrictFDerivAt.sub (hf : HasStrictFDerivAt f f' x) (hg : HasStrictFDerivAt g g' x) :
    HasStrictFDerivAt (fun x => f x - g x) (f' - g') x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem add_right_inj_of_lt_aleph0 {α β γ : Cardinal} (γ₀ : γ < aleph0) : α + γ = β + γ ↔ α = β
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- The mean value theorem on a convex set in dimension 1: if the derivative of a function is
bounded by `C`, then the function is `C`-Lipschitz. Version with `deriv`. -/
theorem norm_image_sub_le_of_norm_deriv_le {C : ℝ} (hf : ∀ x ∈ s, DifferentiableAt 𝕜 f x)
    (bound : ∀ x ∈ s, ‖deriv f x‖ ≤ C) (hs : Convex ℝ s) (xs : x ∈ s) (ys : y ∈ s) :
    ‖f y - f x‖ ≤ C * ‖y - x‖
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
theorem compress_of_disjoint_of_le (hua : Disjoint u a) (hva : v ≤ a) :
    compress u v a = (a ⊔ u) \ v
-- Mathlib/Topology/Instances/AddCircle.lean
theorem equivIccQuot_comp_mk_eq_toIocMod :
    equivIccQuot p a ∘ Quotient.mk'' = fun x =>
      Quot.mk _ ⟨toIocMod hp.out a x, Ioc_subset_Icc_self <| toIocMod_mem_Ioc _ _ x⟩
-- Mathlib/Algebra/CharP/Basic.lean
theorem sub_pow_char_pow [CommRing R] {p : ℕ} [Fact p.Prime] [CharP R p] {n : ℕ} (x y : R) :
    (x - y) ^ p ^ n = x ^ p ^ n - y ^ p ^ n
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp (high)]
protected theorem mul (q r : ℚ_[p]) : ‖q * r‖ = ‖q‖ * ‖r‖
-- Mathlib/Data/Set/Pairwise/Basic.lean
/-- See also `Function.injective_iff_pairwise_ne` -/
lemma injOn_iff_pairwise_ne {s : Set ι} : InjOn f s ↔ s.Pairwise (f · ≠ f ·)
-- Mathlib/Algebra/GeomSum.lean
theorem Nat.geom_sum_le {b : ℕ} (hb : 2 ≤ b) (a n : ℕ) :
    ∑ i ∈ range n, a / b ^ i ≤ a * b / (b - 1)
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toDFinsupp_union (s t : Multiset α) : toDFinsupp (s ∪ t) = toDFinsupp s ⊔ toDFinsupp t
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_sub_const_Ioi : (fun x => x - a) ⁻¹' Ioi b = Ioi (b + a)
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
lemma cpow_nat_mul (x : ℂ) (n : ℕ) (y : ℂ) : x ^ (n * y) = (x ^ y) ^ n
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
/-- If `f` is a smooth partition of unity on a set `s : Set M` and `g : ι → M → F` is a family of
functions such that `g i` is smooth at every point of the topological support of `f i`, then the sum
`fun x ↦ ∑ᶠ i, f i x • g i x` is smooth on the whole manifold. -/
theorem smooth_finsum_smul {g : ι → M → F}
    (hg : ∀ (i), ∀ x ∈ tsupport (f i), SmoothAt I 𝓘(ℝ, F) (g i) x) :
    Smooth I 𝓘(ℝ, F) fun x => ∑ᶠ i, f i x • g i x
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a ≤ f b ↔ a ≤ b
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
theorem counit_tensorObj :
    Coalgebra.counit (R := R) (A := (CoalgebraCat.of R M ⊗ CoalgebraCat.of R N : CoalgebraCat R))
      = Coalgebra.counit (A := M ⊗[R] N)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem ofPrime_valuation_eq_one_iff_mem_primeCompl (A : ValuationSubring K) (P : Ideal A)
    [P.IsPrime] (x : A) : (ofPrime A P).valuation x = 1 ↔ x ∈ P.primeCompl
-- Mathlib/Data/FunLike/Equiv.lean
protected theorem bijective (e : E) : Function.Bijective (e : α → β)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem empty_subset (x : PSet.{u}) : (∅ : PSet) ⊆ x
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
protected theorem Perm.symm {l₁ l₂ : List α} (h : l₁ ~ l₂) : l₂ ~ l₁
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability]
theorem measurable_ereal_toReal : Measurable EReal.toReal
-- Mathlib/Topology/Order/LeftRightLim.lean
theorem rightLim_eq_of_eq_bot [TopologicalSpace α] [OrderTopology α] (f : α → β) {a : α}
    (h : 𝓝[>] a = ⊥) : rightLim f a = f a
-- Mathlib/RingTheory/Binomial.lean
theorem choose_one_right [NatPowAssoc R] (r : R) : choose r 1 = r
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem false_or (p : Prop) : (False ∨ p) = p