ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Complex/Basic.lean
/-- The equivalence between the complex numbers and `ℝ × ℝ`. -/
@[simps apply]
def equivRealProd : ℂ ≃ ℝ × ℝ
-- Mathlib/Algebra/Group/Aut.lean
@[simp]
theorem coe_mul (e₁ e₂ : MulAut M) : ⇑(e₁ * e₂) = e₁ ∘ e₂
-- Mathlib/Tactic/NormNum/DivMod.lean
lemma isNat_neg_of_isNegNat {a : ℤ} {b : ℕ} (h : IsInt a (.negOfNat b)) : IsNat (-a) b
-- Mathlib/Order/FixedPoints.lean
theorem nextFixed_le {x : α} (hx : x ≤ f x) {y : fixedPoints f} (h : x ≤ y) :
    f.nextFixed x hx ≤ y
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
theorem filterTR_loop_eq (p : α → Bool) (as bs : List α) :
    filterTR.loop p as bs = bs.reverse ++ filter p as
-- Mathlib/Computability/Halting.lean
nonrec theorem sum_casesOn {f : α → β ⊕ γ} {g : α → β →. σ} {h : α → γ →. σ} (hf : Computable f)
    (hg : Partrec₂ g) (hh : Partrec₂ h) : @Partrec _ σ _ _ fun a => Sum.casesOn (f a) (g a) (h a)
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Injective affine maps preserve affine independence. -/
theorem AffineMap.affineIndependent_iff {p : ι → P} (f : P →ᵃ[k] P₂) (hf : Function.Injective f) :
    AffineIndependent k (f ∘ p) ↔ AffineIndependent k p
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive add_lt_of_neg_right]
theorem mul_lt_of_lt_one_right' [CovariantClass α α (· * ·) (· < ·)] (a : α) {b : α} (h : b < 1) :
    a * b < a
-- Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean
theorem gradedMul_assoc (x y z : DirectSum _ 𝒜 ⊗[R] DirectSum _ ℬ) :
    gradedMul R 𝒜 ℬ (gradedMul R 𝒜 ℬ x y) z = gradedMul R 𝒜 ℬ x (gradedMul R 𝒜 ℬ y z)
-- Mathlib/RingTheory/Generators.lean
lemma σ_injective : P.σ.Injective
-- Mathlib/RingTheory/Ideal/MinimalPrime.lean
theorem Ideal.minimalPrimes_eq_comap :
    I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I)
-- Mathlib/Computability/Primrec.lean
protected theorem ofNat (α) [Denumerable α] : Primrec (ofNat α)
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- `seminormFromConst' hf1 hc hpm 1 = 1`. -/
theorem seminormFromConst_one : seminormFromConst' hf1 hc hpm 1 = 1
-- Mathlib/Order/Filter/Pi.lean
theorem mem_pi' {s : Set (∀ i, α i)} :
    s ∈ pi f ↔ ∃ I : Finset ι, ∃ t : ∀ i, Set (α i), (∀ i, t i ∈ f i) ∧ Set.pi (↑I) t ⊆ s
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- The function `x ^ (a / (b * x + c))` tends to `1` at `+∞`, for any real numbers `a`, `b`, and
`c` such that `b` is nonzero. -/
theorem tendsto_rpow_div_mul_add (a b c : ℝ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ (a / (b * x + c))) atTop (𝓝 1)
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma inv : MeromorphicOn s⁻¹ U
-- Mathlib/CategoryTheory/ConcreteCategory/Basic.lean
theorem coe_comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X → Z) = g ∘ f
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem univ_mem : univ ∈ f
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem isCaratheodory_iUnion_nat {s : ℕ → Set α} (h : ∀ i, IsCaratheodory m (s i))
    (hd : Pairwise (Disjoint on s)) : IsCaratheodory m (⋃ i, s i)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
