ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.imp_iff_right_iff [Decidable a] : (a → b ↔ b) ↔ a ∨ b
-- Mathlib/Order/Max.lean
theorem Prod.isTop_iff : IsTop x ↔ IsTop x.1 ∧ IsTop x.2
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem nnnorm_def : ‖f‖₊ = nndist f 0
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
/-- Given a family of `n` linearly independent vectors in a space of dimension `> n`, one may extend
the family by another vector while retaining linear independence. -/
theorem exists_linearIndependent_cons_of_lt_rank [StrongRankCondition R] {n : ℕ} {v : Fin n → M}
    (hv : LinearIndependent R v) (h : n < Module.rank R M) :
    ∃ (x : M), LinearIndependent R (Fin.cons x v)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem zero_le {_m0 : MeasurableSpace α} (μ : Measure α) : 0 ≤ μ
-- Mathlib/Algebra/Homology/Augment.lean
@[simp]
theorem augmentTruncate_inv_f_succ (C : CochainComplex V ℕ) (i : ℕ) :
    (augmentTruncate C).inv.f (i + 1) = 𝟙 (C.X (i + 1))
-- Mathlib/Order/Hom/Basic.lean
/-- Constant function bundled as an `OrderHom`. -/
@[simps (config := .asFn)]
def const (α : Type*) [Preorder α] {β : Type*} [Preorder β] : β →o α →o β
-- Mathlib/Algebra/Module/CharacterModule.lean
/--
Any character `c` in `(A ⊗ B)⋆` induces a linear map `A → B⋆` by `a ↦ b ↦ c (a ⊗ b)`.
-/
@[simps] noncomputable def curry :
    CharacterModule (A ⊗[R] B) →ₗ[R] (A →ₗ[R] CharacterModule B)
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma image_coe_Iic (x : ℝ) : Real.toEReal '' Iic x = Ioc ⊥ ↑x
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem div_tendsto_leadingCoeff_div_of_degree_eq (hdeg : P.degree = Q.degree) :
    Tendsto (fun x => eval x P / eval x Q) atTop (𝓝 <| P.leadingCoeff / Q.leadingCoeff)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le_natAbs {a : Int} : a ≤ natAbs a
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean
theorem MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff {β : Type*}
    {f : α → β} {mα : MeasurableSpace α} {μa : Measure α} {mβ : MeasurableSpace β} {μb : Measure β}
    (hf : MeasurePreserving f μa μb) (h₂ : MeasurableEmbedding f) {g : β → γ} :
    AEStronglyMeasurable (g ∘ f) μa ↔ AEStronglyMeasurable g μb
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
@[simp]
theorem NormedAddGroupHom.completion_toCompl (f : NormedAddGroupHom G H) :
    f.completion.comp toCompl = toCompl.comp f
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
@[simp]
theorem coe_toContinuousLinearMap (φ : A →ₐ[𝕜] 𝕜) : ⇑φ.toContinuousLinearMap = φ
-- Mathlib/Order/InitialSeg.lean
theorem irrefl {r : α → α → Prop} [IsWellOrder α r] (f : r ≺i r) : False
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- If the angle between two vectors is π, the norm of their difference equals
the sum of their norms. -/
theorem norm_sub_eq_add_norm_of_angle_eq_pi {x y : V} (h : angle x y = π) :
    ‖x - y‖ = ‖x‖ + ‖y‖
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_mul_unit_left_left : IsCoprime (x * y) z ↔ IsCoprime y z
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
/-- The Stone-Weierstrass approximation theorem, `RCLike` version, that a star subalgebra `A` of
`C(X, 𝕜)`, where `X` is a compact topological space and `RCLike 𝕜`, is dense if it separates
points. -/
theorem ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints
    (A : StarSubalgebra 𝕜 C(X, 𝕜)) (hA : A.SeparatesPoints) : A.topologicalClosure = ⊤
