ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `f : α → E` is an integrable function, then either it is a.e. equal to the constant
`⨍ x, f x ∂μ` or there exists a measurable set such that `μ t ≠ 0`, `μ tᶜ ≠ 0`, and the average
values of `f` over `t` and `tᶜ` are different. -/
theorem ae_eq_const_or_exists_average_ne_compl [IsFiniteMeasure μ] (hfi : Integrable f μ) :
    f =ᵐ[μ] const α (⨍ x, f x ∂μ) ∨
      ∃ t, MeasurableSet t ∧ μ t ≠ 0 ∧ μ tᶜ ≠ 0 ∧ (⨍ x in t, f x ∂μ) ≠ ⨍ x in tᶜ, f x ∂μ
-- Mathlib/CategoryTheory/Abelian/Exact.lean
theorem Abelian.tfae_mono {X Y : C} (f : X ⟶ Y) (Z : C) :
    TFAE [Mono f, kernel.ι f = 0, (ShortComplex.mk (0 : Z ⟶ X) f zero_comp).Exact]
-- Mathlib/Data/List/Lattice.lean
@[simp]
theorem inter_nil' (l : List α) : l ∩ [] = []
-- Mathlib/NumberTheory/LSeries/RiemannZeta.lean
/-- Special case of `zeta_eq_tsum_one_div_nat_cpow` when the argument is in `ℕ`, so the power
function can be expressed using naïve `pow` rather than `cpow`. -/
theorem zeta_nat_eq_tsum_of_gt_one {k : ℕ} (hk : 1 < k) :
    riemannZeta k = ∑' n : ℕ, 1 / (n : ℂ) ^ k
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem mk_eq_zero {g : R[X]} : mk f g = 0 ↔ f ∣ g
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_of_nonempty_subtype [Nonempty (↥s)] : s.Nonempty
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
/-- If `S` is finite and `IsCyclotomicExtension S K A`, then `finiteDimensional K A`. -/
theorem finiteDimensional (C : Type z) [Finite S] [CommRing C] [Algebra K C] [IsDomain C]
    [IsCyclotomicExtension S K C] : FiniteDimensional K C
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem coe_mk (f : ℕ → R) (hf) : @DFunLike.coe (ArithmeticFunction R) _ _ _
    (ZeroHom.mk f hf) = f
-- Mathlib/AlgebraicTopology/DoldKan/NCompGamma.lean
theorem identity_N₂ :
    (𝟙 (N₂ : Karoubi (SimplicialObject C) ⥤ _) ◫ N₂Γ₂.inv) ≫
    (Functor.associator _ _ _).inv ≫ Γ₂N₂.natTrans ◫ 𝟙 (@N₂ C _ _) = 𝟙 N₂
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem discr_smul (a : R) : (a • Q).discr = a ^ Fintype.card n * Q.discr
-- Mathlib/Topology/ShrinkingLemma.lean
/-- **Shrinking lemma**. A point-finite open cover of a closed subset of a normal space can be
"shrunk" to a new closed cover so that each new closed set is contained in the corresponding
original open set. See also `exists_subset_iUnion_closure_subset` for a stronger statement. -/
theorem exists_subset_iUnion_closed_subset (hs : IsClosed s) (uo : ∀ i, IsOpen (u i))
    (uf : ∀ x ∈ s, { i | x ∈ u i }.Finite) (us : s ⊆ ⋃ i, u i) :
    ∃ v : ι → Set X, s ⊆ iUnion v ∧ (∀ i, IsClosed (v i)) ∧ ∀ i, v i ⊆ u i
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
/-- The submonoid generated by an element of a monoid equals the set of natural number powers of
    the element. -/
theorem mem_closure_singleton {x y : M} : y ∈ closure ({x} : Set M) ↔ ∃ n : ℕ, x ^ n = y
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_eq_one {a : Cardinal.{v}} : lift.{u} a = 1 ↔ a = 1
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem nmul_one (a : Ordinal) : a ⨳ 1 = a
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem ringHom_eval₂_intCastRingHom {R S : Type*} [Ring R] [Ring S] (p : ℤ[X]) (f : R →+* S)
    (r : R) : f (eval₂ (Int.castRingHom R) r p) = eval₂ (Int.castRingHom S) (f r) p
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem prod_eq_of_fintype {α : Type u} [h : Fintype α] (f : α → Cardinal.{v}) :
    prod f = Cardinal.lift.{u} (∏ i, f i)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem DifferentiableWithinAt.finset_prod (hd : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (f i) s x) :
    DifferentiableWithinAt 𝕜 (∏ i ∈ u, f i ·) s x