/-- The function x ↦ ∑ a_i b_i^x is injective. This implies the uniqueness of `p`. -/
lemma injective_sumCoeffsExp : Function.Injective (fun (p : ℝ) => ∑ i, a i * (b i) ^ p)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_erase_lt (hp : p ≠ 0) : degree (p.erase (natDegree p)) < degree p
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem mul_inv : ∀ {z : ℤ_[p]}, ‖z‖ = 1 → z * z.inv = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
lemma Sigma.map_comp_map {f g h : α → C} [HasCoproduct f] [HasCoproduct g] [HasCoproduct h]
    (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (a : α), g a ⟶ h a) :
    Sigma.map q ≫ Sigma.map q' = Sigma.map (fun a => q a ≫ q' a)
-- Mathlib/Data/Finset/Piecewise.lean
lemma piecewise_insert_self [DecidableEq ι] {j : ι} [∀ i, Decidable (i ∈ insert j s)] :
    (insert j s).piecewise f g j = f j
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiable_fst : MDifferentiable (I.prod I') I (Prod.fst : M × M' → M)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_ne_of_natDegree_ne {n : ℕ} : p.natDegree ≠ n → degree p ≠ n
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem exists_mem_range_of_norm_rat_le_one (h : ‖(r : ℚ_[p])‖ ≤ 1) :
    ∃ n : ℤ, 0 ≤ n ∧ n < p ∧ ‖(⟨r, h⟩ - n : ℤ_[p])‖ < 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem take_left : ∀ l₁ l₂ : List α, take (length l₁) (l₁ ++ l₂) = l₁
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem union_symm_apply_left {α} {s t : Set α} [DecidablePred fun x => x ∈ s] (H : s ∩ t ⊆ ∅)
    (a : s) : (Equiv.Set.union H).symm (Sum.inl a) = ⟨a, by simp⟩