-- Mathlib/Algebra/Lie/Submodule.lean
theorem ker_eq_bot : f.ker = ⊥ ↔ Function.Injective f
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem neg_iff_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) : a < 0 ↔ b < 0
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.lintegral_eq_of_tendsto [l.NeBot] [l.IsCountablyGenerated] {φ : ι → Set α}
    (hφ : AECover μ l φ) {f : α → ℝ≥0∞} (I : ℝ≥0∞) (hfm : AEMeasurable f μ)
    (htendsto : Tendsto (fun i => ∫⁻ x in φ i, f x ∂μ) l (𝓝 I)) : ∫⁻ x, f x ∂μ = I
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem aeStronglyMeasurable'_condexpL2 (hm : m ≤ m0) (f : α →₂[μ] E) :
    AEStronglyMeasurable' (β := E) m (condexpL2 E 𝕜 hm f) μ
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
@[simp]
theorem GammaIntegral_one : GammaIntegral 1 = 1
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem basisFun_map :
    (basisFun p 𝕜 ι).map (WithLp.linearEquiv p 𝕜 (ι → 𝕜)) = Pi.basisFun 𝕜 ι
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem colimit.pre_pre [h : HasColimit (D ⋙ E ⋙ F)] :
    haveI : HasColimit ((D ⋙ E) ⋙ F) := h
    colimit.pre (E ⋙ F) D ≫ colimit.pre F E = colimit.pre F (D ⋙ E)
-- Mathlib/Analysis/PSeries.lean
lemma Real.summable_one_div_nat_add_rpow (a : ℝ) (s : ℝ) :
    Summable (fun n : ℕ ↦ 1 / |n + a| ^ s) ↔ 1 < s
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem aeval_monomial (g : σ → S₁) (d : σ →₀ ℕ) (r : R) :
    aeval g (monomial d r) = algebraMap _ _ r * d.prod fun i k => g i ^ k
