ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- A uniform space is complete provided that (a) its uniformity filter has a countable basis;
(b) any sequence satisfying a "controlled" version of the Cauchy condition converges. -/
theorem complete_of_convergent_controlled_sequences (U : ℕ → Set (α × α)) (U_mem : ∀ n, U n ∈ 𝓤 α)
    (HU : ∀ u : ℕ → α, (∀ N m n, N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)) :
    CompleteSpace α
-- Mathlib/Data/Finset/Sups.lean
theorem infs_sups_subset_right : (t ⊻ u) ⊼ s ⊆ t ⊼ s ⊻ u ⊼ s
-- Mathlib/Topology/Connected/PathConnected.lean
theorem JoinedIn.source_mem (h : JoinedIn F x y) : x ∈ F
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem length_pushn (c : Char) (n : Nat) : (pushn s c n).length = s.length + n
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
@[simp] theorem of_coe (X : ModuleCat R) : of R X = X
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Asymptotics.lean
theorem isBigO_id : f =O[l] fun x => x
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem sub_apply : (x - y) i = x i - y i
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem fundamentalDomain_stdBasis :
    fundamentalDomain (stdBasis K) =
        (Set.univ.pi fun _ => Set.Ico 0 1) ×ˢ
        (Set.univ.pi fun _ => Complex.measurableEquivPi⁻¹' (Set.univ.pi fun _ => Set.Ico 0 1))
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_graph {f : L.Functions n} {x : Fin n → M} {y : M} :
    (Formula.graph f).Realize (Fin.cons y x : _ → M) ↔ funMap f x = y
-- Mathlib/Data/Finset/Basic.lean
theorem subset_inter_iff : s ⊆ t ∩ u ↔ s ⊆ t ∧ s ⊆ u
-- Mathlib/RingTheory/Flat/Basic.lean
lemma lTensor_exact [Small.{v} R] [flat : Flat R M] ⦃N N' N'' : Type v⦄
    [AddCommGroup N] [AddCommGroup N'] [AddCommGroup N''] [Module R N] [Module R N'] [Module R N'']
    ⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄ (exact : Function.Exact f g) :
    Function.Exact (f.lTensor M) (g.lTensor M)
-- Mathlib/Order/Filter/Germ/Basic.lean
/-- If `f : α → β` is constant w.r.t. `l` and `g : β → γ`, then `g ∘ f : α → γ` also is. -/
lemma isConstant_comp {l : Filter α} {f : α → β} {g : β → γ}
    (h : (f : Germ l β).IsConstant) : ((g ∘ f) : Germ l γ).IsConstant
-- Mathlib/MeasureTheory/Function/ContinuousMapDense.lean
/-- A function in `Lp` can be approximated in `Lp` by continuous functions. -/
theorem boundedContinuousFunction_topologicalClosure [SecondCountableTopologyEither α E]
    [Fact (1 ≤ p)] (hp : p ≠ ∞) [μ.WeaklyRegular] :
    (boundedContinuousFunction E p μ).topologicalClosure = ⊤
-- 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 compactly supported
function `f : X → ℝ` such that

* `f` equals one on `s`;
* `f` equals zero on `t`;
* `0 ≤ f x ≤ 1` for all `x`.
-/
theorem exists_continuous_one_zero_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 1 s ∧ EqOn f 0 t ∧ HasCompactSupport f ∧ ∀ x, f x ∈ Icc (0 : ℝ) 1
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[fun_prop]
nonrec
theorem ContinuousAt.cexp (h : ContinuousAt f x) : ContinuousAt (fun y => exp (f y)) x
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
@[simp]
theorem dimH_preimage (e : X ≃ᵢ Y) (s : Set Y) : dimH (e ⁻¹' s) = dimH s
-- Mathlib/Topology/Connected/PathConnected.lean
theorem pathConnectedSpace_iff_zerothHomotopy :
    PathConnectedSpace X ↔ Nonempty (ZerothHomotopy X) ∧ Subsingleton (ZerothHomotopy X)
-- Mathlib/Algebra/Polynomial/Lifts.lean
/-- If `(s : S)` is in the image of `f`, then `monomial n s` lifts. -/
theorem monomial_mem_lifts {s : S} (n : ℕ) (h : s ∈ Set.range f) : monomial n s ∈ lifts f
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem lie_le_inf : ⁅I, J⁆ ≤ I ⊓ J
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma Φ_four : W.Φ 4 = X * W.preΨ₄ ^ 2 * W.Ψ₂Sq - W.Ψ₃ * (W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3)
-- Mathlib/Topology/Compactification/OnePoint.lean
@[simp]
theorem range_coe_inter_infty : range ((↑) : X → OnePoint X) ∩ {∞} = ∅
-- Mathlib/Data/Matrix/RowCol.lean
theorem updateRow_reindex [DecidableEq l] [DecidableEq m] (A : Matrix m n α) (i : l) (r : o → α)
    (e : m ≃ l) (f : n ≃ o) :
    updateRow (reindex e f A) i r = reindex e f (A.updateRow (e.symm i) fun j => r (f j))
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_le_iff_of_exists [IsWellOrder ι (· < ·)] {m : ι}
    (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@[simp]
theorem algebraMap_mk' (x : B) (hx : IsIntegral R x) : algebraMap A B (mk' A x hx) = x
-- Mathlib/Data/NNReal/Basic.lean
@[norm_cast]
theorem coe_iInf {ι : Sort*} (s : ι → ℝ≥0) : (↑(⨅ i, s i) : ℝ) = ⨅ i, ↑(s i)
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem map_apply_ιMulti {n : ℕ} (f : M →ₗ[R] N) (m : Fin n → M) :
    map f (ιMulti R n m) = ιMulti R n (f ∘ m)
-- Mathlib/Order/Interval/Set/OrdConnected.lean
theorem ordConnected_of_uIcc_subset_left (h : ∀ y ∈ s, [[x, y]] ⊆ s) : OrdConnected s
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_insert_of_symmetric_of_not_mem (hr : Symmetric r) (ha : a ∉ s) :
    (insert a s).Pairwise r ↔ s.Pairwise r ∧ ∀ b ∈ s, r a b
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem HasDerivAt.tendsto_slope_zero_left [PartialOrder 𝕜] (h : HasDerivAt f f' x) :
    Tendsto (fun t ↦ t⁻¹ • (f (x + t) - f x)) (𝓝[<] 0) (𝓝 f')
-- Mathlib/CategoryTheory/Shift/ShiftSequence.lean
lemma shiftIso_add'_inv_app (n m mn : M) (hnm : m + n = mn) (a a' a'' : M)
    (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).inv.app X =
      (shiftIso F m a' a'' ha'').inv.app X ≫
        (shiftIso F n a a' ha').inv.app ((shiftFunctor C m).obj X) ≫
        (shift F a).map ((shiftFunctorAdd' C m n mn hnm).inv.app X)
-- Mathlib/Algebra/Group/Nat.lean
/-- If `m` and `n` are natural numbers, then the natural number `m^n` is even
if and only if `m` is even and `n` is positive. -/
@[parity_simps] lemma even_pow : Even (m ^ n) ↔ Even m ∧ n ≠ 0
-- Mathlib/Algebra/Ring/Hom/Defs.lean
/-- Composition of non-unital ring homomorphisms is associative. -/
theorem comp_assoc {δ} {_ : NonUnitalNonAssocSemiring δ} (f : α →ₙ+* β) (g : β →ₙ+* γ)
    (h : γ →ₙ+* δ) : (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/Data/List/Lattice.lean
theorem forall_mem_of_forall_mem_union_left (h : ∀ x ∈ l₁ ∪ l₂, p x) : ∀ x ∈ l₁, p x
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- `liminf (c + xᵢ) = c + liminf xᵢ`. -/
lemma limsup_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
    Filter.limsup (fun i ↦ c + f i) F = c + Filter.limsup f F
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
lemma natTrailingDegree_X_pow (n : ℕ) :
    (X ^ n : R[X]).natTrailingDegree = n
-- Mathlib/Analysis/Convex/GaugeRescale.lean
theorem image_gaugeRescaleHomeomorph_interior {s t : Set E}
    (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) (hsb : IsVonNBounded ℝ s)
    (htc : Convex ℝ t) (ht₀ : t ∈ 𝓝 0) (htb : IsVonNBounded ℝ t) :
    gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb '' interior s = interior t
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma add_of_imp {x₁ x₂ y₁ y₂ : F} {h₁ : W.Nonsingular x₁ y₁} {h₂ : W.Nonsingular x₂ y₂}
    (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) : some h₁ + some h₂ = some (nonsingular_add h₁ h₂ hxy)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
theorem isLocallySurjective_iff_imagePresheaf_sheafify_eq_top' {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) :
    IsLocallySurjective J f ↔ (imagePresheaf f).sheafify J = ⊤
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem Complex.volume_sum_rpow_lt_one {p : ℝ} (hp : 1 ≤ p) :
    volume {x : ι → ℂ | ∑ i, ‖x i‖ ^ p < 1} =
      .ofReal ((π * Real.Gamma (2 / p + 1)) ^ card ι / Real.Gamma (2 * card ι / p + 1))
-- Mathlib/Data/List/AList.lean
theorem insertRec_insert_mk {C : AList β → Sort*} (H0 : C ∅)
    (IH : ∀ (a : α) (b : β a) (l : AList β), a ∉ l → C l → C (l.insert a b)) {a : α} (b : β a)
    {l : AList β} (h : a ∉ l) :
    @insertRec α β _ C H0 IH (l.insert a b) = IH a b l h (@insertRec α β _ C H0 IH l)
-- Mathlib/Topology/Order/LowerUpperTopology.lean
theorem isLowerSet_of_isClosed (h : IsClosed s) : IsLowerSet s
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem mk_length (s : List Char) : (String.mk s).length = s.length
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem map_eq_some' : x.map f = some b ↔ ∃ a, x = some a ∧ f a = b
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem restrict_comp_codRestrict {f : ι → α} {g : α → β} {b : Set α} (h : ∀ x, f x ∈ b) :
    b.restrict g ∘ b.codRestrict f h = g ∘ f
-- Mathlib/CategoryTheory/Localization/Triangulated.lean
lemma complete_distinguished_triangle_morphism (T₁ T₂ : Triangle D)
    (hT₁ : T₁ ∈ L.essImageDistTriang) (hT₂ : T₂ ∈ L.essImageDistTriang)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
    ∃ c, T₁.mor₂ ≫ c = b ≫ T₂.mor₂ ∧ T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃
-- Mathlib/RingTheory/Nakayama.lean
lemma top_ne_ideal_smul_of_le_jacobson_annihilator [Nontrivial M]
    [Module.Finite R M] {I} (h : I ≤ (Module.annihilator R M).jacobson) :
    (⊤ : Submodule R M) ≠ I • ⊤
-- Mathlib/Init/Order/LinearOrder.lean
theorem max_le {a b c : α} (h₁ : a ≤ c) (h₂ : b ≤ c) : max a b ≤ c
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_ball [Nontrivial E] (x : E) {r : ℝ} (hr : 0 ≤ r) :
    μ (ball x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 1)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- A function is `C^(n + 1)` if and only if it is differentiable,
  and its derivative (formulated in terms of `deriv`) is `C^n`. -/
theorem contDiff_succ_iff_deriv {n : ℕ} :
    ContDiff 𝕜 (n + 1 : ℕ) f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 n (deriv f₂)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem summable_toReal {f : α → ℝ≥0∞} (hsum : ∑' x, f x ≠ ∞) : Summable fun x => (f x).toReal
-- Mathlib/Order/Cover.lean
lemma reflTransGen_wcovBy_eq_reflTransGen_covBy [PartialOrder α] :
    ReflTransGen ((· : α) ⩿ ·) = ReflTransGen (· ⋖ ·)
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_of_mem_maximalAtlas [HasGroupoid M G] (hG : G.LocalInvariantProp G Q)
    (hQ : ∀ y, Q id univ y) (he : e ∈ maximalAtlas M G) : LiftPropOn Q e e.source
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem natDegree_mul (hp : p.Monic) (hq : q.Monic) :
    (p * q).natDegree = p.natDegree + q.natDegree
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
theorem isDiag_iff_proj_eq (z : α × α) : IsDiag (Sym2.mk z) ↔ z.1 = z.2
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isComplex_smul_iff : IsComplex (σ • w) ↔ IsComplex w
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem eq_of_forall_apply_eq (μ ν : FiniteMeasure Ω)
    (h : ∀ s : Set Ω, MeasurableSet s → μ s = ν s) : μ = ν
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem setIntegral_condexpL2_indicator (hs : MeasurableSet[m] s) (ht : MeasurableSet t)
    (hμs : μ s ≠ ∞) (hμt : μ t ≠ ∞) :
    ∫ x in s, (condexpL2 ℝ ℝ hm (indicatorConstLp 2 ht hμt 1) : α → ℝ) x ∂μ = (μ (t ∩ s)).toReal
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
@[simp]
theorem toContinuousLinearMap_norm [NormOneClass A] (φ : A →ₐ[𝕜] 𝕜) :
    ‖φ.toContinuousLinearMap‖ = 1
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem linearIsometryEquiv_mk' (e : P₁ → P₂) (e' : V₁ ≃ₗᵢ[𝕜] V₂) (p h) :
    (mk' e e' p h).linearIsometryEquiv = e'
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem mod_one (a : Ordinal) : a % 1 = 0
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_uniformContinuous_equiv : UniformContinuous (WithLp.equiv p (α × β))
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
theorem isOpen_iff {s : Set Γ₀} : IsOpen s ↔ (0 : Γ₀) ∉ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s
-- Mathlib/Order/Atoms.lean
theorem isCoatomic_iff_forall_isCoatomic_Ici [OrderTop α] :
    IsCoatomic α ↔ ∀ x : α, IsCoatomic (Set.Ici x)
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem IsCompactOperator.clm_comp [AddCommMonoid M₂] [Module R₂ M₂] [AddCommMonoid M₃]
    [Module R₃ M₃] {f : M₁ → M₂} (hf : IsCompactOperator f) (g : M₂ →SL[σ₂₃] M₃) :
    IsCompactOperator (g ∘ f)
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem mem_A_of_differentiable {ε : ℝ} (hε : 0 < ε) {x : E} (hx : DifferentiableAt 𝕜 f x) :
    ∃ R > 0, ∀ r ∈ Ioo (0 : ℝ) R, x ∈ A f (fderiv 𝕜 f x) r ε
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_coe_eq_self_iff {θ : ℝ} : (θ : Angle).toReal = θ ↔ -π < θ ∧ θ ≤ π
-- Mathlib/MeasureTheory/Measure/Haar/Unique.lean
@[to_additive]
theorem measurePreserving_zpow [CompactSpace G] [RootableBy G ℤ] {n : ℤ} (hn : n ≠ 0) :
    MeasurePreserving (fun g : G => g ^ n) μ μ
-- Mathlib/Order/Hom/Bounded.lean
/-- The type of bounded order homomorphisms from `α` to `β`. -/
structure BoundedOrderHom (α β : Type*) [Preorder α] [Preorder β] [BoundedOrder α]
  [BoundedOrder β] extends OrderHom α β where
  /-- The function preserves the top element. The preferred spelling is `map_top`. -/
  map_top' : toFun ⊤ = ⊤
  /-- The function preserves the bottom element. The preferred spelling is `map_bot`. -/
  map_bot' : toFun ⊥ = ⊥
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- Hölder's inequality for functions `α → ℝ`. The integral of the product of two nonnegative
functions is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are conjugate
exponents. -/
theorem integral_mul_le_Lp_mul_Lq_of_nonneg {p q : ℝ} (hpq : p.IsConjExponent q) {f g : α → ℝ}
    (hf_nonneg : 0 ≤ᵐ[μ] f) (hg_nonneg : 0 ≤ᵐ[μ] g) (hf : Memℒp f (ENNReal.ofReal p) μ)
    (hg : Memℒp g (ENNReal.ofReal q) μ) :
    ∫ a, f a * g a ∂μ ≤ (∫ a, f a ^ p ∂μ) ^ (1 / p) * (∫ a, g a ^ q ∂μ) ^ (1 / q)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem rotateR_nil (y : α) (r : Ordnode α) : rotateR nil y r = node' nil y r
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
theorem pullback_snd_image_fst_preimage (f : X ⟶ Z) (g : Y ⟶ Z) (U : Set X) :
    (pullback.snd f g) '' ((pullback.fst f g) ⁻¹' U) =
      g ⁻¹' (f '' U)
-- Mathlib/Data/List/Zip.lean
theorem unzip_eq_map : ∀ l : List (α × β), unzip l = (l.map Prod.fst, l.map Prod.snd)
-- Mathlib/Data/Nat/Choose/Lucas.lean
/-- **Lucas's Theorem**: For primes `p`, `choose n k` is congruent to the product of
`choose (⌊n / p ^ i⌋ % p) (⌊k / p ^ i⌋ % p)` over `i` modulo `p`. -/
theorem choose_modEq_prod_range_choose {a : ℕ} (ha₁ : n < p ^ a) (ha₂ : k < p ^ a) :
    choose n k ≡ ∏ i in range a, choose (n / p ^ i % p) (k / p ^ i % p) [ZMOD p]
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- Restriction of a measure to a subset is monotone both in set and in measure. -/
@[mono]
theorem restrict_mono {_m0 : MeasurableSpace α} ⦃s s' : Set α⦄ (hs : s ⊆ s') ⦃μ ν : Measure α⦄
    (hμν : μ ≤ ν) : μ.restrict s ≤ ν.restrict s'
-- Mathlib/Combinatorics/Additive/Corner/Roth.lean
@[simp] private lemma card_triangleIndices : (triangleIndices A).card = A.card
-- Mathlib/Data/List/Sort.lean
theorem sublist_orderedInsert (x : α) (xs : List α) : xs <+ xs.orderedInsert r x
-- Mathlib/LinearAlgebra/Matrix/LDL.lean
/-- **LDL decomposition**: any positive definite matrix `S` can be
decomposed as `S = LDLᴴ` where `L` is a lower-triangular matrix and `D` is a diagonal matrix.  -/
theorem LDL.lower_conj_diag : LDL.lower hS * LDL.diag hS * (LDL.lower hS)ᴴ = S
-- Mathlib/Data/Set/Card.lean
theorem ncard_def (s : Set α) : s.ncard = ENat.toNat s.encard
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_product_right (s : Finset β) (t : Finset γ) (f : β × γ → α) :
    (s ×ˢ t).inf f = t.inf fun i' => s.inf fun i => f ⟨i, i'⟩
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem differentiableAt_arctan (x : ℝ) : DifferentiableAt ℝ arctan x
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp] lemma coe_tosInfHom (f : CompleteLatticeHom α β) : ⇑f.tosInfHom = f
-- Mathlib/Topology/Basic.lean
theorem Filter.Tendsto.lift'_closure (hf : Continuous f) {l l'} (h : Tendsto f l l') :
    Tendsto f (l.lift' closure) (l'.lift' closure)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_lt_of_translationNumber_lt_nat {n : ℕ} (h : τ f < n) (x : ℝ) : f x < x + n
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma toSpec_surjective {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) :
    Function.Surjective (toSpec 𝒜 f)
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem conjTranspose_row [Star α] (v : m → α) : (row ι v)ᴴ = col ι (star v)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem WithTop.coe_sSup' [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α)
-- Mathlib/Order/Heyting/Regular.lean
@[simp, norm_cast]
theorem coe_compl (a : Regular α) : (↑aᶜ : α) = (a : α)ᶜ
-- Mathlib/Order/Max.lean
theorem IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem mem_ball_self (h : 0 < ε) : x ∈ ball x ε
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
/-- `Complex.inv_cpow_eq_ite` with the `ite` on the other side. -/
theorem inv_cpow_eq_ite' (x : ℂ) (n : ℂ) :
    (x ^ n)⁻¹ = if x.arg = π then conj (x⁻¹ ^ conj n) else x⁻¹ ^ n
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
theorem preimage_inversion_perpBisector (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R ⁻¹' perpBisector c y = sphere (inversion c R y) (R ^ 2 / dist y c) \ {c}
-- Mathlib/Data/Nat/Prime/Defs.lean
@[simp]
theorem minFac_one : minFac 1 = 1
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
@[simp]
theorem mem_measurableCylinders (t : Set (∀ i, α i)) :
    t ∈ measurableCylinders α ↔ ∃ s S, MeasurableSet S ∧ t = cylinder s S
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem sdiff_symmDiff_eq_sup : (a \ b) ∆ b = a ⊔ b
-- Mathlib/Topology/Connected/Basic.lean
theorem Continuous.image_connectedComponentIn_subset [TopologicalSpace β] {f : α → β} {s : Set α}
    {a : α} (hf : Continuous f) (hx : a ∈ s) :
    f '' connectedComponentIn s a ⊆ connectedComponentIn (f '' s) (f a)
-- Mathlib/RingTheory/Localization/Basic.lean
theorem sec_snd_ne_zero [Nontrivial R] (hM : M ≤ nonZeroDivisors R) (x : S) :
    ((sec M x).snd : R) ≠ 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem isometry [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) : Isometry f
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem dvd_gcd_mul_iff_dvd_mul : x ∣ gcd x n * m ↔ x ∣ n * m
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffine_zero : toAffine W ![1, 1, 0] = 0
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
/-- If `P` respects isos, then `stalkwise P` is local at the target. -/
lemma stalkwiseIsLocalAtTarget_of_respectsIso (hP : RingHom.RespectsIso P) :
    IsLocalAtTarget (stalkwise P)
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp] theorem zero_fst : (0 : X q).1 = 0
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem mem_reverse_iff {a : α} {s : Cycle α} : a ∈ s.reverse ↔ a ∈ s
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_add_const_Iio : (fun x => x + a) ⁻¹' Iio b = Iio (b - a)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem subset_def {x y : ZFSet.{u}} : x ⊆ y ↔ ∀ ⦃z⦄, z ∈ x → z ∈ y
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma mul_delta_eq_smul_delta {f : ℕ → ℂ} : f * δ = f 1 • δ
-- Mathlib/Data/Set/Lattice.lean
theorem subset_iUnion : ∀ (s : ι → Set β) (i : ι), s i ⊆ ⋃ i, s i
-- Mathlib/RingTheory/PowerBasis.lean
theorem exists_eq_aeval' (pb : PowerBasis R S) (y : S) : ∃ f : R[X], y = aeval pb.gen f
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem powerlt_aleph0_le (c : Cardinal) : c ^< ℵ₀ ≤ max c ℵ₀
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq_norm_posPart_sub (f : α →₁ₛ[μ] ℝ) : integral f = ‖posPart f‖ - ‖negPart f‖
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_add (m n) : xn a1 (m + n) = xn a1 m * xn a1 n + d a1 * yn a1 m * yn a1 n
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem mapRange_add {v w : VectorMeasure α M} {f : M →+ N} (hf : Continuous f) :
    (v + w).mapRange f hf = v.mapRange f hf + w.mapRange f hf
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.isPrime_of_prime {P : Ideal A} (h : Prime P) : IsPrime P
-- Mathlib/CategoryTheory/GradedObject/Unitor.lean
lemma mapBifunctor_triangle :
    (mapBifunctorAssociator associator τ.ρ₁₂ τ.ρ₂₃ X₁ ((single₀ I₂).obj X₂) X₃).hom ≫
    mapBifunctorMapMap G π (𝟙 X₁) (mapBifunctorLeftUnitor F₂ X₂ e₂ τ.p₂₃ τ.h₃ X₃).hom =
      mapBifunctorMapMap G π (mapBifunctorRightUnitor F₁ X₂ e₁ τ.p₁₂ τ.h₁ X₁).hom (𝟙 X₃)
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem id_apply (a : α) : BotHom.id α a = a
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem hasBasis_coLindelof : (coLindelof X).HasBasis IsLindelof compl
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem hasDerivWithinAt_aeval (x : 𝕜) (s : Set 𝕜) :
    HasDerivWithinAt (fun x => aeval x q) (aeval x (derivative q)) s x
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem unit_mul_mem_iff_mem {x y : α} (hy : IsUnit y) : y * x ∈ I ↔ x ∈ I
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp]
theorem zero_div (a : G₀) : 0 / a = 0
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem isMax_top : IsMax (⊤ : α)
-- Mathlib/CategoryTheory/Filtered/Basic.lean
theorem of_isTerminal {X : C} (h : IsTerminal X) : IsFiltered C
-- Mathlib/Data/PFunctor/Univariate/M.lean
@[simp]
theorem agree'_refl {n : ℕ} (x : M F) : Agree' n x x
-- Mathlib/Data/Bool/Basic.lean
theorem xor_iff_ne : ∀ {x y : Bool}, xor x y = true ↔ x ≠ y
-- Mathlib/Data/Opposite.lean
theorem unop_eq_iff_eq_op {x} {y : α} : unop x = y ↔ x = op y
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_option {ι} (s : Option ι → Set α) : ⋃ o, s o = s none ∪ ⋃ i, s (some i)
-- Mathlib/Data/Finset/Card.lean
theorem card_image_le [DecidableEq β] : (s.image f).card ≤ s.card
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem domRestrict_apply {f : E →ₗ.[R] F} {S : Submodule R E} ⦃x : ↥(S ⊓ f.domain)⦄ ⦃y : f.domain⦄
    (h : (x : E) = y) : f.domRestrict S x = f y
-- Mathlib/Analysis/RCLike/Basic.lean
theorem norm_im_le_norm (z : K) : ‖im z‖ ≤ ‖z‖
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem sub_im (z w : ℂ) : (z - w).im = z.im - w.im
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffAt.of_succ {n : ℕ} (h : ContMDiffAt I I' n.succ f x) : ContMDiffAt I I' n f x
-- Mathlib/Order/Lattice.lean
/-- Pointwise supremum of two antitone functions is an antitone function. -/
protected theorem sup [Preorder α] [SemilatticeSup β] {f g : α → β} {s : Set α}
    (hf : AntitoneOn f s) (hg : AntitoneOn g s) : AntitoneOn (f ⊔ g) s
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem trans_transHomeomorph (e : PartialHomeomorph X Y) (e' : PartialHomeomorph Y Z)
    (f'' : Z ≃ₜ Z') :
    (e.trans e').transHomeomorph f'' = e.trans (e'.transHomeomorph f'')
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem intervalIntegrable_id : IntervalIntegrable (fun x => x) μ a b