-- Mathlib/RepresentationTheory/Basic.lean
theorem ofMulAction_def (g : G) : ofMulAction k G H g = Finsupp.lmapDomain k k (g • ·)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_add_const_Ico : (fun x => x + a) ⁻¹' Ico b c = Ico (b - a) (c - a)
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem decode_zero : (decode 0 : Option Bool) = some false
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
lemma not_nil_of_ne {p : G.Walk v w} : v ≠ w → ¬ p.Nil
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_lt_norm_mul_iff_real {x y : F} : ⟪x, y⟫_ℝ < ‖x‖ * ‖y‖ ↔ ‖y‖ • x ≠ ‖x‖ • y
-- Mathlib/Order/Hom/Basic.lean
theorem OrderIso.isCompl {x y : α} (h : IsCompl x y) : IsCompl (f x) (f y)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_polynomialY : (W.map f).toAffine.polynomialY = W.polynomialY.map (mapRingHom f)
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
theorem toEquiv_injective : Injective (Diffeomorph.toEquiv : (M ≃ₘ^n⟮I, I'⟯ M') → M ≃ M')
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_apply_eq_zero' (hs : MeasurableSet s) : μ.restrict s t = 0 ↔ μ (t ∩ s) = 0
-- Mathlib/NumberTheory/NumberField/Basic.lean
lemma coe_mk {x : K} (hx) : ((⟨x, hx⟩ : 𝓞 K) : K) = x
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_unique (s : x ⊓ y ⊔ z = x) (i : x ⊓ y ⊓ z = ⊥) : x \ y = z
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem eq_left_getLeft_of_isLeft : ∀ {x : α ⊕ β} (h : x.isLeft), x = inl (x.getLeft h)
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem insepDegree_top : insepDegree F (⊤ : IntermediateField E K) = insepDegree F K
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
lemma natDegree_eq_of_natDegree_add_lt_left (p q : R[X])
    (H : natDegree (p + q) < natDegree p) : natDegree p = natDegree q
-- Mathlib/Logic/Encodable/Basic.lean
theorem surjective_decode_iget (α : Type*) [Encodable α] [Inhabited α] :
    Surjective fun n => ((Encodable.decode n).iget : α)
-- Mathlib/Algebra/Module/BigOperators.lean
theorem List.sum_smul {l : List R} {x : M} : l.sum • x = (l.map fun r ↦ r • x).sum
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- A multiplicative character on a commutative monoid with finitely many units
has finite (= positive) order. -/
lemma orderOf_pos [Finite Mˣ] (χ : MulChar M R) : 0 < orderOf χ
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_sin_pow_antitone : Antitone fun n : ℕ => ∫ x in (0)..π, sin x ^ n
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem swap_apply_self (i j a : α) : swap i j (swap i j a) = a
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem ExpChar.congr {p : ℕ} (q : ℕ) [hq : ExpChar R q] (h : q = p) : ExpChar R p
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem eq_of_empty [h : IsEmpty α] (f g : α →ᵇ β) : f = g
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.not_swap_left [NoZeroSMulDivisors R V] {x y z : P} (h : Sbtw R x y z) :
    ¬Wbtw R y x z
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem Colorable.mono_left {G' : SimpleGraph V} (h : G ≤ G') {n : ℕ} (hc : G'.Colorable n) :
    G.Colorable n
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem Derivation.tensorProductTo_mul (D : Derivation R S M) (x y : S ⊗[R] S) :
    D.tensorProductTo (x * y) =
      TensorProduct.lmul' (S := S) R x • D.tensorProductTo y +
        TensorProduct.lmul' (S := S) R y • D.tensorProductTo x
-- Mathlib/Data/Finsupp/Order.lean
@[simp]
theorem support_sup [DecidableEq ι] (f g : ι →₀ α) : (f ⊔ g).support = f.support ∪ g.support
-- Mathlib/Algebra/MvPolynomial/Rename.lean
@[simp]
theorem renameEquiv_refl : renameEquiv R (Equiv.refl σ) = AlgEquiv.refl
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
/-- A subsemigroup of a magma `M` is a subset closed under multiplication. -/
structure Subsemigroup (M : Type*) [Mul M] where
  /-- The carrier of a subsemigroup. -/
  carrier : Set M
  /-- The product of two elements of a subsemigroup belongs to the subsemigroup. -/
  mul_mem' {a b} : a ∈ carrier → b ∈ carrier → a * b ∈ carrier
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_measurableSet {α : Type*} [MeasurableSpace α] :
    IsPiSystem { s : Set α | MeasurableSet s }
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_eq_true_iff (x y : Bool) : (x && y) = true ↔ x = true ∧ y = true
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem id_apply (a : α) : sSupHom.id α a = a
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
@[simp] theorem pwFilter_nil [DecidableRel R] : pwFilter R [] = []
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[fun_prop]
protected theorem mono' (h : AEMeasurable f μ) (h' : ν ≪ μ) : AEMeasurable f ν
-- Mathlib/FieldTheory/Adjoin.lean
theorem sup_toSubalgebra_of_isAlgebraic_right [Algebra.IsAlgebraic K E2] :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra
-- Mathlib/Data/Fintype/Card.lean
theorem bijective_iff_surjective_and_card (f : α → β) :
    Bijective f ↔ Surjective f ∧ card α = card β
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
lemma L₀_g_δ : S.L₀.g ≫ S.δ = 0
-- Mathlib/Order/Filter/AtTopBot.lean
theorem disjoint_pure_atBot [Preorder α] [NoMinOrder α] (x : α) : Disjoint (pure x) atBot
-- Mathlib/Data/Matroid/Basic.lean
@[aesop safe (rule_sets := [Matroid])]
private theorem insert_subset_ground {e : α} {X : Set α} {M : Matroid α}
    (he : e ∈ M.E) (hX : X ⊆ M.E) : insert e X ⊆ M.E
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem one_lt_pow (ha : 1 < a) : ∀ {n : ℕ} (_ : n ≠ 0), 1 < a ^ n
-- Mathlib/LinearAlgebra/Projection.lean
theorem ofIsCompl_eq (h : IsCompl p q) {φ : p →ₗ[R] F} {ψ : q →ₗ[R] F} {χ : E →ₗ[R] F}
    (hφ : ∀ u, φ u = χ u) (hψ : ∀ u, ψ u = χ u) : ofIsCompl h φ ψ = χ
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coe_def : (φ : MvPowerSeries σ R) = fun n => coeff n φ
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem b_of_eq (h : P.toPoly = Q.toPoly) : P.b = Q.b
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
lemma add_eq_add {X'' Y'' : C} (eX' : L.obj X'' ≅ X') (eY' : L.obj Y'' ≅ Y')
    (f₁ f₂ : X' ⟶ Y') :
    add W eX eY f₁ f₂ = add W eX' eY' f₁ f₂
-- Mathlib/ModelTheory/Substructures.lean
theorem closure_withConstants_eq :
    closure (L[[A]]) s =
      (closure L (A ∪ s)).withConstants ((A.subset_union_left).trans subset_closure)
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem refl_toCoalgEquiv : refl R A = CoalgEquiv.refl R A
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem fpowerSeries_apply_add_two (f : E →L[𝕜] F) (x : E) (n : ℕ) : f.fpowerSeries x (n + 2) = 0
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
@[simp] lemma smul_pow' (r : M) (x : A) (n : ℕ) : r • x ^ n = (r • x) ^ n
-- Mathlib/NumberTheory/SumFourSquares.lean
private theorem sum_four_squares_of_two_mul_sum_four_squares {m a b c d : ℤ}
    (h : a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = 2 * m) :
    ∃ w x y z : ℤ, w ^ 2 + x ^ 2 + y ^ 2 + z ^ 2 = m
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[simp] lemma div_self (h : a ≠ 0) : a / a = 1
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp, norm_cast]
theorem coe_sub (x y : R) : (↑(x - y) : c.Quotient) = x - y
-- Mathlib/FieldTheory/Adjoin.lean
theorem mem_adjoin_iff (x : E) :
    x ∈ adjoin F S ↔ ∃ r s : MvPolynomial S F,
      x = MvPolynomial.aeval Subtype.val r / MvPolynomial.aeval Subtype.val s
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive add_sub_one_nsmul]
lemma pow_sub_one_mul (hn : n ≠ 0) (a : M) : a ^ (n - 1) * a = a ^ n
-- Mathlib/Data/Fintype/Basic.lean
/-- Embed `Fin n` into `Fin (n + 1)` by inserting
around a specified pivot `p : Fin (n + 1)` into the `univ` -/
theorem Fin.univ_succAbove (n : ℕ) (p : Fin (n + 1)) :
    (univ : Finset (Fin (n + 1))) = Finset.cons p (univ.map <| Fin.succAboveEmb p) (by simp)