-- Mathlib/Data/TypeVec.lean
theorem comp_assoc {α β γ δ : TypeVec n} (h : γ ⟹ δ) (g : β ⟹ γ) (f : α ⟹ β) :
    (h ⊚ g) ⊚ f = h ⊚ g ⊚ f
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem UniformInducing.uniformContinuousOn_iff {f : α → β} {g : β → γ} {S : Set α}
    (hg : UniformInducing g) :
    UniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem taylor_one : taylor r (1 : R[X]) = C 1
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxFilter f l' a
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem ofDual_sSup (s : Set αᵒᵈ) : ofDual (sSup s) = sInf (toDual ⁻¹' s)
-- .lake/packages/batteries/Batteries/Data/HashMap/WF.lean
theorem erase_WF [BEq α] [Hashable α] {m : Imp α β} {k}
    (h : m.buckets.WF) : (erase m k).buckets.WF
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[to_additive]
theorem div_apply [Div β] (f g : α →ₛ β) (x : α) : (f / g) x = f x / g x
-- Mathlib/LinearAlgebra/Ray.lean
/-- `SameRay` is transitive unless the vector in the middle is zero and both other vectors are
nonzero. -/
theorem trans (hxy : SameRay R x y) (hyz : SameRay R y z) (hy : y = 0 → x = 0 ∨ z = 0) :
    SameRay R x z
-- Mathlib/Dynamics/PeriodicPts.lean
protected theorem mul_const (hm : IsPeriodicPt f m x) (n : ℕ) : IsPeriodicPt f (m * n) x
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_div_im (x y : ℤ[i]) : ((x / y : ℤ[i]) : ℂ).im = round (x / y : ℂ).im
-- Mathlib/RingTheory/FreeRing.lean
theorem of_injective : Function.Injective (of : α → FreeRing α)
-- Mathlib/RingTheory/Nullstellensatz.lean
@[simp]
theorem zeroLocus_bot : zeroLocus (⊥ : Ideal (MvPolynomial σ k)) = ⊤
-- Mathlib/CategoryTheory/Shift/Pullback.lean
lemma pullbackShiftFunctorAdd'_inv_app :
    (shiftFunctorAdd' _ a₁ a₂ a₃ h).inv.app X =
      (shiftFunctor (PullbackShift C φ) a₂).map ((pullbackShiftIso C φ a₁ b₁ h₁).hom.app X) ≫
        (pullbackShiftIso C φ a₂ b₂ h₂).hom.app _ ≫
        (shiftFunctorAdd' C b₁ b₂ b₃ (by rw [h₁, h₂, h₃, ← h, φ.map_add])).inv.app X ≫
        (pullbackShiftIso C φ a₃ b₃ h₃).inv.app X
-- Mathlib/Order/Antichain.lean
protected theorem subsingleton [IsTrichotomous α r] (h : IsAntichain r s) : s.Subsingleton
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} {S : ι → NonUnitalSubalgebra R A} :
    (↑(⨅ i, S i) : Set A) = ⋂ i, S i
-- Mathlib/CategoryTheory/Bicategory/Functor/Lax.lean
@[reassoc]
lemma map₂_rightUnitor_hom {a b : B} (f : a ⟶ b) :
    (ρ_ (F.map f)).hom = F.map f ◁ F.mapId b ≫ F.mapComp f (𝟙 b) ≫ F.map₂ (ρ_ f).hom
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_insert_right [DecidableEq β] :
    image₂ f s (insert b t) = (s.image fun a => f a b) ∪ image₂ f s t
-- Mathlib/Data/Nat/Fib/Basic.lean
@[simp]
theorem fib_zero : fib 0 = 0
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem edist_equiv_symm_snd (y₁ y₂ : β) :
    edist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) =
      edist y₁ y₂
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem cond_true  {α : Type u} {a b : α} : cond true  a b = a
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_add_left_of_ge' (C : β) (hf : ∀ᶠ x in l, f x ≤ C) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- If `Irreducible (cyclotomic (2 ^ (k + 1)) K)` (in particular for `K = ℚ`), then the norm of
`ζ ^ (2 ^ k) - 1` is `(-2) ^ (2 ^ k)`. -/
-- Porting note: writing `(2 : ℕ+)` was not needed (similarly everywhere).
theorem norm_pow_sub_one_two {k : ℕ} (hζ : IsPrimitiveRoot ζ (2 ^ (k + 1)))
    [IsCyclotomicExtension {(2 : ℕ+) ^ (k + 1)} K L]
    (hirr : Irreducible (cyclotomic (2 ^ (k + 1)) K)) :
    norm K (ζ ^ 2 ^ k - 1) = (-2 : K) ^ 2 ^ k
-- Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean
@[reassoc (attr := simp)]
theorem homotopyEquiv_hom_π {X : C} (P Q : ProjectiveResolution X) :
    (homotopyEquiv P Q).hom ≫ Q.π = P.π
-- Mathlib/Algebra/Order/Module/Pointwise.lean
@[simp] lemma lowerBounds_smul_of_neg (ha : a < 0) : lowerBounds (a • s) = a • upperBounds s
-- Mathlib/Analysis/MellinTransform.lean
theorem mellin_comp_rpow (f : ℝ → E) (s : ℂ) (a : ℝ) :
    mellin (fun t => f (t ^ a)) s = |a|⁻¹ • mellin f (s / a)
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
theorem coordinate_eval_0 : (coordinate 0).eval (.ofList (a0 :: t)) = a0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem refl_mul (e : E ≃ₗᵢ[R] E) : refl _ _ * e = e
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem comap_snd : q.comap (snd R M M₂) = prod ⊤ q
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
/-- The length-1 path between a pair of adjacent vertices. -/
@[simps]
def singleton {u v : V} (h : G.Adj u v) : G.Path u v
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem sub_eq_add_neg (xs ys : Coeffs) : xs - ys = xs + -ys
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the sign of the angle between two vectors is positive, the first vector is nonzero. -/
theorem left_ne_zero_of_oangle_sign_eq_one {x y : V} (h : (o.oangle x y).sign = 1) : x ≠ 0
-- Mathlib/Algebra/Polynomial/Splits.lean
@[simp]
theorem splits_zero : Splits i (0 : K[X])
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma cyclesMap_neg : cyclesMap (-φ) = -cyclesMap φ
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fib_add_two_sub_fib_add_one {n : ℕ} : fib (n + 2) - fib (n + 1) = fib n
-- Mathlib/Combinatorics/Schnirelmann.lean
/--
For any natural `n`, the Schnirelmann density multiplied by `n` is bounded by `|A ∩ {1, ..., n}|`.
Note this property fails for the natural density.
-/
lemma schnirelmannDensity_mul_le_card_filter {n : ℕ} :
    schnirelmannDensity A * n ≤ ((Ioc 0 n).filter (· ∈ A)).card
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivAt.ccosh (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.cosh (f x)) (Complex.sinh (f x) • f') x
-- Mathlib/Order/GaloisConnection.lean
@[simp]
theorem bddAbove_preimage (e : α ≃o β) {s : Set β} : BddAbove (e ⁻¹' s) ↔ BddAbove s
-- Mathlib/Algebra/Jordan/Basic.lean
@[simp]
theorem commute_rmul_rmul_sq (a : A) : Commute (R a) (R (a * a))
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem fst_one [One R] [Zero A] : (1 : Unitization R A).fst = 1
-- Mathlib/GroupTheory/Perm/Support.lean
theorem pow_apply_eq_of_apply_apply_eq_self {x : α} (hffx : f (f x) = x) :
    ∀ n : ℕ, (f ^ n) x = x ∨ (f ^ n) x = f x
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem trichotomous_of [IsTrichotomous α r] : ∀ a b : α, a ≺ b ∨ a = b ∨ b ≺ a
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[reassoc (attr := simp, nolint simpNF)]
theorem obj_μ_inv_app (m₁ m₂ m₃ : M) (X : C) :
    (F.obj m₃).map ((F.μIso m₁ m₂).inv.app X) =
      (F.μ (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫
          (F.μIso m₁ (m₂ ⊗ m₃)).inv.app X ≫ (F.μIso m₂ m₃).inv.app ((F.obj m₁).obj X)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem sUnion_image (f : α → Set β) (s : Set α) : ⋃₀(f '' s) = ⋃ x ∈ s, f x
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Subgroup G) (x : G) :
    a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp)]
theorem elim_one_one [One γ] : Sum.elim (1 : α → γ) (1 : β → γ) = 1
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast] lemma imK_nnratCast (q : ℚ≥0) : (q : ℍ[R]).imK = 0
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem div_subst {α} [Field α] {n1 n2 k e1 e2 t1 : α}
    (h1 : n1 * e1 = t1) (h2 : n2 / e2 = 1) (h3 : n1 * n2 = k) : k * (e1 / e2) = t1
-- Mathlib/Topology/Maps/Basic.lean
theorem of_inverse {g : Y → X} (hf : Continuous f) (hg : Continuous g) (h : LeftInverse g f) :
    QuotientMap g
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSpace_le_of_countable_range (hτ : IsStoppingTime f τ)
    (h_countable : (Set.range τ).Countable) : hτ.measurableSpace ≤ m
-- Mathlib/Topology/MetricSpace/Closeds.lean
/-- The range of `NonemptyCompacts.toCloseds` is closed in a complete space -/
theorem NonemptyCompacts.isClosed_in_closeds [CompleteSpace α] :
    IsClosed (range <| @NonemptyCompacts.toCloseds α _ _)
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagramIso_app_left (i : D.J × D.J) :
    (D.diagramIso F).app (WalkingMultispan.left i) = Iso.refl _
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive eq_zero_of_add_nonneg_right]
theorem eq_one_of_one_le_mul_right (ha : a ≤ 1) (hb : b ≤ 1) (hab : 1 ≤ a * b) : b = 1
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_plift_true : #(PLift True) = 1
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem NNReal.upper_bound {α : Type*} [TopologicalSpace α] (f : α →ᵇ ℝ≥0) (x : α) :
    f x ≤ nndist f 0
