ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Localization/Basic.lean
theorem IsLocalization.map_units_map_submonoid
    [IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ] (y : M) :
    IsUnit (algebraMap R Sₘ y)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem mem_prod {S : NonUnitalSubalgebra R A} {S₁ : NonUnitalSubalgebra R B} {x : A × B} :
    x ∈ prod S S₁ ↔ x.1 ∈ S ∧ x.2 ∈ S₁
-- Mathlib/Order/WithBot.lean
@[simp]
theorem bot_ne_coe : ⊥ ≠ (a : WithBot α)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
theorem map_coord_zero {m : ∀ i, M₁ i} (i : ι) (h : m i = 0) : f m = 0
-- Mathlib/Topology/Category/Compactum.lean
theorem isClosed_iff {X : Compactum} (S : Set X) :
    IsClosed S ↔ ∀ F : Ultrafilter X, S ∈ F → X.str F ∈ S
-- Mathlib/Data/List/EditDistance/Defs.lean
/-- The default cost structure, for which all operations cost `1`. -/
@[simps]
def defaultCost [DecidableEq α] : Cost α α ℕ
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem range_inr_inter_range_inl : range (Sum.inr : β → α ⊕ β) ∩ range Sum.inl = ∅
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem prod_mk_right (b : β) : LipschitzWith 1 fun a : α => (a, b)
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma abs_lt_of_sq_lt_sq' (h : a ^ 2 < b ^ 2) (hb : 0 ≤ b) : -b < a ∧ a < b
-- Mathlib/Topology/PartialHomeomorph.lean
theorem toPartialEquiv (h : e.IsImage s t) : e.toPartialEquiv.IsImage s t
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.dvd_iff_dvd_right [Monoid α] {a b c : α} (h : b ~ᵤ c) : a ∣ b ↔ a ∣ c
-- Mathlib/Order/Interval/Multiset.lean
theorem right_mem_Icc : b ∈ Icc a b ↔ a ≤ b
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma measurableSet_countableGeneratingSet [MeasurableSpace α] [CountablyGenerated α]
    {s : Set α} (hs : s ∈ countableGeneratingSet α) :
    MeasurableSet s
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, strict differentiability in the right endpoint.

If `f : ℝ → E` is integrable on `a..b` and `f x` has a finite limit `c` almost surely at `b`, then
`u ↦ ∫ x in a..u, f x` has derivative `c` at `b` in the sense of strict differentiability. -/
theorem integral_hasStrictDerivAt_of_tendsto_ae_right (hf : IntervalIntegrable f volume a b)
    (hmeas : StronglyMeasurableAtFilter f (𝓝 b)) (hb : Tendsto f (𝓝 b ⊓ ae volume) (𝓝 c)) :
    HasStrictDerivAt (fun u => ∫ x in a..u, f x) c b
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
@[simp]
theorem card_incidenceSet_eq_degree [DecidableEq V] :
    Fintype.card (G.incidenceSet v) = G.degree v
-- Mathlib/Topology/Instances/ENNReal.lean
theorem eventuallyEq_of_toReal_eventuallyEq {l : Filter α} {f g : α → ℝ≥0∞}
    (hfi : ∀ᶠ x in l, f x ≠ ∞) (hgi : ∀ᶠ x in l, g x ≠ ∞)
    (hfg : (fun x => (f x).toReal) =ᶠ[l] fun x => (g x).toReal) : f =ᶠ[l] g
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem mem_domain_iff {f : E →ₗ.[R] F} {x : E} : x ∈ f.domain ↔ ∃ y : F, (x, y) ∈ f.graph
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp]
theorem eq_natCast [FunLike F ℕ R] [RingHomClass F ℕ R] (f : F) : ∀ n, f n = n
-- Mathlib/NumberTheory/LSeries/Deriv.lean
/-- If the L-series of `f` is summable at `s` and `re s < re s'`, then the L-series of the
point-wise product of `log` with `f` is summable at `s'`. -/
lemma LSeriesSummable_logMul_of_lt_re {f : ℕ → ℂ} {s : ℂ} (h : abscissaOfAbsConv f < s.re) :
    LSeriesSummable (logMul f) s