-- Mathlib/Algebra/AddTorsor.lean
@[simp]
theorem mk_vsub_mk (p₁ p₂ : P) (p₁' p₂' : P') :
    ((p₁, p₁') -ᵥ (p₂, p₂') : G × G') = (p₁ -ᵥ p₂, p₁' -ᵥ p₂')
-- Mathlib/Order/SuccPred/Limit.lean
@[simp]
theorem isSuccLimit_toDual_iff : IsSuccLimit (toDual a) ↔ IsPredLimit a
-- Mathlib/Data/Nat/Factorization/Root.lean
lemma floorRoot_pow_dvd : floorRoot n a ^ n ∣ a
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem _root_.IsFiniteMeasure.lintegral_lt_top_of_bounded_to_ennreal {α : Type*}
    [MeasurableSpace α] (μ : Measure α) [μ_fin : IsFiniteMeasure μ] {f : α → ℝ≥0∞}
    (f_bdd : ∃ c : ℝ≥0, ∀ x, f x ≤ c) : ∫⁻ x, f x ∂μ < ∞
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma homMk₅_app_zero : (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 0 = app₀
-- Mathlib/Order/Filter/Extr.lean
theorem IsMinFilter.inf (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
    IsMinFilter (fun x => f x ⊓ g x) l a
-- Mathlib/CategoryTheory/Category/Grpd.lean
@[simp]
theorem coe_of (C : Type u) [Groupoid C] : (of C : Type u) = C
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem sin_pi_div_two_sub (θ : Angle) : sin (↑(π / 2) - θ) = cos θ
-- Mathlib/Order/WithBot.lean
theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = (a : WithTop α) ⊓ b
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem map_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : ⨂[R] i, s (e.symm i)) :
    map f ((reindex R s e).symm x) = (reindex R t e).symm (map (fun i ↦ f (e.symm i)) x)
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- Multiplying by some of the matrices in `listTransvecRow M` does not change the last column. -/
theorem mul_listTransvecRow_last_col_take (i : Fin r ⊕ Unit) {k : ℕ} (hk : k ≤ r) :
    (M * ((listTransvecRow M).take k).prod) i (inr unit) = M i (inr unit)
-- Mathlib/CategoryTheory/Limits/FinallySmall.lean
/-- A category is `FinallySmall.{w}` if there is a final functor from a `w`-small category. -/
class FinallySmall : Prop where
  /-- There is a final functor from a small category. -/
  final_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Final F
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp, norm_cast]
theorem coe_add (a b : α) : ((a + b : α) : WithBot α) = a + b
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] protected theorem ediv_left_inj {a b d : Int}
    (hda : d ∣ a) (hdb : d ∣ b) : a / d = b / d ↔ a = b
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Two affine subspaces with nonempty intersection are equal if and only if their directions are
equal. -/
theorem eq_iff_direction_eq_of_mem {s₁ s₂ : AffineSubspace k P} {p : P} (h₁ : p ∈ s₁)
    (h₂ : p ∈ s₂) : s₁ = s₂ ↔ s₁.direction = s₂.direction
-- Mathlib/Order/Sublattice.lean
lemma map_iSup (f : LatticeHom α β) (L : ι → Sublattice α) : (⨆ i, L i).map f = ⨆ i, (L i).map f
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_C_isSolvable (x : F) : IsSolvable (C x).Gal
-- Mathlib/Data/Finset/Interval.lean
/-- A function `f` from `Finset α` is strictly antitone if and only if `f (cons a s ha) < f s` for
all `s` and `a ∉ s`. -/
lemma strictAnti_iff_forall_cons_lt : StrictAnti f ↔ ∀ s ⦃a⦄ ha, f (cons a s ha) < f s
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem validFor : ∀ {it}, Valid it → ∃ l r, ValidFor l r it
-- Mathlib/ModelTheory/Definability.lean
@[simp]
theorem Definable.inter {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g) :
    A.Definable L (f ∩ g)
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
theorem isMatching_iff_forall_degree [∀ v, Fintype (M.neighborSet v)] :
    M.IsMatching ↔ ∀ v : V, v ∈ M.verts → M.degree v = 1
-- Mathlib/SetTheory/Surreal/Dyadic.lean
@[simp]
theorem birthday_half : birthday (powHalf 1) = 2
-- Mathlib/CategoryTheory/Sites/Coverage.lean
@[simp]
lemma factorsThruAlong_id {X : C} (S T : Presieve X) :
    S.FactorsThruAlong T (𝟙 X) ↔ S.FactorsThru T
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/-- Shows that `|v - Aₙ / Bₙ| ≤ 1 / (bₙ * Bₙ * Bₙ)`. This bound is worse than the one shown in
`GenContFract.abs_sub_convs_le`, but sometimes it is easier to apply and
sufficient for one's use case.
 -/
theorem abs_sub_convergents_le' {b : K}
    (nth_partDen_eq : (of v).partDens.get? n = some b) :
    |v - (of v).convs n| ≤ 1 / (b * (of v).dens n * (of v).dens n)
-- Mathlib/Data/Rat/Cast/Order.lean
/-- Coercion from `ℚ` as an order embedding. -/
@[simps!]
def castOrderEmbedding : ℚ ↪o K
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := gcongr) sub_lt_sub_right]
theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_iff_final_comp [Final F] : Final G ↔ Final (F ⋙ G)
-- Mathlib/RingTheory/Polynomial/Opposites.lean
@[simp]
theorem opRingEquiv_op_monomial (n : ℕ) (r : R) :
    opRingEquiv R (op (monomial n r : R[X])) = monomial n (op r)