-- Mathlib/Data/Stream/Init.lean
theorem homomorphism (f : α → β) (a : α) : pure f ⊛ pure a = pure (f a)
-- .lake/packages/lean4/src/lean/Init/Data/List/Control.lean
@[simp] theorem foldlM_cons [Monad m] (f : β → α → m β) (b) (a) (l : List α) :
    (a :: l).foldlM f b = f b a >>= l.foldlM f
-- Mathlib/NumberTheory/PrimeCounting.lean
@[simp]
theorem primeCounting'_nth_eq (n : ℕ) : π' (nth Prime n) = n
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Real.lean
theorem setIntegral_abs_condexp_le {s : Set α} (hs : MeasurableSet[m] s) (f : α → ℝ) :
    ∫ x in s, |(μ[f|m]) x| ∂μ ≤ ∫ x in s, |f x| ∂μ
-- Mathlib/NumberTheory/LSeries/Basic.lean
/-- If the `LSeries` of `f` is summable at `s`, then `f n` is bounded in absolute value
by a constant times `n^(re s)`. -/
lemma LSeriesSummable.le_const_mul_rpow {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    ∃ C, ∀ n ≠ 0, ‖f n‖ ≤ C * n ^ s.re
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem apply_le_norm (f : C(α, ℝ)) (x : α) : f x ≤ ‖f‖
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The Legendre symbol `legendreSym p a` with an integer `a` and a prime number `p`
is the same as the Jacobi symbol `J(a | p)`. -/
theorem legendreSym.to_jacobiSym (p : ℕ) [fp : Fact p.Prime] (a : ℤ) :
    legendreSym p a = J(a | p)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma φ_three : W.φ 3 = C X * C W.Ψ₃ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 2
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma coeSubgraph_adj {G' : G.Subgraph} (G'' : G'.coe.Subgraph) (v w : V) :
    (G'.coeSubgraph G'').Adj v w ↔
      ∃ (hv : v ∈ G'.verts) (hw : w ∈ G'.verts), G''.Adj ⟨v, hv⟩ ⟨w, hw⟩
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem hausdorffMeasure_of_dimH_lt {s : Set X} {d : ℝ≥0} (h : dimH s < d) : μH[d] s = 0
-- Mathlib/Data/DFinsupp/Basic.lean
theorem eq_mk_support (f : Π₀ i, β i) : f = mk f.support fun i => f i
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp] theorem gt_iff_lt [LT α] {x y : α} : x > y ↔ y < x
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem normalize.reduced' {num : Int} {den g : Nat} (den_nz : den ≠ 0)
    (e : g = num.natAbs.gcd den) : (num / g).natAbs.Coprime (den / g)
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma even_or_odd [NoZeroDivisors S] : ψ.Even ∨ ψ.Odd
-- Mathlib/Data/Nat/Multiplicity.lean
theorem multiplicity_pow_self {p n : ℕ} (hp : p.Prime) : multiplicity p (p ^ n) = n
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem add_isLimit (a) {b} : IsLimit b → IsLimit (a + b)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem data_takeWhile (p : Char → Bool) (s : String) :
    (s.takeWhile p).1 = s.1.takeWhile p
-- Mathlib/Algebra/DirectSum/Module.lean
theorem IsInternal.addSubmonoid_independent {M : Type*} [AddCommMonoid M] {A : ι → AddSubmonoid M}
    (h : IsInternal A) : CompleteLattice.Independent A
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem bound_of_isBigO_nat_atTop {f : ℕ → E} {g'' : ℕ → E''} (h : f =O[atTop] g'') :
    ∃ C > 0, ∀ ⦃x⦄, g'' x ≠ 0 → ‖f x‖ ≤ C * ‖g'' x‖
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualCoannihilator_dualAnnihilator_dualCoannihilator (U : Submodule R (Module.Dual R M)) :
    U.dualCoannihilator.dualAnnihilator.dualCoannihilator = U.dualCoannihilator
-- Mathlib/Control/Traversable/Lemmas.lean
@[simp]
theorem pureTransformation_apply {α} (x : id α) : PureTransformation F x = pure x
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem IsRoot.of_map {R} [CommRing R] {f : R →+* S} {x : R} {p : R[X]} (h : IsRoot (p.map f) (f x))
    (hf : Function.Injective f) : IsRoot p x
-- Mathlib/Data/Set/Basic.lean
@[gcongr]
theorem inter_subset_inter {s₁ s₂ t₁ t₂ : Set α} (h₁ : s₁ ⊆ t₁) (h₂ : s₂ ⊆ t₂) :
    s₁ ∩ s₂ ⊆ t₁ ∩ t₂
-- Mathlib/Data/Fintype/Powerset.lean
@[simp] lemma powerset_eq_univ : s.powerset = univ ↔ s = univ
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem vars_map : (map f p).vars ⊆ p.vars
-- Mathlib/Combinatorics/HalesJewett.lean
/-- The type of collections of lines such that
- each line is only one color except possibly at its endpoint
- the lines all have the same endpoint
- the colors of the lines are distinct.
Used in the proof `exists_mono_in_high_dimension`. -/
structure ColorFocused {α ι κ : Type*} (C : (ι → Option α) → κ) where
  /-- The underlying multiset of almost monochromatic lines of a color-focused collection. -/
  lines : Multiset (AlmostMono C)
  /-- The common endpoint of the lines in the color-focused collection. -/
  focus : ι → Option α
  /-- The proposition that all lines in a color-focused collection have the same endpoint. -/
  is_focused : ∀ p ∈ lines, p.line none = focus
  /-- The proposition that all lines in a color-focused collection of lines have distinct colors. -/
  distinct_colors : (lines.map AlmostMono.color).Nodup
-- Mathlib/CategoryTheory/Monad/Coequalizer.lean
@[simp]
theorem beckCofork_π : (beckCofork X).π = X.a
-- Mathlib/Combinatorics/SimpleGraph/Dart.lean
@[simp]
theorem Dart.edge_symm (d : G.Dart) : d.symm.edge = d.edge
-- Mathlib/Data/List/Dedup.lean
theorem nodup_dedup : ∀ l : List α, Nodup (dedup l)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem filter_cons_of_neg {a : α} (s) : ¬p a → filter p (a ::ₘ s) = filter p s
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Raised.right {l x₁ x₂ r₁ r₂} (H : Raised (size r₁) (size r₂)) :
    Raised (size (@node' α l x₁ r₁)) (size (@node' α l x₂ r₂))
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[simp]
theorem tensorLeftHomEquiv_whiskerLeft_comp_evaluation {Y Z : C} [HasLeftDual Z] (f : Y ⟶ ᘁZ) :
    (tensorLeftHomEquiv _ _ _ _) (Z ◁ f ≫ ε_ _ _) = f ≫ (ρ_ _).inv
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma map_comp (f : Hom P P') (g : Hom P' P'') :
    CotangentSpace.map (g.comp f) =
      (CotangentSpace.map g).restrictScalars S ∘ₗ CotangentSpace.map f
-- Mathlib/Data/Finset/Basic.lean
theorem filter_not (s : Finset α) : (s.filter fun a => ¬p a) = s \ s.filter p
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem map_proj_nhds (x : TotalSpace F E) : map (π F E) (𝓝 x) = 𝓝 x.proj
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem coe_notMemRangeEquiv (k : ℕ) :
    (notMemRangeEquiv k : { n // n ∉ range k } → ℕ) = fun (i : { n // n ∉ range k }) => i - k
-- Mathlib/Analysis/Convex/Combination.lean
theorem inf_le_centerMass {s : Finset ι} {f : ι → α} {w : ι → R} (hw₀ : ∀ i ∈ s, 0 ≤ w i)
    (hw₁ : 0 < ∑ i ∈ s, w i) :
    s.inf' (nonempty_of_ne_empty <| by rintro rfl; simp at hw₁) f ≤ s.centerMass w f
-- Mathlib/Order/Filter/Lift.lean
/-- If `(p : ι → Prop, s : ι → Set α)` is a basis of a filter `f`, `g` is a monotone function
`Set α → Filter γ`, and for each `i`, `(pg : β i → Prop, sg : β i → Set α)` is a basis
of the filter `g (s i)`, then
`(fun (i : ι) (x : β i) ↦ p i ∧ pg i x, fun (i : ι) (x : β i) ↦ sg i x)` is a basis
of the filter `f.lift g`.

This basis is parametrized by `i : ι` and `x : β i`, so in order to formulate this fact using
`Filter.HasBasis` one has to use `Σ i, β i` as the index type, see `Filter.HasBasis.lift`.
This lemma states the corresponding `mem_iff` statement without using a sigma type. -/
theorem HasBasis.mem_lift_iff {ι} {p : ι → Prop} {s : ι → Set α} {f : Filter α}
    (hf : f.HasBasis p s) {β : ι → Type*} {pg : ∀ i, β i → Prop} {sg : ∀ i, β i → Set γ}
    {g : Set α → Filter γ} (hg : ∀ i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
    {s : Set γ} : s ∈ f.lift g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.prod_left_snd : (fun x => (f' x, g' x)) =o[l] k' → g' =o[l] k'
-- Mathlib/Topology/Sober.lean
theorem mem_open_set_iff (h : IsGenericPoint x S) (hU : IsOpen U) : x ∈ U ↔ (S ∩ U).Nonempty
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem _root_.Set.Finite.nullMeasurableSet_sUnion {s : Set (Set α)} (hs : s.Finite)
    (h : ∀ t ∈ s, NullMeasurableSet t μ) : NullMeasurableSet (⋃₀ s) μ
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Two morphisms are equal if there is a fork whose inclusion is epi. -/
theorem eq_of_epi_fork_ι (t : Fork f g) [Epi (Fork.ι t)] : f = g
-- Mathlib/Order/Disjoint.lean
theorem isComplemented_top : IsComplemented (⊤ : α)
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem pointwise_smul_le_iff₀ {a : M} (ha : a ≠ 0) {S T : Subsemiring R} :
    a • S ≤ T ↔ S ≤ a⁻¹ • T
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma verts_monotone : Monotone (verts : G.Subgraph → Set V)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[simp]
theorem infty_coeFn_intCast (z : ℤ) : ⇑(z : lp B ∞) = z
-- Mathlib/Data/Sum/Interval.lean
lemma Ioc_inl_inl :
    Ioc (inlₗ a₁ : α ⊕ₗ β) (inlₗ a₂) = (Ioc a₁ a₂).map (Embedding.inl.trans toLex.toEmbedding)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem top_eq_univ : (⊤ : Set α) = univ
-- Mathlib/Analysis/Normed/Group/InfiniteSum.lean
/-- If a function `f` is summable in norm, and along some sequence of finsets exhausting the space
its sum is converging to a limit `a`, then this holds along all finsets, i.e., `f` is summable
with sum `a`. -/
theorem hasSum_of_subseq_of_summable {f : ι → E} (hf : Summable fun a => ‖f a‖) {s : α → Finset ι}
    {p : Filter α} [NeBot p] (hs : Tendsto s p atTop) {a : E}
    (ha : Tendsto (fun b => ∑ i ∈ s b, f i) p (𝓝 a)) : HasSum f a
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem image_trans_source : e '' (e.trans e').source = e.target ∩ e'.source
-- Mathlib/Computability/Halting.lean
theorem vec_iff {m n f} : @Vec m n f ↔ Computable f
-- Mathlib/Topology/LocallyConstant/Basic.lean
protected theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y
-- Mathlib/Analysis/LocallyConvex/Barrelled.lean
/-- The **Banach-Steinhaus** theorem, or **Uniform Boundedness Principle**, for maps from a
barrelled space to any space whose topology is generated by a family of seminorms. Use
`WithSeminorms.equicontinuous_TFAE` and `Seminorm.bound_of_continuous` to get explicit bounds on
the seminorms from equicontinuity. -/
protected theorem banach_steinhaus (H : ∀ k x, BddAbove (range fun i ↦ q k (𝓕 i x))) :
    UniformEquicontinuous ((↑) ∘ 𝓕)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_iff :
    LinearIndependent R v ↔ ∀ l, Finsupp.total ι M R v l = 0 → l = 0
-- Mathlib/Order/WithBot.lean
theorem none_eq_bot : (none : WithBot α) = (⊥ : WithBot α)