-- Mathlib/Data/Multiset/Basic.lean
@[ext]
theorem ext' {s t : Multiset α} : (∀ a, count a s = count a t) → s = t
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
protected theorem Perm.rfl {l : List α} : l ~ l
-- Mathlib/Data/Finsupp/Defs.lean
theorem single_eq_set_indicator : ⇑(single a b) = Set.indicator {a} fun _ => b
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_eq_top {s : α} (h : ¬P s) : extend m s = ∞
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem isOpen_resolventSet (a : A) : IsOpen (ρ a)
-- Mathlib/Algebra/GroupWithZero/Basic.lean
lemma zpow_add_one₀ (ha : a ≠ 0) : ∀ n : ℤ, a ^ (n + 1) = a ^ n * a
-- Mathlib/Data/Holor.lean
/-- Two holors are equal if all their slices are equal. -/
theorem slice_eq (x : Holor α (d :: ds)) (y : Holor α (d :: ds)) (h : slice x = slice y) : x = y
-- Mathlib/Topology/Basic.lean
theorem mem_closure_iff_comap_neBot :
    x ∈ closure s ↔ NeBot (comap ((↑) : s → X) (𝓝 x))
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem frequently_filterAt_iff {x : α} {P : Set α → Prop} :
    (∃ᶠ a in v.filterAt x, P a) ↔ ∀ ε > (0 : ℝ), ∃ a ∈ v.setsAt x, a ⊆ closedBall x ε ∧ P a
-- Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean
lemma IsSemisimple.maxGenEigenspace_eq_eigenspace
    (hf : f.IsSemisimple) (μ : R) :
    f.maxGenEigenspace μ = f.eigenspace μ
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[simp, reassoc]
theorem lift_fac (H' : Set.range g.1.base ⊆ Set.range f.1.base) : lift f g H' ≫ f = g
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_const_smul_le (c : 𝕜) (f : α → F) :
    eLpNormEssSup (c • f) μ ≤ ‖c‖₊ • eLpNormEssSup f μ
-- Mathlib/Tactic/NormNum/LegendreSymbol.lean
theorem jacobiSymNat.qr₃_mod (a b ab : ℕ) (r : ℤ) (ha : a % 4 = 3) (hb : b % 4 = 3)
    (hab : b % a = ab) (hr : jacobiSymNat ab a = r) : jacobiSymNat a b = -r
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot
-- Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean
theorem hasStrictFDerivAt_log_real {x : ℂ} (h : x ∈ slitPlane) :
    HasStrictFDerivAt log (x⁻¹ • (1 : ℂ →L[ℝ] ℂ)) x
-- Mathlib/NumberTheory/FunctionField.lean
theorem inftyValuedFqt.def {x : RatFunc Fq} :
    @Valued.v (RatFunc Fq) _ _ _ (inftyValuedFqt Fq) x = inftyValuationDef Fq x
-- Mathlib/Data/Set/Lattice.lean
/-- An equality version of this lemma is `iUnion_iInter_of_monotone` in `Data.Set.Finite`. -/
theorem iUnion_iInter_subset {s : ι → ι' → Set α} : (⋃ j, ⋂ i, s i j) ⊆ ⋂ i, ⋃ j, s i j
-- Mathlib/Data/Set/Function.lean
theorem EqOn.injOn_iff (H : EqOn f₁ f₂ s) : InjOn f₁ s ↔ InjOn f₂ s
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
@[simp] theorem if_true {_ : Decidable True} (t e : α) : ite True t e = t
-- Mathlib/Data/Int/ModEq.lean
@[simp]
theorem add_modEq_left : n + a ≡ a [ZMOD n]
-- Mathlib/Topology/OmegaCompletePartialOrder.lean
theorem isOpen_univ : IsOpen α univ
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp, norm_cast]
lemma ofENat_inj {m n : ℕ∞} : (m : Cardinal) = n ↔ m = n
-- Mathlib/Order/Interval/Finset/Basic.lean
/-- In a locally finite preorder, `≤` is the transitive closure of `⩿`. -/
lemma le_iff_transGen_wcovBy [Preorder α] [LocallyFiniteOrder α] {x y : α} :
    x ≤ y ↔ TransGen (· ⩿ ·) x y
-- Mathlib/Topology/Instances/Matrix.lean
theorem Continuous.matrix_conjTranspose [Star R] [ContinuousStar R] {A : X → Matrix m n R}
    (hA : Continuous A) : Continuous fun x => (A x)ᴴ
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_def : ‖f‖ = sInf { c | 0 ≤ (c : ℝ) ∧ ∀ m, ‖f m‖ ≤ c * ∏ i, ‖m i‖ }
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem cancel_factors_le {α} [LinearOrderedField α] {a b ad bd a' b' gcd : α}
    (ha : ad * a = a') (hb : bd * b = b') (had : 0 < ad) (hbd : 0 < bd) (hgcd : 0 < gcd) :
    (a ≤ b) = (1 / gcd * (bd * a') ≤ 1 / gcd * (ad * b'))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem DifferentiableAt.sinh (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => Real.sinh (f x)) x
-- Mathlib/Order/PrimeIdeal.lean
theorem I_isProper : IsProper IF.I
-- Mathlib/Order/WithBot.lean
theorem le_untop_iff {a : α} {b : WithTop α} (h : b ≠ ⊤) :
    a ≤ untop b h ↔ (a : WithTop α) ≤ b
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pwFilter_sublist [DecidableRel (α := α) R] : ∀ l : List α, pwFilter R l <+ l
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem filterMap_filterMap (f : α → Option β) (g : β → Option γ) (l : List α) :
    filterMap g (filterMap f l) = filterMap (fun x => (f x).bind g) l
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem exists_conts_b_of_den {B : K} (nth_denom_eq : g.dens n = B) :
    ∃ conts, g.conts n = conts ∧ conts.b = B
-- Mathlib/RingTheory/Polynomial/Dickson.lean
@[simp]
theorem dickson_two_zero : ∀ n : ℕ, dickson 2 (0 : R) n = X ^ n
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- General fencing theorem for continuous functions with an estimate on the norm of the derivative.
Let `f` and `B` be continuous functions on `[a, b]` such that

* `‖f a‖ ≤ B a`;
* `f` has right derivative `f'` at every point of `[a, b)`;
* `B` has derivative `B'` everywhere on `ℝ`;
* the norm of `f'` is strictly less than `B'` whenever `‖f x‖ = B x`.

Then `‖f x‖ ≤ B x` everywhere on `[a, b]`. We use one-sided derivatives in the assumptions
to make this theorem work for piecewise differentiable functions.
-/
theorem image_norm_le_of_norm_deriv_right_lt_deriv_boundary {f' : ℝ → E}
    (hf : ContinuousOn f (Icc a b)) (hf' : ∀ x ∈ Ico a b, HasDerivWithinAt f (f' x) (Ici x) x)
    {B B' : ℝ → ℝ} (ha : ‖f a‖ ≤ B a) (hB : ∀ x, HasDerivAt B (B' x) x)
    (bound : ∀ x ∈ Ico a b, ‖f x‖ = B x → ‖f' x‖ < B' x) : ∀ ⦃x⦄, x ∈ Icc a b → ‖f x‖ ≤ B x
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isNat_zpow_neg {α : Type*} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsNat (a ^ nb)⁻¹ ne) :
    IsNat (a ^ b) ne
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.left_mem_affineSpan_of_right_ne {x y z : P} (h : Wbtw R x y z) (hne : z ≠ y) :
    x ∈ line[R, z, y]
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem HasSum.mul_right (a₂) (hf : HasSum f a₁) : HasSum (fun i ↦ f i * a₂) (a₁ * a₂)
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
lemma ValuationRing.cond {A : Type u} [CommRing A] [IsDomain A] [ValuationRing A] (a b : A) :
    ∃ c : A, a * c = b ∨ b * c = a
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma normEDS_odd (m : ℕ) : normEDS b c d (2 * (m + 2) + 1) =
    normEDS b c d (m + 4) * normEDS b c d (m + 2) ^ 3 -
      normEDS b c d (m + 1) * normEDS b c d (m + 3) ^ 3