-- Mathlib/Control/Lawful.lean
@[ext] theorem ext {x x' : OptionT m α} (h : x.run = x'.run) : x = x'
-- Mathlib/Logic/Basic.lean
theorem And.exists {p q : Prop} {f : p ∧ q → Prop} : (∃ h, f h) ↔ ∃ hp hq, f ⟨hp, hq⟩
-- Mathlib/RingTheory/SimpleModule.lean
theorem surjective_of_ne_zero [IsSimpleModule R N] {f : M →ₗ[R] N} (h : f ≠ 0) :
    Function.Surjective f
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Any compact set in a pseudometric space can be covered by finitely many balls of a given
positive radius -/
theorem finite_cover_balls_of_compact {α : Type u} [PseudoMetricSpace α] {s : Set α}
    (hs : IsCompact s) {e : ℝ} (he : 0 < e) :
    ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ x ∈ t, ball x e
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The angle between a nonnegative multiple of a vector and that vector is 0. -/
@[simp]
theorem oangle_smul_left_self_of_nonneg (x : V) {r : ℝ} (hr : 0 ≤ r) : o.oangle (r • x) x = 0
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem symm_dual_id : BoundedOrderHom.dual.symm (BoundedOrderHom.id _) = BoundedOrderHom.id α
-- Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@[reassoc (attr := simp)]
lemma ιTensorObj₃_tensorHom (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃)
    (i₁ i₂ i₃ j : I) (h : i₁ + i₂ + i₃ = j) :
    ιTensorObj₃ X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ tensorHom f₁ (tensorHom f₂ f₃) j =
      (f₁ i₁ ⊗ f₂ i₂ ⊗ f₃ i₃) ≫ ιTensorObj₃ Y₁ Y₂ Y₃ i₁ i₂ i₃ j h
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem lie_nsmul (n : ℕ) : ⁅x, n • m⁆ = n • ⁅x, m⁆
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem minimum?_mem [Min α] (min_eq_or : ∀ a b : α, min a b = a ∨ min a b = b) :
    {xs : List α} → xs.minimum? = some a → a ∈ xs