-- Mathlib/Topology/Order.lean
theorem continuous_id_of_le {t t' : TopologicalSpace α} (h : t ≤ t') : Continuous[t, t'] id
-- Mathlib/Data/Finset/Powerset.lean
theorem not_mem_of_mem_powerset_of_not_mem {s t : Finset α} {a : α} (ht : t ∈ s.powerset)
    (h : a ∉ s) : a ∉ t
-- Mathlib/Algebra/GroupWithZero/Basic.lean
theorem eq_zero_of_mul_self_eq_zero (h : a * a = 0) : a = 0
-- Mathlib/Data/ENNReal/Operations.lean
@[gcongr] protected theorem add_lt_add_left : a ≠ ∞ → b < c → a + b < a + c
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- If a `E ⋙ F` has a limit, and `E` is an equivalence, we can construct a limit of `F`.
-/
theorem hasLimitOfEquivalenceComp (e : K ≌ J) [HasLimit (e.functor ⋙ F)] : HasLimit F
-- Mathlib/CategoryTheory/Generator.lean
theorem isSeparating_proj_preimage {𝒢 : Set C} (h𝒢 : IsSeparating 𝒢) :
    IsSeparating ((proj S T).obj ⁻¹' 𝒢)
-- Mathlib/Order/Hom/Lattice.lean
@[simp, norm_cast] lemma coe_snd : ⇑(snd (α := α) (β := β)) = Prod.snd
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem pure_seq {α β : Type u} {f : α → β} {x : FreeMagma α} : pure f <*> x = f <$> x
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem natAbs_dvd {a b : Int} : (a.natAbs : Int) ∣ b ↔ a ∣ b
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableWithinAt.hasLineDerivWithinAt (h : LineDifferentiableWithinAt 𝕜 f s x v) :
    HasLineDerivWithinAt 𝕜 f (lineDerivWithin 𝕜 f s x v) s x v
-- Mathlib/Algebra/Homology/TotalComplex.lean
lemma d₂_eq' (i₁ : I₁) {i₂ i₂' : I₂} (h : c₂.Rel i₂ i₂') (i₁₂ : I₁₂) :
    K.d₂ c₁₂ i₁ i₂ i₁₂ = ComplexShape.ε₂ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ • ((K.X i₁).d i₂ i₂' ≫
    K.ιTotalOrZero c₁₂ i₁ i₂' i₁₂)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem div_eq_of_eq_mul_right {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = b * c) : a.div b = c
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_comp (hnp : β →+* γ) (hmn : α →+* β) : (hnp.comp hmn : α → γ) = hnp ∘ hmn
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem inl_intCast [AddGroupWithOne R] [AddGroup M] (z : ℤ) : (inl z : tsze R M) = z
-- Mathlib/Topology/Basic.lean
theorem continuous_of_const (h : ∀ x y, f x = f y) : Continuous f
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
/-- If we remove a smaller interval from a larger, the result is nonempty -/
theorem nonempty_Ico_sdiff {x dx y dy : α} (h : dy < dx) (hx : 0 < dx) :
    Nonempty ↑(Ico x (x + dx) \ Ico y (y + dy))
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousAt_prod_of_discrete_right [DiscreteTopology β] {f : α × β → γ} {x : α × β} :
    ContinuousAt f x ↔ ContinuousAt (f ⟨·, x.2⟩) x.1
-- Mathlib/Order/WellFoundedSet.lean
nonrec theorem IsPWO.prod {t : Set β} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s ×ˢ t)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iio_union_Ioo' (h₁ : c < b) : Iio b ∪ Ioo c d = Iio (max b d)
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem mk_d_1_0 : (mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 0 = d₀
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
@[simp]
theorem logb_abs (x : ℝ) : logb b |x| = logb b x
-- Mathlib/Topology/Basic.lean
lemma nhdsWithin_neBot : (𝓝[s] x).NeBot ↔ ∀ ⦃t⦄, t ∈ 𝓝 x → (t ∩ s).Nonempty
-- Mathlib/Order/Filter/Basic.lean
theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
    (hs : m '' s ∈ f) : NeBot (comap m f ⊓ 𝓟 s)
-- Mathlib/Data/Finsupp/Defs.lean
theorem single_of_single_apply (a a' : α) (b : M) :
    single a ((single a' b) a) = single a' (single a' b) a
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[simp]
theorem infty_coeFn_natCast (n : ℕ) : ⇑(n : lp B ∞) = n
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem zero_comp (g : β →co γ) : (0 : C_c(γ, δ)).comp g = 0
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
/-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag'_transpose (M : Matrix (Σi, m' i) (Σi, n' i) α) (k : o) :
    blockDiag' Mᵀ k = (blockDiag' M k)ᵀ
-- Mathlib/Topology/Inseparable.lean
theorem not_specializes_iff_exists_open : ¬x ⤳ y ↔ ∃ S : Set X, IsOpen S ∧ y ∈ S ∧ x ∉ S
-- Mathlib/Analysis/Normed/Group/Bounded.lean
/-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. -/
@[to_additive "In a (semi)normed group, negation `x ↦ -x` tends to infinity at infinity."]
theorem Filter.tendsto_inv_cobounded : Tendsto Inv.inv (cobounded E) (cobounded E)
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
/-- Automorphization of a function into an `R`-`Module` distributes, that is, commutes with the
`R`-scalar multiplication. -/
lemma QuotientGroup.automorphize_smul_left (f : G → M) (g : G ⧸ Γ → R) :
    (QuotientGroup.automorphize ((g ∘ (@Quotient.mk' _ (_)) : G → R) • f) : G ⧸ Γ → M)
      = g • (QuotientGroup.automorphize f : G ⧸ Γ → M)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem carrier.asIdeal.homogeneous : (carrier.asIdeal f_deg hm q).IsHomogeneous 𝒜
-- Mathlib/LinearAlgebra/BilinearForm/TensorProduct.lean
/-- The base change of a symmetric bilinear form is symmetric. -/
lemma IsSymm.baseChange {B₂ : BilinForm R M₂} (hB₂ : B₂.IsSymm) : (B₂.baseChange A).IsSymm
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem restrict_Ico_eq_restrict_Icc : μ.restrict (Ico a b) = μ.restrict (Icc a b)
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
/-- An additive functor induces a functor between homotopy categories. -/
@[simps! obj]
def Functor.mapHomotopyCategory (F : V ⥤ W) [F.Additive] (c : ComplexShape ι) :
    HomotopyCategory V c ⥤ HomotopyCategory W c
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[simp]
theorem sum.map_inv : sum x⁻¹ = -sum x
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem univ_pi_Iio_ae_eq_Iic {f : ∀ i, α i} :
    (pi univ fun i => Iio (f i)) =ᵐ[Measure.pi μ] Iic f
-- Mathlib/Order/BooleanAlgebra.lean
theorem disjoint_sdiff_iff_le (hz : z ≤ y) (hx : x ≤ y) : Disjoint z (y \ x) ↔ z ≤ x
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_add_int (a : α) (z : ℤ) : ⌈a + z⌉ = ⌈a⌉ + z
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem antilipschitz_of_comap_nhds_le [h : RingHomIsometric σ₁₂] (f : E →ₛₗ[σ₁₂] F)
    (hf : (𝓝 0).comap f ≤ 𝓝 0) : ∃ K, AntilipschitzWith K f
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.trans_le (hfg : f =o[l] g) (hgk : ∀ x, ‖g x‖ ≤ ‖k x‖) : f =o[l] k
-- Mathlib/RingTheory/FractionalIdeal/Norm.lean
theorem abs_det_basis_change [NoZeroDivisors K] {ι : Type*} [Fintype ι]
    [DecidableEq ι] (b : Basis ι ℤ R) (I : FractionalIdeal R⁰ K) (bI : Basis ι ℤ I) :
    |(b.localizationLocalization ℚ ℤ⁰ K).det ((↑) ∘ bI)| = absNorm I
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive Left.pow_nonneg]
theorem Left.one_le_pow_of_le (hx : 1 ≤ x) : ∀ {n : ℕ}, 1 ≤ x ^ n
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp, norm_cast]
theorem natCast_mul (m : ℕ) : ∀ n : ℕ, ((m * n : ℕ) : Ordinal) = m * n
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- An isomorphism of comonads gives a natural isomorphism of the underlying functors.
-/
@[simps!]
def ComonadIso.toNatIso {M N : Comonad C} (h : M ≅ N) : (M : C ⥤ C) ≅ N
-- Mathlib/Order/Filter/NAry.lean
@[simp]
theorem le_map₂_iff {h : Filter γ} :
    h ≤ map₂ m f g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → image2 m s t ∈ h
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem comap_exp_cobounded : comap exp (cobounded ℂ) = comap re atTop
-- Mathlib/Algebra/Star/RingQuot.lean
theorem Rel.star (hr : ∀ a b, r a b → r (star a) (star b))
    ⦃a b : R⦄ (h : Rel r a b) : Rel r (star a) (star b)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.valid {t o₁ o₂} (h : @Valid' α _ o₁ t o₂) : Valid t
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_iff' : μ₁ ≤ μ₂ ↔ ∀ s, μ₁ s ≤ μ₂ s
-- Mathlib/Topology/PartialHomeomorph.lean
theorem eventually_ne_nhdsWithin {x} (hx : x ∈ e.source) :
    ∀ᶠ x' in 𝓝[≠] x, e x' ≠ e x
-- Mathlib/Data/List/DropRight.lean
@[simp]
theorem rtakeWhile_concat_pos (x : α) (h : p x) :
    rtakeWhile p (l ++ [x]) = rtakeWhile p l ++ [x]
-- Mathlib/FieldTheory/Adjoin.lean
theorem rank_adjoin_eq_one_iff : Module.rank F (adjoin F S) = 1 ↔ S ⊆ (⊥ : IntermediateField F E)
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma traceForm_comm (x y : L) : traceForm R L M x y = traceForm R L M y x
-- Mathlib/Analysis/Analytic/Inverse.lean
theorem comp_rightInv_aux1 {n : ℕ} (hn : 0 < n) (p : FormalMultilinearSeries 𝕜 E F)
    (q : FormalMultilinearSeries 𝕜 F E) (v : Fin n → F) :
    p.comp q n v =
      ∑ c ∈ {c : Composition n | 1 < c.length}.toFinset,
          p c.length (q.applyComposition c v) +
        p 1 fun _ => q n v
-- Mathlib/Topology/Order/OrderClosed.lean
protected lemma BddBelow.of_closure : BddBelow (closure s) → BddBelow s
-- Mathlib/Algebra/Order/Ring/Cast.lean
lemma nneg_mul_add_sq_of_abs_le_one (n : ℤ) (hx : |x| ≤ 1) : (0 : R) ≤ n * x + n * n
-- Mathlib/Data/Nat/SuccPred.lean
theorem pred_iterate (a : ℕ) : ∀ n, pred^[n] a = a - n
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem coord_apply_ne (h : i ≠ j) : b.coord i (b j) = 0
-- Mathlib/Algebra/Field/Subfield.lean
theorem map_le_iff_le_comap {f : K →+* L} {s : Subfield K} {t : Subfield L} :
    s.map f ≤ t ↔ s ≤ t.comap f
-- Mathlib/Algebra/CharP/Two.lean
@[simp]
theorem sub_eq_add (x y : R) : x - y = x + y
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
theorem mod_four_ne_three_of_sq_eq_neg_sq {x y : ZMod p} (hx : x ≠ 0) (hxy : x ^ 2 = -y ^ 2) :
    p % 4 ≠ 3
-- Mathlib/Order/Part.lean
lemma Antitone.partMap (hg : Antitone g) : Antitone fun x ↦ (g x).map f
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
@[simp]
theorem coe_neg (g : SpecialLinearGroup n R) : ↑(-g) = -(g : Matrix n n R)
-- Mathlib/Condensed/TopComparison.lean
/--
If `G` preserves the relevant pullbacks and every effective epi in `C` is a quotient map (which is
the case when `C` is `CompHaus` or `Profinite`), then `yonedaPresheaf` satisfies the equalizer
condition which is required to be a sheaf for the regular topology.
-/
theorem equalizerCondition_yonedaPresheaf
    [∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) G]
    (hq : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], QuotientMap (G.map π)) :
      EqualizerCondition (yonedaPresheaf G X)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableAt.const_smul (h : DifferentiableAt 𝕜 f x) (c : R) :
    DifferentiableAt 𝕜 (fun y => c • f y) x
-- Mathlib/Algebra/Polynomial/Taylor.lean
theorem eq_zero_of_hasseDeriv_eq_zero {R} [CommRing R] (f : R[X]) (r : R)
    (h : ∀ k, (hasseDeriv k f).eval r = 0) : f = 0
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
theorem mem_setOfIdeal {I : Ideal C(X, R)} {x : X} :
    x ∈ setOfIdeal I ↔ ∃ f ∈ I, (f : C(X, R)) x ≠ 0
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- The residue of `completedHurwitzZetaEven a s` at `s = 1` is equal to `1`. -/
lemma completedHurwitzZetaEven_residue_one (a : UnitAddCircle) :
    Tendsto (fun s ↦ (s - 1) * completedHurwitzZetaEven a s) (𝓝[≠] 1) (𝓝 1)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem covariant_le_of_covariant_lt [PartialOrder N] :
    Covariant M N μ (· < ·) → Covariant M N μ (· ≤ ·)
-- Mathlib/Data/Nat/Defs.lean
lemma sqrt_eq (n : ℕ) : sqrt (n * n) = n
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Ico : (Ico a b).Nonempty ↔ a < b
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasStrictFDerivAt.inner (hf : HasStrictFDerivAt f f' x) (hg : HasStrictFDerivAt g g' x) :
    HasStrictFDerivAt (fun t => ⟪f t, g t⟫) ((fderivInnerCLM 𝕜 (f x, g x)).comp <| f'.prod g') x
-- Mathlib/GroupTheory/CosetCover.lean
/-- B. H. Neumann Lemma :
If a finite family of cosets of subgroups covers the group, then at least one
of these subgroups has index not exceeding the number of cosets. -/
@[to_additive]
theorem exists_index_le_card_of_leftCoset_cover :
    ∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
@[simp, mono]
theorem measure_le_measure_union_right : μ t ≤ μ (s ∪ t)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsPath.takeUntil {u v w : V} {p : G.Walk v w} (hc : p.IsPath)
    (h : u ∈ p.support) : (p.takeUntil u h).IsPath
-- Mathlib/InformationTheory/Hamming.lean
@[simp]
theorem toHamming_smul [∀ i, SMul α (β i)] {r : α} {x : ∀ i, β i} :
    toHamming (r • x) = r • toHamming x
-- Mathlib/Algebra/Algebra/Defs.lean
@[norm_cast]
theorem coe_add (a b : R) : (↑(a + b : R) : A) = ↑a + ↑b
-- Mathlib/Algebra/Group/Action/Units.lean
@[to_additive]
lemma _root_.IsUnit.inv_smul [Monoid α] {a : α} (h : IsUnit a) : h.unit⁻¹ • a = 1
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- The limit of `n / (n + x)` is 1, for any constant `x` (valid in `ℝ` or any topological division
algebra over `ℝ`, e.g., `ℂ`).

TODO: introduce a typeclass saying that `1 / n` tends to 0 at top, making it possible to get this
statement simultaneously on `ℚ`, `ℝ` and `ℂ`. -/
theorem tendsto_natCast_div_add_atTop {𝕜 : Type*} [DivisionRing 𝕜] [TopologicalSpace 𝕜]
    [CharZero 𝕜] [Algebra ℝ 𝕜] [ContinuousSMul ℝ 𝕜] [TopologicalDivisionRing 𝕜] (x : 𝕜) :
    Tendsto (fun n : ℕ ↦ (n : 𝕜) / (n + x)) atTop (𝓝 1)
-- Mathlib/Topology/Order.lean
theorem singletons_open_iff_discrete {X : Type*} [TopologicalSpace X] :
    (∀ a : X, IsOpen ({a} : Set X)) ↔ DiscreteTopology X
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem get?_eq_none : l.get? n = none ↔ length l ≤ n
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
/-- `HasFiniteWidePushouts` represents a choice of wide pushout
for every finite collection of morphisms
-/
class HasFiniteWidePushouts : Prop where
  /-- `C` has all wide pushouts any Fintype `J`-/
  out (J : Type) [Finite J] : HasColimitsOfShape (WidePushoutShape J) C
-- Mathlib/Order/Hom/Lattice.lean
/-- Reinterpret a finitary infimum homomorphism as a finitary supremum homomorphism between the dual
lattices. -/
@[simps]
protected def dual : InfTopHom α β ≃ SupBotHom αᵒᵈ βᵒᵈ
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := mono)]
theorem mul_subset_mul : s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ * s₂ ⊆ t₁ * t₂
-- Mathlib/Order/Filter/Basic.lean
theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g
-- Mathlib/MeasureTheory/Measure/Tilted.lean
lemma setLIntegral_tilted' (f : α → ℝ) (g : α → ℝ≥0∞) {s : Set α} (hs : MeasurableSet s) :
    ∫⁻ x in s, g x ∂(μ.tilted f)
      = ∫⁻ x in s, ENNReal.ofReal (exp (f x) / ∫ x, exp (f x) ∂μ) * g x ∂μ
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem powerset_mono : 𝒫 s ⊆ 𝒫 t ↔ s ⊆ t
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem includeRight_apply (b : B) : (includeRight : B →ₐ[R] A ⊗[R] B) b = 1 ⊗ₜ b
-- Mathlib/Order/Compare.lean
theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
-- Mathlib/LinearAlgebra/TensorProduct/Basis.lean
@[simp]
theorem Basis.tensorProduct_apply (b : Basis ι S M) (c : Basis κ R N) (i : ι) (j : κ) :
    Basis.tensorProduct b c (i, j) = b i ⊗ₜ c j
-- Mathlib/Topology/Connected/PathConnected.lean
@[symm]
theorem JoinedIn.symm (h : JoinedIn F x y) : JoinedIn F y x
-- Mathlib/Data/Multiset/Fintype.lean
@[to_additive]
theorem Multiset.prod_eq_prod_toEnumFinset [CommMonoid α] (m : Multiset α) :
    m.prod = ∏ x ∈ m.toEnumFinset, x.1
-- Mathlib/Data/Finite/Card.lean
theorem card_subtype_le [Finite α] (p : α → Prop) : Nat.card { x // p x } ≤ Nat.card α
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem zero_lt_neg_iff {x : PGame} : 0 < -x ↔ x < 0
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem continuousOn_floor (n : ℤ) :
    ContinuousOn (fun x => floor x : α → α) (Ico n (n + 1) : Set α)
-- Mathlib/Analysis/Convex/GaugeRescale.lean
theorem mapsTo_gaugeRescale_closure {s t : Set E} (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0)
    (htc : Convex ℝ t) (ht₀ : 0 ∈ t) (hta : Absorbent ℝ t) :
    MapsTo (gaugeRescale s t) (closure s) (closure t)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem weightedHomogeneousComponent_apply [DecidableEq M] :
    weightedHomogeneousComponent w n φ =
      ∑ d ∈ φ.support.filter fun d => weight w d = n, monomial d (coeff d φ)
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
/--
The lower set topology is the topology where the open sets are the lower sets. In general the lower
set topology does not coincide with the lower topology.
-/
protected class IsLowerSet (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  topology_eq_lowerSetTopology : t = lowerSet α
-- Mathlib/NumberTheory/LSeries/Deriv.lean
/-- The derivative of the terms of an L-series. -/
lemma LSeries.hasDerivAt_term (f : ℕ → ℂ) (n : ℕ) (s : ℂ) :
    HasDerivAt (fun z ↦ term f z n) (-(term (logMul f) s n)) s
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem snd_univ : ρ.snd univ = ρ univ
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : R) : ℍ[R,c₁,c₂]) = 0
-- Mathlib/Algebra/Order/Module/Defs.lean
private theorem smul_nonneg_of_pos_of_nonneg (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a • b
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem lift.range_eq_closure : (lift f).range = Subgroup.closure (Set.range f)
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_finset_image {f : γ → α} {g : α → Set β} {s : Finset γ} :
    ⋃ x ∈ s.image f, g x = ⋃ y ∈ s, g (f y)
-- Mathlib/Data/Real/Pointwise.lean
theorem Real.mul_iSup_of_nonpos (ha : r ≤ 0) (f : ι → ℝ) : (r * ⨆ i, f i) = ⨅ i, r * f i
-- Mathlib/Algebra/Group/Units.lean
theorem units_eq_one [Unique Mˣ] (u : Mˣ) : u = 1
-- Mathlib/Order/GaloisConnection.lean
theorem u_iSup_l [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u) {ι : Sort x}
    (f : ι → α) : u (⨆ i, l (f i)) = ⨆ i, f i
-- Mathlib/Algebra/Module/Equiv/Basic.lean
/-- Ring equivalence between additive group endomorphisms of an `AddCommGroup` `A` and
`ℤ`-module endomorphisms of `A.` -/
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem UniformInducing.mk' {f : α → β}
    (h : ∀ s, s ∈ 𝓤 α ↔ ∃ t ∈ 𝓤 β, ∀ x y : α, (f x, f y) ∈ t → (x, y) ∈ s) : UniformInducing f
-- Mathlib/Computability/Ackermann.lean
private theorem ack_strict_mono_left' : ∀ {m₁ m₂} (n), m₁ < m₂ → ack m₁ n < ack m₂ n
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- If a product is 1 and the function is 1 except possibly at one
point, it is 1 everywhere on the `Finset`. -/
@[to_additive "If a sum is 0 and the function is 0 except possibly at one
point, it is 0 everywhere on the `Finset`."]
theorem eq_one_of_prod_eq_one {s : Finset α} {f : α → β} {a : α} (hp : ∏ x ∈ s, f x = 1)
    (h1 : ∀ x ∈ s, x ≠ a → f x = 1) : ∀ x ∈ s, f x = 1
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Replacing both the first and third points by ones on the same lines but the opposite rays
does not change the oriented angle (vertically opposite angles). -/
theorem _root_.Sbtw.oangle_eq_left_right {p₁ p₁' p₂ p₃ p₃' : P} (h₁ : Sbtw ℝ p₁ p₂ p₁')
    (h₃ : Sbtw ℝ p₃ p₂ p₃') : ∡ p₁ p₂ p₃ = ∡ p₁' p₂ p₃'
-- Mathlib/Algebra/Order/Group/MinMax.lean
@[to_additive]
lemma max_inv_one (a : α) : max a⁻¹ 1 = a⁻¹ * max a 1
-- Mathlib/RingTheory/Binomial.lean
theorem descPochhammer_smeval_eq_ascPochhammer (r : R) (n : ℕ) :
    (descPochhammer ℤ n).smeval r = (ascPochhammer ℕ n).smeval (r - n + 1)
-- Mathlib/Topology/Instances/ENNReal.lean
/-- For a bounded set `s : Set ℝ`, its `Metric.diam` is equal to `sSup s - sInf s`. -/
theorem diam_eq {s : Set ℝ} (h : Bornology.IsBounded s) : Metric.diam s = sSup s - sInf s
-- Mathlib/FieldTheory/IntermediateField.lean
theorem map_map {K L₁ L₂ L₃ : Type*} [Field K] [Field L₁] [Algebra K L₁] [Field L₂] [Algebra K L₂]
    [Field L₃] [Algebra K L₃] (E : IntermediateField K L₁) (f : L₁ →ₐ[K] L₂) (g : L₂ →ₐ[K] L₃) :
    (E.map f).map g = E.map (g.comp f)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
/-- Two linear isometries are equal if they are equal on basis vectors. -/
theorem Basis.ext_linearIsometry {ι : Type*} (b : Basis ι R E) {f₁ f₂ : E →ₛₗᵢ[σ₁₂] E₂}
    (h : ∀ i, f₁ (b i) = f₂ (b i)) : f₁ = f₂
-- Mathlib/Algebra/AddTorsor.lean
/-- Subtracting the result of adding a group element produces the same result
as subtracting the points and subtracting that group element. -/
theorem vsub_vadd_eq_vsub_sub (p₁ p₂ : P) (g : G) : p₁ -ᵥ (g +ᵥ p₂) = p₁ -ᵥ p₂ - g
-- Mathlib/Data/Seq/WSeq.lean
theorem flatten_congr {c1 c2 : Computation (WSeq α)} :
    Computation.LiftRel Equiv c1 c2 → flatten c1 ~ʷ flatten c2
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toDFinsupp_zero [Zero M] : (0 : ι →₀ M).toDFinsupp = 0
-- Mathlib/Order/Lattice.lean
@[simp]
theorem ofDual_sup [Inf α] (a b : αᵒᵈ) : ofDual (a ⊔ b) = ofDual a ⊓ ofDual b