-- Mathlib/Data/List/MinMax.lean
theorem argmin_mem : ∀ {l : List α} {m : α}, m ∈ argmin f l → m ∈ l
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_subset_Icc_union_Ioc : Icc a c ⊆ Icc a b ∪ Ioc b c
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- Technical lemma which will give us differentiability of Hurwitz zeta at `s = 0`. -/
lemma differentiableAt_update_of_residue
    {Λ : ℂ → ℂ} (hf : ∀ (s : ℂ) (_ : s ≠ 0) (_ : s ≠ 1), DifferentiableAt ℂ Λ s)
    {L : ℂ} (h_lim : Tendsto (fun s ↦ s * Λ s) (𝓝[≠] 0) (𝓝 L)) (s : ℂ) (hs' : s ≠ 1) :
    DifferentiableAt ℂ (Function.update (fun s ↦ Λ s / Gammaℝ s) 0 (L / 2)) s
-- Mathlib/Topology/Order/OrderClosed.lean
theorem eventually_le_nhds (hab : a < b) : ∀ᶠ x in 𝓝 a, x ≤ b
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
theorem lift_uniq (H' : Set.range g.1.base ⊆ Set.range f.1.base) (l : Y ⟶ X) (hl : l ≫ f = g) :
    l = lift f g H'
-- Mathlib/RingTheory/Ideal/Prod.lean
@[simp]
theorem mem_prod {r : R} {s : S} : (⟨r, s⟩ : R × S) ∈ prod I J ↔ r ∈ I ∧ s ∈ J
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[aesop safe apply (rule_sets := [SetLike])]
theorem smul_mem [Monoid R] [DistribMulAction R A] [StarModule R A] (r : R) {x : A}
    (h : x ∈ skewAdjoint A) : r • x ∈ skewAdjoint A
-- Mathlib/Algebra/Group/Nat.lean
lemma two_mul_div_two_of_even : Even n → 2 * (n / 2) = n
-- Mathlib/Data/PNat/Factors.lean
theorem prod_dvd_iff {u v : PrimeMultiset} : u.prod ∣ v.prod ↔ u ≤ v
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem ucs_bot_one : (⊥ : LieSubmodule R L M).ucs 1 = LieModule.maxTrivSubmodule R L M
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem apply_mk_symm (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e ⟨b, e.symm b y⟩ = (b, y)
-- Mathlib/Data/Set/Subsingleton.lean
@[simp]
theorem subsingleton_empty : (∅ : Set α).Subsingleton
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem getLsb_concat (x : BitVec w) (b : Bool) (i : Nat) :
    (concat x b).getLsb i = if i = 0 then b else x.getLsb (i - 1)
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_X_sub_C_isSolvable (x : F) : IsSolvable (X - C x).Gal
-- Mathlib/Data/Finsupp/Basic.lean
theorem mk_mem_graph_iff {a : α} {m : M} {f : α →₀ M} : (a, m) ∈ f.graph ↔ f a = m ∧ m ≠ 0
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_zero : degree (0 : R[X]) = ⊥
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eq_of_degree_sub_lt_of_eval_index_eq (hvs : Set.InjOn v s)
    (degree_fg_lt : (f - g).degree < s.card) (eval_fg : ∀ i ∈ s, f.eval (v i) = g.eval (v i)) :
    f = g
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
/-- Restrict the codomain of a continuous alternating map to a submodule. -/
@[simps!]
def codRestrict (f : M [⋀^ι]→L[R] N) (p : Submodule R N) (h : ∀ v, f v ∈ p) : M [⋀^ι]→L[R] p
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma self_intCast_mul : Commute a (n * a : α)
-- Mathlib/Data/Matroid/Restrict.lean
theorem Basis.eq_exchange_of_diff_eq_singleton (hI : M.Basis I X) (hJ : M.Basis J X)
    (hIJ : I \ J = {e}) : ∃ f ∈ J \ I, J = insert f I \ {e}
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp, norm_cast]
theorem coe_inj : (φ : MvPowerSeries σ R) = ψ ↔ φ = ψ
-- Mathlib/Topology/MetricSpace/Basic.lean
/-- If `f : β → α` sends any two distinct points to points at distance at least `ε > 0`, then
`f` is a uniform embedding with respect to the discrete uniformity on `β`. -/
theorem uniformEmbedding_bot_of_pairwise_le_dist {β : Type*} {ε : ℝ} (hε : 0 < ε) {f : β → α}
    (hf : Pairwise fun x y => ε ≤ dist (f x) (f y)) :
    @UniformEmbedding _ _ ⊥ (by infer_instance) f
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_id : LatticeHom.dual.symm (LatticeHom.id _) = LatticeHom.id α
-- Mathlib/Order/GaloisConnection.lean
protected theorem dfun {ι : Type u} {α : ι → Type v} {β : ι → Type w} [∀ i, Preorder (α i)]
    [∀ i, Preorder (β i)] (l : ∀ i, α i → β i) (u : ∀ i, β i → α i)
    (gc : ∀ i, GaloisConnection (l i) (u i)) :
    GaloisConnection (fun (a : ∀ i, α i) i => l i (a i)) fun b i => u i (b i)
-- Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean
theorem le_rpow_one_add_norm_iff_norm_le {r t : ℝ} (hr : 0 < r) (ht : 0 < t) (x : E) :
    t ≤ (1 + ‖x‖) ^ (-r) ↔ ‖x‖ ≤ t ^ (-r⁻¹) - 1
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.kerTotal_mkQ_single_algebraMap (x y) : (y𝖣algebraMap R S x) = 0
-- Mathlib/Algebra/Order/Monovary.lean
lemma monovaryOn_inv₀ (hf : ∀ i ∈ s, 0 < f i) (hg : ∀ i ∈ s, 0 < g i) :
    MonovaryOn f⁻¹ g⁻¹ s ↔ MonovaryOn f g s
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- `MulHomClass F M N` states that `F` is a type of multiplication-preserving homomorphisms.

You should declare an instance of this typeclass when you extend `MulHom`.
-/
@[to_additive]
class MulHomClass (F : Type*) (M N : outParam Type*) [Mul M] [Mul N] [FunLike F M N] : Prop where
  /-- The proposition that the function preserves multiplication -/
  map_mul : ∀ (f : F) (x y : M), f (x * y) = f x * f y
-- Mathlib/Data/NNRat/Defs.lean
theorem lt_def {p q : ℚ≥0} : p < q ↔ p.num * q.den < q.num * p.den
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_mono_left' (T T' : Set α → E →L[ℝ] G'')
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α →ₛ E)
    (hf : Integrable f μ) : setToSimpleFunc T f ≤ setToSimpleFunc T' f