-- Mathlib/Data/ZMod/Basic.lean
lemma nontrivial_iff {n : ℕ} : Nontrivial (ZMod n) ↔ n ≠ 1
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
protected theorem Measurable.rangeFactorization {f : α → β} (hf : Measurable f) :
    Measurable (rangeFactorization f)
-- Mathlib/Analysis/Seminorm.lean
/-- Let `p` be a seminorm on a vector space over a `NormedField`.
If there is a scalar `c` with `‖c‖>1`, then any `x` such that `p x ≠ 0` can be
moved by scalar multiplication to any `p`-shell of width `‖c‖`. Also recap information on the
value of `p` on the rescaling element that shows up in applications. -/
lemma rescale_to_shell_zpow (p : Seminorm 𝕜 E) {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ}
    (εpos : 0 < ε) {x : E} (hx : p x ≠ 0) : ∃ n : ℤ, c^n ≠ 0 ∧
    p (c^n • x) < ε ∧ (ε / ‖c‖ ≤ p (c^n • x)) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x)
-- Mathlib/CategoryTheory/Idempotents/Basic.lean
/-- A preadditive category is pseudoabelian iff all idempotent endomorphisms have a kernel. -/
theorem isIdempotentComplete_iff_idempotents_have_kernels [Preadditive C] :
    IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasKernel p
-- Mathlib/Algebra/CharZero/Defs.lean
/-- Typeclass for monoids with characteristic zero.
  (This is usually stated on fields but it makes sense for any additive monoid with 1.)

*Warning*: for a semiring `R`, `CharZero R` and `CharP R 0` need not coincide.
* `CharZero R` requires an injection `ℕ ↪ R`;
* `CharP R 0` asks that only `0 : ℕ` maps to `0 : R` under the map `ℕ → R`.
For instance, endowing `{0, 1}` with addition given by `max` (i.e. `1` is absorbing), shows that
`CharZero {0, 1}` does not hold and yet `CharP {0, 1} 0` does.
This example is formalized in `Counterexamples/CharPZeroNeCharZero.lean`.
-/
class CharZero (R) [AddMonoidWithOne R] : Prop where
  /-- An additive monoid with one has characteristic zero if the canonical map `ℕ → R` is
  injective. -/
  cast_injective : Function.Injective (Nat.cast : ℕ → R)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem padicValNat_dvd_iff_le [hp : Fact p.Prime] {a n : ℕ} (ha : a ≠ 0) :
    p ^ n ∣ a ↔ n ≤ padicValNat p a
