ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/CofilteredSystem.lean
/-- If `F` is nonempty at each index and Mittag-Leffler, then so is `F.toEventualRanges`. -/
theorem toEventualRanges_nonempty (h : F.IsMittagLeffler) [∀ j : J, Nonempty (F.obj j)] (j : J) :
    Nonempty (F.toEventualRanges.obj j)
-- Mathlib/RingTheory/Derivation/Basic.lean
theorem add_apply : (D1 + D2) a = D1 a + D2 a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_intro (h : ∀ s, MeasurableSet s → s.Nonempty → μ₁ s ≤ μ₂ s) : μ₁ ≤ μ₂
-- Mathlib/Topology/Filter.lean
@[simp]
theorem nhds_top : 𝓝 (⊤ : Filter α) = ⊤
-- Mathlib/CategoryTheory/Generator.lean
theorem IsCoseparating.mono {𝒢 : Set C} (h𝒢 : IsCoseparating 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsCoseparating ℋ
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
@[to_additive]
theorem mono_iff_injective : Mono f ↔ Function.Injective f
-- Mathlib/CategoryTheory/Monad/Algebra.lean
@[simp]
theorem id_f (A : Coalgebra G) : (𝟙 A : A ⟶ A).f = 𝟙 A.A
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem translationNumber_lt_of_forall_lt_add (hf : Continuous f) {z : ℝ} (hz : ∀ x, f x < x + z) :
    τ f < z
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
theorem AnalyticAt.differentiableAt : AnalyticAt 𝕜 f x → DifferentiableAt 𝕜 f x
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem mem_mk {S : Subsemiring R} {x : R} (h) : x ∈ (⟨S, h⟩ : Subring R) ↔ x ∈ S
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
theorem mkDerivationₗ_C (f : σ → A) (r : R) : mkDerivationₗ R f (C r) = 0
-- Mathlib/Algebra/Order/Floor.lean
theorem fract_add_fract_le (a b : α) : fract a + fract b ≤ fract (a + b) + 1
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem IsTrail.count_edges_eq_one [DecidableEq V] {u v : V} {p : G.Walk u v} (h : p.IsTrail)
    {e : Sym2 V} (he : e ∈ p.edges) : p.edges.count e = 1
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `u` is a family of uniform structures on `γ`, then
`𝒱(α, γ, 𝔖, (⨅ i, u i)) = ⨅ i, 𝒱(α, γ, 𝔖, u i)`. -/
protected theorem iInf_eq {u : ι → UniformSpace γ} :
    𝒱(α, γ, 𝔖, ⨅ i, u i) = ⨅ i, 𝒱(α, γ, 𝔖, u i)
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.comp {g : β → γ} {f : α → β} {s : Set α} {t : Set β} (hg : ContinuousOn g t)
    (hf : ContinuousOn f s) (h : MapsTo f s t) : ContinuousOn (g ∘ f) s
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma coeff_Ψ₂Sq_ne_zero (h : (4 : R) ≠ 0) : W.Ψ₂Sq.coeff 3 ≠ 0
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem emptyGraph_eq_bot (V : Type u) : emptyGraph V = ⊥
-- Mathlib/Order/Filter/NAry.lean
/-- If `a` is a left identity for `f : α → β → β`, then `pure a` is a left identity for
`Filter.map₂ f`. -/
theorem map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (l : Filter β) :
    map₂ f (pure a) l = l
-- Mathlib/Topology/Partial.lean
theorem open_dom_of_pcontinuous {f : X →. Y} (h : PContinuous f) : IsOpen f.Dom
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
theorem preErgodic_of_preErgodic_conjugate (hg : MeasurePreserving g μ μ') (hf : PreErgodic f μ)
    {f' : β → β} (h_comm : g ∘ f = f' ∘ g) : PreErgodic f' μ'
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[nolint unusedHavesSuffices] -- false positive from unfolding String.findAux
theorem findAux_of_valid (p) : ∀ l m r,
    findAux ⟨l ++ m ++ r⟩ p ⟨utf8Len l + utf8Len m⟩ ⟨utf8Len l⟩ =
    ⟨utf8Len l + utf8Len (m.takeWhile (!p ·))⟩
-- Mathlib/Topology/UrysohnsLemma.lean
/-- Urysohn's lemma: if `s` and `t` are two disjoint sets in a regular locally compact topological
space `X`, with `s` compact and `t` closed, then there exists a continuous
function `f : X → ℝ` such that

* `f` equals zero on `s`;
* `f` equals one on `t`;
* `0 ≤ f x ≤ 1` for all `x`.
-/
theorem exists_continuous_zero_one_of_isCompact [RegularSpace X] [LocallyCompactSpace X]
    {s t : Set X} (hs : IsCompact s) (ht : IsClosed t) (hd : Disjoint s t) :
    ∃ f : C(X, ℝ), EqOn f 0 s ∧ EqOn f 1 t ∧ ∀ x, f x ∈ Icc (0 : ℝ) 1
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem mem_univ (x : α) : x ∈ (univ : Finset α)
-- Mathlib/Topology/Algebra/Algebra.lean
theorem mul_def (f g : A →A[R] A) : f * g = f.comp g
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem mem_intrinsicFrontier :
    x ∈ intrinsicFrontier 𝕜 s ↔ ∃ y, y ∈ frontier ((↑) ⁻¹' s : Set <| affineSpan 𝕜 s) ∧ ↑y = x
-- Mathlib/Algebra/BigOperators/RingEquiv.lean
protected theorem map_list_sum [NonAssocSemiring R] [NonAssocSemiring S] (f : R ≃+* S)
    (l : List R) : f l.sum = (l.map f).sum
-- Mathlib/Order/LiminfLimsup.lean
theorem blimsup_eq : blimsup u f p = sInf { a | ∀ᶠ x in f, p x → u x ≤ a }
-- Mathlib/SetTheory/Game/Short.lean
theorem short_birthday (x : PGame.{u}) : [Short x] → x.birthday < Ordinal.omega
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem get?_set_ne (a : Array α) (i : Fin a.size) {j : Nat} (v : α)
    (h : i.1 ≠ j) : (a.set i v)[j]? = a[j]?
-- Mathlib/RepresentationTheory/Rep.lean
@[simp]
theorem ihom_ev_app_hom (A B : Rep k G) :
    Action.Hom.hom ((ihom.ev A).app B)
      = TensorProduct.uncurry k A (A →ₗ[k] B) B LinearMap.id.flip
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
/-- Linear lower bound for `f (x + n)` on unit interval -/
theorem f_add_nat_ge (hf_conv : ConvexOn ℝ (Ioi 0) f)
    (hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y) (hn : 2 ≤ n) (hx : 0 < x) :
    f n + x * log (n - 1) ≤ f (n + x)
-- Mathlib/Algebra/Order/Field/Basic.lean
/-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_lt_one_div (ha : 0 < a) (hb : 0 < b) : 1 / a < 1 / b ↔ b < a
-- Mathlib/Data/Finset/Basic.lean
@[simp] theorem subset_insert (a : α) (s : Finset α) : s ⊆ insert a s
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem coe_eq_zero (z : ℤ_[p]) : (z : ℚ_[p]) = 0 ↔ z = 0
-- Mathlib/Topology/Order/Monotone.lean
/-- A monotone map has a limit to the left of any point `x`, equal to `sSup (f '' (Iio x))`. -/
theorem Monotone.tendsto_nhdsWithin_Iio {α β : Type*} [LinearOrder α] [TopologicalSpace α]
    [OrderTopology α] [ConditionallyCompleteLinearOrder β] [TopologicalSpace β] [OrderTopology β]
    {f : α → β} (Mf : Monotone f) (x : α) : Tendsto f (𝓝[<] x) (𝓝 (sSup (f '' Iio x)))
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem _root_.ContinuousLinearMap.intervalIntegral_comp_comm (L : E →L[𝕜] F)
    (hf : IntervalIntegrable f μ a b) : (∫ x in a..b, L (f x) ∂μ) = L (∫ x in a..b, f x ∂μ)
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem stronglyMeasurable_deriv [MeasurableSpace 𝕜] [OpensMeasurableSpace 𝕜]
    [h : SecondCountableTopologyEither 𝕜 F] (f : 𝕜 → F) : StronglyMeasurable (deriv f)
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_mul_cpow_one_add_sq {t : ℂ} (ht : t ≠ -1) :
    (∫ x : ℝ in a..b, (x : ℂ) * ((1 : ℂ) + ↑x ^ 2) ^ t) =
      ((1 : ℂ) + (b : ℂ) ^ 2) ^ (t + 1) / (2 * (t + ↑1)) -
      ((1 : ℂ) + (a : ℂ) ^ 2) ^ (t + 1) / (2 * (t + ↑1))
-- Mathlib/NumberTheory/Dioph.lean
theorem abs_poly_dioph (p : Poly α) : DiophFn fun v => (p v).natAbs
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualCoannihilator_iSup_eq {ι : Sort*} (U : ι → Submodule R (Module.Dual R M)) :
    (⨆ i : ι, U i).dualCoannihilator = ⨅ i : ι, (U i).dualCoannihilator
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
/-- Rewrite the Gamma integral as an example of a Mellin transform. -/
theorem GammaIntegral_eq_mellin : GammaIntegral = mellin fun x => ↑(Real.exp (-x))
-- Mathlib/Topology/Filter.lean
@[continuity]
theorem continuous_nhds : Continuous (𝓝 : X → Filter X)
-- Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean
lemma sum_smul_minpolyDiv_eq_X_pow (E) [Field E] [Algebra K E] [IsAlgClosed E]
    [FiniteDimensional K L] [Algebra.IsSeparable K L]
    {x : L} (hxL : Algebra.adjoin K {x} = ⊤) {r : ℕ} (hr : r < finrank K L) :
    ∑ σ : L →ₐ[K] E, ((x ^ r / aeval x (derivative <| minpoly K x)) •
      minpolyDiv K x).map σ = (X ^ r : E[X])
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem restriction_one : restriction (1 : R[X]) = 1
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotation in an oriented real inner product space of dimension 2 can be evaluated in terms of a
complex-number representation of the space. -/
theorem rotation_map_complex (θ : Real.Angle) (f : V ≃ₗᵢ[ℝ] ℂ)
    (hf : Orientation.map (Fin 2) f.toLinearEquiv o = Complex.orientation) (x : V) :
    f (o.rotation θ x) = θ.expMapCircle * f x
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem closedBall_eq_image (x : E) (r : ℝ) :
    closedBall x r = toEuclidean.symm '' Metric.closedBall (toEuclidean x) r
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_modEq_x2n_add_lem (n j) : xn a1 n ∣ d a1 * yn a1 n * (yn a1 n * xn a1 j) + xn a1 j
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem embDomain_eq_zero {f : α ↪ β} {l : α →₀ M} : embDomain f l = 0 ↔ l = 0
-- Mathlib/Topology/Connected/Basic.lean
/-- A union of a family of preconnected sets with a common point is preconnected as well. -/
theorem isPreconnected_sUnion (x : α) (c : Set (Set α)) (H1 : ∀ s ∈ c, x ∈ s)
    (H2 : ∀ s ∈ c, IsPreconnected s) : IsPreconnected (⋃₀ c)
-- Mathlib/Computability/TuringMachine.lean
theorem trTape'_move_right (L R : ListBlank Γ) :
    (Tape.move Dir.right)^[n] (trTape' enc0 L R) = trTape' enc0 (L.cons R.head) R.tail
-- Mathlib/Algebra/Algebra/Hom.lean
theorem comp_toRingHom (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) :
    (φ₁.comp φ₂ : A →+* C) = (φ₁ : B →+* C).comp ↑φ₂
-- Mathlib/Data/Opposite.lean
@[simp]
theorem op_unop (x : αᵒᵖ) : op (unop x) = x
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_counitIso_inv_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    f ≫ (opShiftFunctorEquivalence C n).counitIso.inv.app Y =
      (opShiftFunctorEquivalence C n).counitIso.inv.app X ≫ f.unop⟦n⟧'.op⟦n⟧'
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- If `P` is a prime ideal of `R`, then `P.R[x]` is a prime ideal of `R[x]`. -/
theorem isPrime_map_C_of_isPrime {P : Ideal R} (H : IsPrime P) :
    IsPrime (map (C : R →+* R[X]) P : Ideal R[X])
-- Mathlib/Data/Set/Function.lean
theorem antitoneOn_of_rightInvOn_of_mapsTo [PartialOrder α] [LinearOrder β]
    {φ : β → α} {ψ : α → β} {t : Set β} {s : Set α} (hφ : AntitoneOn φ t)
    (φψs : Set.RightInvOn ψ φ s) (ψts : Set.MapsTo ψ s t) : AntitoneOn ψ s
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- The integral of `sin x * cos x`, given in terms of sin².
  See `integral_sin_mul_cos₂` below for the integral given in terms of cos². -/
@[simp]
theorem integral_sin_mul_cos₁ : ∫ x in a..b, sin x * cos x = (sin b ^ 2 - sin a ^ 2) / 2
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
protected theorem map_smul (c : ℝ≥0∞) (μ : Measure α) (f : α → β) :
    (c • μ).map f = c • μ.map f
-- Mathlib/Analysis/Seminorm.lean
theorem ball_smul_ball (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) :
    Metric.ball (0 : 𝕜) r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂)
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_subtype (p : α → Prop) (s : { x // p x } → Set β) :
    ⋂ x : { x // p x }, s x = ⋂ (x) (hx : p x), s ⟨x, hx⟩
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp]
theorem comp_id : φ.comp (AlgHom.id R A) = φ
-- Mathlib/ModelTheory/Definability.lean
@[simp]
theorem Definable.sdiff {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t) :
    A.Definable L (s \ t)
-- Mathlib/Data/Nat/Prime/Basic.lean
/-- A prime `p` satisfies `p % 2 = 1` if and only if `p ≠ 2`. -/
theorem Prime.mod_two_eq_one_iff_ne_two {p : ℕ} [Fact p.Prime] : p % 2 = 1 ↔ p ≠ 2
-- Mathlib/Order/Basic.lean
@[simp]
lemma ltByCases_eq (h : x = y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
    ltByCases x y h₁ h₂ h₃ = h₂ h
-- Mathlib/Order/Hom/Basic.lean
theorem le_def {f g : α →o β} : f ≤ g ↔ ∀ x, f x ≤ g x
-- Mathlib/Analysis/Normed/Module/Dual.lean
@[simp]
theorem polar_closure (s : Set E) : polar 𝕜 (closure s) = polar 𝕜 s
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
theorem Embedding.isTotallyDisconnected [TopologicalSpace β] {f : α → β} (hf : Embedding f)
    {s : Set α} (h : IsTotallyDisconnected (f '' s)) : IsTotallyDisconnected s
-- Mathlib/Data/Set/MemPartition.lean
lemma memPartition_succ (f : ℕ → Set α) (n : ℕ) :
    memPartition f (n + 1) = {s | ∃ u ∈ memPartition f n, s = u ∩ f n ∨ s = u \ f n}
-- Mathlib/CategoryTheory/Abelian/RightDerived.lean
lemma InjectiveResolution.toRightDerivedZero_eq
    {X : C} (I : InjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    F.toRightDerivedZero.app X = I.toRightDerivedZero' F ≫
      (CochainComplex.isoHomologyπ₀ _).hom ≫ (I.isoRightDerivedObj F 0).inv
-- Mathlib/Analysis/Calculus/FDeriv/Star.lean
@[simp]
theorem differentiableOn_star_iff :
    DifferentiableOn 𝕜 (fun y => star (f y)) s ↔ DifferentiableOn 𝕜 f s
-- Mathlib/Combinatorics/Additive/Energy.lean
@[to_additive card_sq_le_card_mul_addEnergy]
lemma card_sq_le_card_mul_mulEnergy (s t u : Finset α) :
    ((s ×ˢ t).filter fun (a, b) ↦ a * b ∈ u).card ^ 2 ≤ u.card * Eₘ[s, t]
-- Mathlib/Init/Logic.lean
theorem true_iff_iff : (True ↔ a) ↔ a
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem isImage_preimage_prod (e : Trivialization F proj) (s : Set B) :
    e.toPartialHomeomorph.IsImage (proj ⁻¹' s) (s ×ˢ univ)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma nonsingular_negAdd_of_eval_derivative_ne_zero {x₁ x₂ y₁ L : R}
    (hx' : W.Equation (W.addX x₁ x₂ L) (W.negAddY x₁ x₂ y₁ L))
    (hx : (W.addPolynomial x₁ y₁ L).derivative.eval (W.addX x₁ x₂ L) ≠ 0) :
    W.Nonsingular (W.addX x₁ x₂ L) (W.negAddY x₁ x₂ y₁ L)
-- Mathlib/Data/Set/Prod.lean
theorem univ_pi_nonempty_iff : (pi univ t).Nonempty ↔ ∀ i, (t i).Nonempty
-- Mathlib/Data/Set/Function.lean
lemma restrictPreimage_injective (hf : Injective f) : Injective (t.restrictPreimage f)
-- Mathlib/Order/RelSeries.lean
lemma append_apply_left (p q : RelSeries r) (connect : r p.last q.head)
    (i : Fin (p.length + 1)) :
    p.append q connect ((i.castAdd (q.length + 1)).cast (by dsimp; abel)) = p i
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem decide_true_eq  {b : Bool} [Decidable (true = b)]  : decide (true  = b) =  b
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem sizeUpTo_zero : c.sizeUpTo 0 = 0
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem isClosedMap_mul_right (a : G) : IsClosedMap (· * a)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- `AlternatingMap.curryLeft` as a `LinearMap`. This is a separate definition as dot notation
does not work for this version. -/
@[simps]
def curryLeftLinearMap {n : ℕ} :
    (M'' [⋀^Fin n.succ]→ₗ[R'] N'') →ₗ[R'] M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N''
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- The sum of a nontrivial subgroup of the units of a field is zero. -/
theorem sum_subgroup_units_eq_zero [Ring K] [NoZeroDivisors K]
    {G : Subgroup Kˣ} [Fintype G] (hg : G ≠ ⊥) :
    ∑ x : G, (x.val : K) = 0
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_symm (x y : E) : openSegment 𝕜 x y = openSegment 𝕜 y x
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasStrictDerivAt.const_cpow (hf : HasStrictDerivAt f f' x) (h : c ≠ 0 ∨ f x ≠ 0) :
    HasStrictDerivAt (fun x => c ^ f x) (c ^ f x * Complex.log c * f') x
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
@[simp]
theorem measure_Icc (a b : ℝ) : f.measure (Icc a b) = ofReal (f b - leftLim f a)
-- Mathlib/ModelTheory/Definability.lean
@[simp, norm_cast]
theorem coe_top : ((⊤ : L.DefinableSet A α) : Set (α → M)) = univ
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem inf_apply (f g : InfTopHom α β) (a : α) : (f ⊓ g) a = f a ⊓ g a
-- Mathlib/GroupTheory/SpecificGroups/Alternating.lean
theorem isConj_of {σ τ : alternatingGroup α} (hc : IsConj (σ : Perm α) (τ : Perm α))
    (hσ : (σ : Perm α).support.card + 2 ≤ Fintype.card α) : IsConj σ τ
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_mono_ae (h : s ≤ᵐ[μ] t) : μ.restrict s ≤ μ.restrict t
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
@[ext]
theorem ModelProd.ext {x y : ModelProd H H'} (h₁ : x.1 = y.1) (h₂ : x.2 = y.2) : x = y
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem vaddConst_toAffineEquiv (p : P) :
    (vaddConst 𝕜 p).toAffineEquiv = AffineEquiv.vaddConst 𝕜 p
-- Mathlib/Data/Nat/Defs.lean
lemma sqrt_le_add (n : ℕ) : n ≤ sqrt n * sqrt n + sqrt n + sqrt n
-- Mathlib/Algebra/MvPolynomial/Supported.lean
theorem supported_mono (st : s ⊆ t) : supported R s ≤ supported R t
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
theorem comp_def (f : M ⟶ N) (g : N ⟶ U) : f ≫ g = g.comp f
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem formPerm_eq_self_of_not_mem (s : Cycle α) (h : Nodup s) (x : α) (hx : x ∉ s) :
    formPerm s h x = x
-- Mathlib/Order/GaloisConnection.lean
theorem strictMono_l [Preorder α] [Preorder β] (gi : GaloisCoinsertion l u) : StrictMono l
-- Mathlib/MeasureTheory/Constructions/EventuallyMeasurable.lean
/-- A function which is `EventuallyEq` to some `EventuallyMeasurable` function
is `EventuallyMeasurable`.-/
theorem EventuallyMeasurable.congr
    (hf : EventuallyMeasurable m l f) (hgf : g =ᶠ[l] f) : EventuallyMeasurable m l g
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsRelPrime.of_prod_right (H1 : IsRelPrime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t) :
    IsRelPrime x (s i)
-- Mathlib/Order/Filter/FilterProduct.lean
theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem add_lt_add {a b c d : Nat} (h₁ : a < b) (h₂ : c < d) : a + c < b + d
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem symmDiff_nonempty : (s ∆ t).Nonempty ↔ s ≠ t
-- Mathlib/Data/Real/EReal.lean
@[simp] theorem abs_top : (⊤ : EReal).abs = ⊤
-- Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean
theorem integral_comp_inv_mul_left (g : ℝ → F) (a : ℝ) :
    (∫ x : ℝ, g (a⁻¹ * x)) = |a| • ∫ y : ℝ, g y
-- Mathlib/Logic/Nonempty.lean
theorem Nonempty.imp {α} {p : Prop} : (Nonempty α → p) ↔ (α → p)
-- Mathlib/Topology/AlexandrovDiscrete.lean
@[simp] lemma exterior_eq_empty : exterior s = ∅ ↔ s = ∅
-- Mathlib/Algebra/Divisibility/Units.lean
/-- In a commutative monoid, an element `a` divides an element `b` iff all
  left associates of `a` divide `b`. -/
@[simp]
theorem mul_left_dvd (hu : IsUnit u) : u * a ∣ b ↔ a ∣ b
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem count_some (hp : Irreducible p) (s : Multiset _) :
    count p (WithTop.some s) = s.count ⟨p, hp⟩
-- Mathlib/Data/Sigma/Basic.lean
@[simp]
theorem Prod.fst_comp_toSigma {α β} : Sigma.fst ∘ @Prod.toSigma α β = Prod.fst
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem union_cylinder (s₁ s₂ : Finset ι) (S₁ : Set (∀ i : s₁, α i)) (S₂ : Set (∀ i : s₂, α i))
    [DecidableEq ι] :
    cylinder s₁ S₁ ∪ cylinder s₂ S₂ =
      cylinder (s₁ ∪ s₂)
        ((fun f ↦ fun j : s₁ ↦ f ⟨j, Finset.mem_union_left s₂ j.prop⟩) ⁻¹' S₁ ∪
          (fun f ↦ fun j : s₂ ↦ f ⟨j, Finset.mem_union_right s₁ j.prop⟩) ⁻¹' S₂)
-- Mathlib/Order/Monotone/Basic.lean
theorem update_strictMono : StrictMono (update f i)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
lemma bounded (hf : IsCauSeq abv f) : ∃ r, ∀ i, abv (f i) < r
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_nonneg (hab : a ≤ b) (hf : ∀ u, u ∈ Icc a b → 0 ≤ f u) : 0 ≤ ∫ u in a..b, f u ∂μ
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_def : s.inf f = (s.1.map f).inf
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem op_iInf (S : ι → Submonoid M) : (iInf S).op = ⨅ i, (S i).op
-- .lake/packages/aesop/Aesop/BuiltinRules.lean
@[aesop (rule_sets := [builtin]) norm destruct]
theorem pEmpty_false (h : PEmpty) : False
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
/-- See also `continuousAt_cpow_const` for a version that assumes `z ≠ 0` but makes no
assumptions about `w`. -/
theorem continuousAt_cpow_const_of_re_pos {z w : ℂ} (hz : 0 ≤ re z ∨ im z ≠ 0) (hw : 0 < re w) :
    ContinuousAt (fun x => x ^ w) z
-- Mathlib/Data/Set/Lattice.lean
theorem surjOn_iUnion {s : Set α} {t : ι → Set β} {f : α → β} (H : ∀ i, SurjOn f s (t i)) :
    SurjOn f s (⋃ i, t i)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
/-- $aba^{-1}$ is a vector. -/
theorem ι_mul_ι_mul_invOf_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
    ι Q a * ι Q b * ⅟ (ι Q a) = ι Q ((⅟ (Q a) * QuadraticMap.polar Q a b) • a - b)
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem restrictScalars_closedBall (p : Seminorm 𝕜' E) :
    (p.restrictScalars 𝕜).closedBall = p.closedBall
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma ι_totalShift₂Iso_hom_f (a b n : ℤ) (h : a + b = n) (b' : ℤ) (hb' : b' = b + y)
    (n' : ℤ) (hn' : n' = n + y) :
    ((shiftFunctor₂ C y).obj K).ιTotal (up ℤ) a b n h ≫ (K.totalShift₂Iso y).hom.f n =
      (a * y).negOnePow • (K.shiftFunctor₂XXIso a b y b' hb').hom ≫
        K.ιTotal (up ℤ) a b' n' (by dsimp; omega) ≫
          (CochainComplex.shiftFunctorObjXIso (K.total (up ℤ)) y n n' hn').inv
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
    ∃ i : ℕ, 0 < i ∧ i ≤ orderOf f ∧ (f ^ i) x = y
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem π_tensor_id_preserves_coequalizer_inv_colimMap_desc {X Y Z X' Y' Z' : C} (f g : X ⟶ Y)
    (f' g' : X' ⟶ Y') (p : X ⊗ Z ⟶ X') (q : Y ⊗ Z ⟶ Y') (wf : (f ▷ Z) ≫ q = p ≫ f')
    (wg : (g ▷ Z) ≫ q = p ≫ g') (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h) :
    (coequalizer.π f g ▷ Z) ≫
        (PreservesCoequalizer.iso (tensorRight Z) f g).inv ≫
          colimMap (parallelPairHom (f ▷ Z) (g ▷ Z) f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem hasGradientWithinAt_iff_tendsto :
    HasGradientWithinAt f f' s x ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - ⟪f', x' - x⟫‖) (𝓝[s] x) (𝓝 0)
-- Mathlib/MeasureTheory/Function/UnifTight.lean
/-- Convergence in Lp implies uniform tightness. -/
private theorem unifTight_of_tendsto_Lp (hp' : p ≠ ∞) (hf : ∀ n, Memℒp (f n) p μ)
    (hg : Memℒp g p μ) (hfg : Tendsto (fun n => eLpNorm (f n - g) p μ) atTop (𝓝 0)) :
    UnifTight f p μ
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
lemma greatestFib_sub_fib_greatestFib_le_greatestFib (hn : n ≠ 0) :
    greatestFib (n - fib (greatestFib n)) ≤ greatestFib n - 2
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
@[simp]
theorem foldr_one (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) : foldr Q f hf n 1 = n
-- Mathlib/Algebra/Ring/Equiv.lean
protected theorem congr_fun {f g : R ≃+* S} (h : f = g) (x : R) : f x = g x
-- Mathlib/Data/Set/Function.lean
theorem injOn (h : LeftInvOn f₁' f s) : InjOn f s
-- Mathlib/RingTheory/Derivation/Basic.lean
theorem coe_injective : @Function.Injective (Derivation R A M) (A → M) DFunLike.coe
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_eq : limsup u f = sInf { a | ∀ᶠ n in f, u n ≤ a }
-- Mathlib/Topology/Order/PartialSups.lean
protected lemma ContinuousAt.partialSups_apply (hf : ∀ k ≤ n, ContinuousAt (f k) x) :
    ContinuousAt (fun a ↦ partialSups (f · a) n) x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem hasStrictDerivAt_sinh (x : ℝ) : HasStrictDerivAt sinh (cosh x) x
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem ker_map (f : R →+* S) :
    RingHom.ker (map f : MvPolynomial σ R →+* MvPolynomial σ S) =
    Ideal.map (C : R →+* MvPolynomial σ R) (RingHom.ker f)
-- Mathlib/RingTheory/Noetherian.lean
/-- If `M ⊕ N` embeds into `M`, for `M` noetherian over `R`, then `N` is trivial. -/
theorem IsNoetherian.subsingleton_of_prod_injective (f : M × N →ₗ[R] M)
    (i : Injective f) : Subsingleton N
-- Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean
theorem exists_hasEigenvalue_of_iSup_genEigenspace_eq_top [Nontrivial M] {f : End R M}
    (hf : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤) :
    ∃ μ, f.HasEigenvalue μ
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
@[simp]
theorem ε_hom_inv_id : F.ε ≫ F.εIso.inv = 𝟙 _
-- Mathlib/NumberTheory/Pell.lean
@[simp]
theorem x_inv (a : Solution₁ d) : a⁻¹.x = a.x