-- Mathlib/Data/Nat/Defs.lean
lemma add_mod_eq_add_mod_right (c : ℕ) (H : a % d = b % d) : (a + c) % d = (b + c) % d
-- Mathlib/Algebra/Associated/Basic.lean
theorem mk_pow (a : α) (n : ℕ) : Associates.mk (a ^ n) = Associates.mk a ^ n
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem single_eq_of_ne (h : a ≠ a') : (single a b : α →₀ M) a' = 0
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem DifferentiableOn.inv (hf : DifferentiableOn 𝕜 h S) (hz : ∀ x ∈ S, h x ≠ 0) :
    DifferentiableOn 𝕜 (fun x => (h x)⁻¹) S
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem bot_coe : ((⊥ : Submodule R M) : Set M) = {0}
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
theorem dist_lt_iff_dist_coe_center_lt :
    dist z w < r ↔ dist (z : ℂ) (w.center r) < w.im * Real.sinh r
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem erase_eq_eraseTR : @List.erase = @eraseTR
-- Mathlib/Order/Bounded.lean
theorem unbounded_inter_ge [LinearOrder α] (a : α) :
    Unbounded (· > ·) (s ∩ { b | b ≤ a }) ↔ Unbounded (· > ·) s
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_fderivWithin :
    smulRight (1 : 𝕜 →L[𝕜] 𝕜) (derivWithin f s x) = fderivWithin 𝕜 f s x
-- Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean
@[reassoc (attr := simp)]
theorem homotopyEquiv_inv_ι {X : C} (I J : InjectiveResolution X) :
    J.ι ≫ (homotopyEquiv I J).inv = I.ι
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤
-- Mathlib/LinearAlgebra/Charpoly/Basic.lean
theorem minpoly_dvd_charpoly {K : Type u} {M : Type v} [Field K] [AddCommGroup M] [Module K M]
    [FiniteDimensional K M] (f : M →ₗ[K] M) : minpoly K f ∣ f.charpoly
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem frequently_ae_iff {p : α → Prop} : (∃ᵐ a ∂μ, p a) ↔ μ { a | p a } ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
/-- The exponential map in a commutative Banach algebra `𝔸` over a normed field `𝕂` of
characteristic zero has strict Fréchet derivative `exp 𝕂 x • 1 : 𝔸 →L[𝕂] 𝔸` at any point `x` in
the disk of convergence. -/
theorem hasStrictFDerivAt_exp_of_mem_ball [CharZero 𝕂] {x : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    HasStrictFDerivAt (exp 𝕂) (exp 𝕂 x • (1 : 𝔸 →L[𝕂] 𝔸)) x
-- Mathlib/Order/Filter/Bases.lean
theorem ofSets_filter_eq_generate (s : Set (Set α)) :
    (FilterBasis.ofSets s).filter = generate s
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.trans_tendsto_nhds (hfg : f =O[l] g') {y : F'} (hg : Tendsto g' l (𝓝 y)) :
    f =O[l] (fun _x => 1 : α → F)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
theorem ι_mul_ι (r₁ r₂) : ι (0 : QuadraticForm R R) r₁ * ι (0 : QuadraticForm R R) r₂ = 0
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
lemma nnreal_iff [Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A] {a : A} :
    QuasispectrumRestricts a ContinuousMap.realToNNReal ↔ ∀ x ∈ σₙ ℝ a, 0 ≤ x
-- Mathlib/Topology/Sheaves/SheafOfFunctions.lean
/-- The presheaf of not-necessarily-continuous functions to
a target type `T` satsifies the sheaf condition.
-/
theorem toType_isSheaf (T : Type u) : (presheafToType X T).IsSheaf
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem integrableOn_Ioi_of_intervalIntegral_norm_bounded (I a : ℝ)
    (hfi : ∀ i, IntegrableOn f (Ioc a (b i)) μ) (hb : Tendsto b l atTop)
    (h : ∀ᶠ i in l, (∫ x in a..b i, ‖f x‖ ∂μ) ≤ I) : IntegrableOn f (Ioi a) μ
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem tsum_apply {ι α : Type*} {f : ι → α → ℝ≥0∞} {x : α} :
    (∑' i, f i) x = ∑' i, f i x
-- Mathlib/Algebra/Module/Equiv/Basic.lean
/-- Any two modules that are subsingletons are isomorphic. -/
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂
-- Mathlib/Data/Set/Finite.lean
theorem finite_def {s : Set α} : s.Finite ↔ Nonempty (Fintype s)
-- Mathlib/Topology/Sheaves/Limits.lean
theorem isSheaf_of_isLimit [HasLimits C] {X : TopCat} (F : J ⥤ Presheaf.{v} C X)
    (H : ∀ j, (F.obj j).IsSheaf) {c : Cone F} (hc : IsLimit c) : c.pt.IsSheaf
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
/-- An auxiliary lemma for manipulating sequence indices. -/
theorem lift_index_left {f : PadicSeq p} (hf : ¬f ≈ 0) (v1 v3 : ℕ) :
    padicNorm p (f (stationaryPoint hf)) =
    padicNorm p (f (max v1 (max (stationaryPoint hf) v3)))
-- Mathlib/Algebra/Homology/HomologySequence.lean
@[reassoc (attr := simp)]
lemma opcyclesToCycles_homologyπ :
    K.opcyclesToCycles i j ≫ K.homologyπ j = 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability]
theorem measurableSet_closedBall : MeasurableSet (Metric.closedBall x ε)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
/-- The function `fun (x, y) => x ^ y` is infinitely smooth at `(x, y)` unless `x = 0`. -/
theorem contDiffAt_rpow_of_ne (p : ℝ × ℝ) (hp : p.1 ≠ 0) {n : ℕ∞} :
    ContDiffAt ℝ n (fun p : ℝ × ℝ => p.1 ^ p.2) p
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem comp_id (f : L₁ →ₗ⁅R⁆ L₂) : f.comp (id : L₁ →ₗ⁅R⁆ L₁) = f
-- Mathlib/RingTheory/Algebraic.lean
/-- Transfer `Algebra.IsAlgebraic` across an `AlgEquiv`. -/
theorem AlgEquiv.isAlgebraic (e : A ≃ₐ[R] B)
    [Algebra.IsAlgebraic R A] : Algebra.IsAlgebraic R B
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
lemma conjTranspose_mul_self_mulVec_eq_zero (A : Matrix m n R) (v : n → R) :
    (Aᴴ * A) *ᵥ v = 0 ↔ A *ᵥ v = 0
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem orderTop_add_orderTop_le_orderTop_mul {Γ} [LinearOrderedCancelAddCommMonoid Γ]
    [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    x.orderTop + y.orderTop ≤ (x * y).orderTop
-- Mathlib/Topology/Homeomorph.lean
protected theorem denseEmbedding (h : X ≃ₜ Y) : DenseEmbedding h
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem mk_inj {x y : F (M F)} (h : M.mk x = M.mk y) : x = y
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem piCongrRight_apply (e : (i : ι) → φ i ≃ₗ[R] ψ i) (f i) :
    piCongrRight e f i = e i (f i)
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- If `S / R` and `S' / R'` are algebras, `i : R' →+* R` and `j : S →+* S'` are injective ring
homomorphisms, such that `R' → R → S → S'` and `R' → S'` commute, then the rank of `S / R` is
smaller than or equal to the rank of `S' / R'`. -/
theorem lift_rank_le_of_injective_injective
    (i : R' →+* R) (j : S →+* S') (hi : Injective i) (hj : Injective j)
    (hc : (j.comp (algebraMap R S)).comp i = algebraMap R' S') :
    lift.{v'} (Module.rank R S) ≤ lift.{v} (Module.rank R' S')
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arctan_lt_pi_div_two (x : ℝ) : arctan x < π / 2
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_eq_mk' : (mk : R → M → Localization M) = IsLocalization.mk' (Localization M)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem map_uniformity_set_coe {s : Set α} [UniformSpace α] :
    map (Prod.map (↑) (↑)) (𝓤 s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s)
-- Mathlib/Data/Finset/Powerset.lean
@[simp]
theorem mem_powerset {s t : Finset α} : s ∈ powerset t ↔ s ⊆ t
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem elim_none (x : β) (f : α → β) : none.elim x f = x
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
@[simp] lemma not_in₂₂ : ¬ (graph t).Adj (in₂ c) (in₂ c')
-- Mathlib/Topology/GDelta.lean
/-- The empty set is nowhere dense. -/
@[simp]
lemma isNowhereDense_empty : IsNowhereDense (∅ : Set X)
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem mkRat_num_den (z : d ≠ 0) (h : mkRat n d = ⟨n', d', z', c⟩) :
    ∃ m : Nat, m ≠ 0 ∧ n = n' * m ∧ d = d' * m
-- Mathlib/Analysis/Convex/Topology.lean
theorem segment_subset_closure_openSegment : [x -[𝕜] y] ⊆ closure (openSegment 𝕜 x y)
-- Mathlib/Algebra/Order/Field/Basic.lean
lemma mul_inv_le_one_of_le (h : a ≤ b) (hb : 0 ≤ b) : a * b⁻¹ ≤ 1
-- Mathlib/RingTheory/Ideal/Operations.lean
@[simp]
theorem top_mul : ⊤ * I = I
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.congr_of_mem (h : HasDerivWithinAt f f' s x) (hs : ∀ x ∈ s, f₁ x = f x)
    (hx : x ∈ s) : HasDerivWithinAt f₁ f' s x
-- Mathlib/NumberTheory/PythagoreanTriples.lean
private theorem coprime_sq_sub_mul_of_even_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 0)
    (hn : n % 2 = 1) : Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1
-- Mathlib/Algebra/Polynomial/Reverse.lean
lemma revAt_eq_self_of_lt {N i : ℕ} (h : N < i) : revAt N i = i
-- Mathlib/Data/Erased.lean
@[ext]
theorem out_inj {α} (a b : Erased α) (h : a.out = b.out) : a = b
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
/-- `r` is a unit as a section on the basic open defined by `r`. -/
theorem isUnit_res_toΓSpecMapBasicOpen : IsUnit (X.toToΓSpecMapBasicOpen r r)