-- Mathlib/Analysis/BoundedVariation.lean
protected theorem eq_of_ge {a b : α} (h : b ≤ a) :
    variationOnFromTo f s a b = -(eVariationOn f (s ∩ Icc b a)).toReal
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoUniformlyOn_iff_tendstoUniformly_comp_coe :
    TendstoUniformlyOn F f p s ↔ TendstoUniformly (fun i (x : s) => F i x) (f ∘ (↑)) p
-- Mathlib/Analysis/Fourier/PoissonSummation.lean
/-- **Poisson's summation formula** for Schwartz functions. -/
theorem SchwartzMap.tsum_eq_tsum_fourierIntegral (f g : SchwartzMap ℝ ℂ) (hfg : 𝓕 ⇑f = ⇑g) (x : ℝ) :
    ∑' n : ℤ, f (x + n) = (∑' n : ℤ, g n * fourier n (x : UnitAddCircle))
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem lowerClosure_iUnion (f : ι → Set α) : lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i)
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem coordChangeL_apply (e e' : Trivialization F (π F E)) [e.IsLinear R] [e'.IsLinear R] {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (y : F) :
    coordChangeL R e e' b y = (e' ⟨b, e.symm b y⟩).2
-- Mathlib/Topology/Compactness/SigmaCompact.lean
/-- If `s` is σ-compact and `f` is continuous on `s`, `f(s)` is σ-compact. -/
lemma IsSigmaCompact.image_of_continuousOn {f : X → Y} {s : Set X} (hs : IsSigmaCompact s)
    (hf : ContinuousOn f s) : IsSigmaCompact (f '' s)
-- Mathlib/RingTheory/WittVector/Identities.lean
theorem iterate_frobenius_coeff (x : 𝕎 R) (i k : ℕ) :
    (frobenius^[i] x).coeff k = x.coeff k ^ p ^ i
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
theorem sup_mem_closed_subalgebra (A : Subalgebra ℝ C(X, ℝ)) (h : IsClosed (A : Set C(X, ℝ)))
    (f g : A) : (f : C(X, ℝ)) ⊔ (g : C(X, ℝ)) ∈ A
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_subtype (p : α → Prop) (s : { x // p x } → Set β) :
    ⋃ x : { x // p x }, s x = ⋃ (x) (hx : p x), s ⟨x, hx⟩
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
@[simp]
theorem explicitCokernelIso_hom_π {X Y : SemiNormedGrp.{u}} (f : X ⟶ Y) :
    explicitCokernelπ f ≫ (explicitCokernelIso f).hom = cokernel.π _
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem roth_lower_bound_explicit (hN : 4096 ≤ N) :
    (N : ℝ) * exp (-4 * √(log N)) < rothNumberNat N
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem op (h : IsZero X) : IsZero (Opposite.op X)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- In a normed vector space, the subtraction of a measurable function and a strongly measurable
function is measurable. Note that this is not true without further second-countability assumptions
for the subtraction of two measurable functions. -/
theorem _root_.Measurable.sub_stronglyMeasurable
    {α E : Type*} {_ : MeasurableSpace α} [AddCommGroup E] [TopologicalSpace E]
    [MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [ContinuousNeg E] [PseudoMetrizableSpace E]
    {g f : α → E} (hg : Measurable g) (hf : StronglyMeasurable f) :
    Measurable (g - f)
-- Mathlib/Data/List/OfFn.lean
@[deprecated ofFn_get (since := "2023-01-17")]
theorem ofFn_nthLe : ∀ l : List α, (ofFn fun i => nthLe l i i.2) = l