ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/Core.lean
protected theorem liftBeta {α : Sort u} {r : α → α → Prop} {β : Sort v}
    (f : α → β)
    (c : (a b : α) → r a b → f a = f b)
    (a : α)
    : lift f c (Quot.mk r a) = f a
-- Mathlib/FieldTheory/PrimitiveElement.lean
/-- **Steinitz theorem**: an algebraic extension `E` of `F` has a
  primitive element (i.e. there is an `α ∈ E` such that `F⟮α⟯ = (⊤ : Subalgebra F E)`)
  if and only if there exist only finitely many intermediate fields between `E` and `F`. -/
theorem exists_primitive_element_iff_finite_intermediateField :
    (Algebra.IsAlgebraic F E ∧ ∃ α : E, F⟮α⟯ = ⊤) ↔ Finite (IntermediateField F E)
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem sub_mem_iff_left (hy : y ∈ p) : x - y ∈ p ↔ x ∈ p
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem absolutelyContinuous_of_eq (h : μ = ν) : μ ≪ ν
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
theorem rpow_zero (x : ℝ) : x ^ (0 : ℝ) = 1
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
protected theorem mul_assoc (φ₁ φ₂ φ₃ : MvPowerSeries σ R) : φ₁ * φ₂ * φ₃ = φ₁ * (φ₂ * φ₃)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
@[simp]
theorem coe_restrictScalarsL : (restrictScalarsL 𝕜 E Fₗ 𝕜' 𝕜'' : (E →L[𝕜] Fₗ) →ₗ[𝕜''] E →L[𝕜'] Fₗ) =
    restrictScalarsₗ 𝕜 E Fₗ 𝕜' 𝕜''
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem coe_substructureReduct {S : L'.Substructure M} : (φ.substructureReduct S : Set M) = ↑S
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
/-- If a function is integrable on a set `s` and vanishes almost everywhere on its complement,
then it is integrable. -/
theorem IntegrableOn.integrable_of_ae_not_mem_eq_zero (hf : IntegrableOn f s μ)
    (h't : ∀ᵐ x ∂μ, x ∉ s → f x = 0) : Integrable f μ
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt32.le_antisymm {x y : UInt32} (h1 : x ≤ y) (h2 : y ≤ x) : x = y
-- Mathlib/Algebra/Lie/Quotient.lean
theorem mk_eq_zero {m : M} : mk' N m = 0 ↔ m ∈ N
-- Mathlib/Data/Prod/Basic.lean
theorem eq_iff_fst_eq_snd_eq : ∀ {p q : α × β}, p = q ↔ p.1 = q.1 ∧ p.2 = q.2
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
lemma bitwise_zero_right (n : Nat) : bitwise f n 0 = if f true false then n else 0
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem arrowCongr_refl {α β : Sort*} :
    arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem map_id : s.map (NonUnitalRingHom.id R) = s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem leadingCoeff_C_mul_X (a : R) : leadingCoeff (C a * X) = a
-- Mathlib/Data/Complex/Abs.lean
private theorem abs_add (z w : ℂ) : (abs z + w) ≤ (abs z) + abs w
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_image_target_inter_eq' (s : Set β) : e.symm '' (e.target ∩ s) = e.source ∩ e ⁻¹' s
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_right_comm (s t u : Set E) :
    convexJoin 𝕜 (convexJoin 𝕜 s t) u = convexJoin 𝕜 (convexJoin 𝕜 s u) t
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[fun_prop]
theorem differentiableWithinAt_id : DifferentiableWithinAt 𝕜 id s x
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_onFinset [DecidableEq M] {s : Finset α} {f : α → M}
    (hf : ∀ a : α, f a ≠ 0 → a ∈ s) :
    (Finsupp.onFinset s f hf).support = s.filter fun a => f a ≠ 0
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
nonrec lemma is3Clique_iff [NoAccidental t] {s : Finset (α ⊕ β ⊕ γ)} :
    (graph t).IsNClique 3 s ↔ ∃ x, x ∈ t ∧ toTriangle x = s
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- A constant sequence of functions is uniformly integrable in the probability sense. -/
theorem uniformIntegrable_const {g : α → β} (hp : 1 ≤ p) (hp_ne_top : p ≠ ∞) (hg : Memℒp g p μ) :
    UniformIntegrable (fun _ : ι => g) p μ
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
lemma Hom.toBialgHom_injective (V W : HopfAlgebraCat.{v} R) :
    Function.Injective (Hom.toBialgHom : Hom V W → _)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem sub_eq_add_neg {a b : Int} : a - b = a + -b
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem Fix.ind (p : Fix F → Prop) (h : ∀ x : F (Fix F), Liftp p x → p (Fix.mk x)) : ∀ x, p x
-- .lake/packages/lean4/src/lean/Init/Core.lean
/--
If and only if, or logical bi-implication. `a ↔ b` means that `a` implies `b` and vice versa.
By `propext`, this implies that `a` and `b` are equal and hence any expression involving `a`
is equivalent to the corresponding expression with `b` instead.
-/
structure Iff (a b : Prop) : Prop where
  /-- If `a → b` and `b → a` then `a` and `b` are equivalent. -/
  intro ::
  /-- Modus ponens for if and only if. If `a ↔ b` and `a`, then `b`. -/
  mp : a → b
  /-- Modus ponens for if and only if, reversed. If `a ↔ b` and `b`, then `a`. -/
  mpr : b → a
-- Mathlib/Data/Sym/Sym2.lean
theorem Rel.is_equivalence : Equivalence (Rel α)
-- Mathlib/SetTheory/Game/PGame.lean
/-- A small family of pre-games is bounded below. -/
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
    BddBelow (Set.range f)
-- Mathlib/Algebra/DualNumber.lean
/-- For two `R`-algebra morphisms out of `A[ε]` to agree, it suffices for them to agree on the
elements of `A` and the `A`-multiples of `ε`. -/
@[ext 1100]
nonrec theorem algHom_ext' ⦃f g : A[ε] →ₐ[R] B⦄
    (hinl : f.comp (inlAlgHom _ _ _) = g.comp (inlAlgHom _ _ _))
    (hinr : f.toLinearMap ∘ₗ (LinearMap.toSpanSingleton A A[ε] ε).restrictScalars R =
        g.toLinearMap ∘ₗ (LinearMap.toSpanSingleton A A[ε] ε).restrictScalars R) :
      f = g
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem symm_mk (f f') (h₁ h₂ h₃ h₄ h₅) :
    (⟨⟨⟨f, f', h₁, h₂⟩, h₃, h₄⟩, h₅⟩ : A ≃⋆+* B).symm =
      { symm_mk.aux f f' h₁ h₂ h₃ h₄ h₅ with
        toFun := f'
        invFun := f }
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
@[simp]
protected theorem deriv : deriv (fun x => p.eval x) x = p.derivative.eval x
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[simp]
theorem fan_mk_proj {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) (j : β) : (Fan.mk P p).proj j = p j
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
theorem isOpen_Iio {a : Γ₀} : IsOpen (Iio a)
-- Mathlib/Data/Set/Pairwise/Basic.lean
lemma exists_lt_mem_inter_of_not_pairwiseDisjoint [LinearOrder ι]
    {f : ι → Set α} (h : ¬ s.PairwiseDisjoint f) :
    ∃ i ∈ s, ∃ j ∈ s, i < j ∧ ∃ x, x ∈ f i ∩ f j
-- Mathlib/LinearAlgebra/Dual.lean
theorem map_eval_injective : (Submodule.map (eval K V)).Injective
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp, nolint simpNF] lemma LieModuleEquiv.ofTop_apply (x : (⊤ : LieSubmodule R L M)) :
    LieModuleEquiv.ofTop R L M x = x
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_smul_iff [NormedDivisionRing 𝕜] [Module 𝕜 β] [BoundedSMul 𝕜 β] {c : 𝕜}
    (hc : c ≠ 0) (f : α → β) : Integrable (c • f) μ ↔ Integrable f μ
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
@[simp]
theorem volume_closedBall (a r : ℝ) : volume (Metric.closedBall a r) = ofReal (2 * r)
-- Mathlib/RingTheory/FinitePresentation.lean
theorem iff :
    FinitePresentation R A ↔
      ∃ (n : _) (I : Ideal (MvPolynomial (Fin n) R)) (_ : (_ ⧸ I) ≃ₐ[R] A), I.FG
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem norm_le_of_nonempty [Nonempty α] {f : α →ᵇ β} {M : ℝ} : ‖f‖ ≤ M ↔ ∀ x, ‖f x‖ ≤ M
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem snd_apply (x : M × M₂) : snd R M M₂ x = x.2
-- Mathlib/Analysis/Convex/Function.lean
/-- If a function is convex on `s`, it remains convex when precomposed by an affine map. -/
theorem ConvexOn.comp_affineMap {f : F → β} (g : E →ᵃ[𝕜] F) {s : Set F} (hf : ConvexOn 𝕜 s f) :
    ConvexOn 𝕜 (g ⁻¹' s) (f ∘ g)
-- Mathlib/MeasureTheory/Measure/Dirac.lean
lemma map_const (μ : Measure α) (c : β) : μ.map (fun _ ↦ c) = (μ Set.univ) • dirac c
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**, local version for any measure.
Let filters `l` and `l'` be related by `TendstoIxxClass Ioc`.
If `f` has a finite limit `c` at `l' ⊓ ae μ`, where `μ` is a measure
finite at `l'`, then `∫ x in u..v, f x ∂μ = ∫ x in u..v, c ∂μ + o(∫ x in u..v, 1 ∂μ)` as both
`u` and `v` tend to `l`.

See also `measure_integral_sub_linear_isLittleO_of_tendsto_ae` for a version assuming
`[intervalIntegral.FTCFilter a l l']` and `[MeasureTheory.IsLocallyFiniteMeasure μ]`. If `l` is one
of `𝓝[≥] a`, `𝓝[≤] a`, `𝓝 a`, then it's easier to apply the non-primed version.  The primed version
also works, e.g., for `l = l' = atTop`.

We use integrals of constants instead of measures because this way it is easier to formulate
a statement that works in both cases `u ≤ v` and `v ≤ u`. -/
theorem measure_integral_sub_linear_isLittleO_of_tendsto_ae' [IsMeasurablyGenerated l']
    [TendstoIxxClass Ioc l l'] (hfm : StronglyMeasurableAtFilter f l' μ)
    (hf : Tendsto f (l' ⊓ ae μ) (𝓝 c)) (hl : μ.FiniteAtFilter l') (hu : Tendsto u lt l)
    (hv : Tendsto v lt l) :
    (fun t => (∫ x in u t..v t, f x ∂μ) - ∫ _ in u t..v t, c ∂μ) =o[lt] fun t =>
      ∫ _ in u t..v t, (1 : ℝ) ∂μ
-- Mathlib/Topology/Algebra/ConstMulAction.lean
/-- Class `ContinuousConstSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is continuous in the second argument. We use the same class for all kinds of multiplicative
actions, including (semi)modules and algebras.

Note that both `ContinuousConstSMul α α` and `ContinuousConstSMul αᵐᵒᵖ α` are
weaker versions of `ContinuousMul α`. -/
class ContinuousConstSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] : Prop where
  /-- The scalar multiplication `(•) : Γ → T → T` is continuous in the second argument. -/
  continuous_const_smul : ∀ γ : Γ, Continuous fun x : T => γ • x
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem MeasureTheory.Integrable.apply_continuousLinearMap {φ : α → H →L[𝕜] E}
    (φ_int : Integrable φ μ) (v : H) : Integrable (fun a => φ a v) μ
-- Mathlib/Data/PNat/Basic.lean
theorem add_one_le_iff : ∀ {a b : ℕ+}, a + 1 ≤ b ↔ a < b
-- Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean
theorem IsConformalMap.smul (hf : IsConformalMap f) {c : R} (hc : c ≠ 0) :
    IsConformalMap (c • f)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem submatrix_id_id (A : Matrix m n α) : A.submatrix id id = A
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem mem_of_mem_filter {a : α} {l} (h : a ∈ filter p l) : a ∈ l
-- Mathlib/Data/Int/GCD.lean
lemma pow_eq_pow_iff_of_coprime (hmn : m.Coprime n) : a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m
-- Mathlib/Order/Closure.lean
theorem closure_sup_closure_left (x y : α) : u (l (u (l x) ⊔ y)) = u (l (x ⊔ y))
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
/-- If `f` and `g` are two torus integrable functions, then so is `f + g`. -/
protected nonrec theorem add (hf : TorusIntegrable f c R) (hg : TorusIntegrable g c R) :
    TorusIntegrable (f + g) c R
-- Mathlib/Data/PNat/Defs.lean
@[simp, norm_cast]
theorem coe_eq_one_iff {m : ℕ+} : (m : ℕ) = 1 ↔ m = 1
-- Mathlib/Logic/Equiv/Defs.lean
theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a = b ↔ HEq a b
-- Mathlib/Algebra/Order/Floor.lean
theorem abs_sub_round_div_natCast_eq {m n : ℕ} :
    |(m : α) / n - round ((m : α) / n)| = ↑(min (m % n) (n - m % n)) / n
-- Mathlib/Topology/Separation.lean
protected theorem R1Space.induced (f : Y → X) : @R1Space Y (.induced f ‹_›)
-- Mathlib/Init/Order/LinearOrder.lean
theorem min_le_right (a b : α) : min a b ≤ b
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem catalan_succ (n : ℕ) : catalan (n + 1) = ∑ i : Fin n.succ, catalan i * catalan (n - i)
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem Basis.ofEquivFun_repr_apply [Finite ι] (e : M ≃ₗ[R] ι → R) (x : M) (i : ι) :
    (Basis.ofEquivFun e).repr x i = e x i
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- `C` has all limits of size `v₁ u₁` (`HasLimitsOfSize.{v₁ u₁} C`)
if it has limits of every shape `J : Type u₁` with `[Category.{v₁} J]`.
-/
@[pp_with_univ]
class HasLimitsOfSize (C : Type u) [Category.{v} C] : Prop where
  /-- All functors `F : J ⥤ C` from all small `J` have limits -/
  has_limits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasLimitsOfShape J C := by
    infer_instance
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem ringExpChar.eq_iff [Ring R] [IsDomain R] {q : ℕ} : ringExpChar R = q ↔ ExpChar R q
-- Mathlib/Topology/Covering.lean
theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)
    (he : s.EqOn (f ∘ g₁) (f ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂
-- Mathlib/Topology/PartitionOfUnity.lean
/-- If `f` is a partition of unity on `s : Set X` and `g : X → E` is continuous at every point of
the topological support of some `f i`, then `fun x ↦ f i x • g x` is continuous on the whole space.
-/
theorem continuous_smul {g : X → E} {i : ι} (hg : ∀ x ∈ tsupport (f i), ContinuousAt g x) :
    Continuous fun x => f i x • g x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arccos`, version subtracting vectors. -/
theorem oangle_sub_left_eq_arccos_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle (x - y) x = Real.arccos (‖x‖ / ‖x - y‖)
-- Mathlib/RingTheory/HahnSeries/Addition.lean
@[simp]
theorem neg_coeff' {x : HahnSeries Γ R} : (-x).coeff = -x.coeff
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioo_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ioo a b ∈ 𝓝[>] a
-- Mathlib/Order/Antichain.lean
theorem preimage (hs : IsAntichain r s) {f : β → α} (hf : Injective f)
    (h : ∀ ⦃a b⦄, r' a b → r (f a) (f b)) : IsAntichain r' (f ⁻¹' s)
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
/-- The generators of the exterior algebra are disjoint from its scalars. -/
theorem ι_range_disjoint_one :
    Disjoint (LinearMap.range (ι R : M →ₗ[R] ExteriorAlgebra R M))
      (1 : Submodule R (ExteriorAlgebra R M))
-- Mathlib/Data/PFun.lean
@[simp]
theorem toSubtype_apply (p : β → Prop) (f : α → β) (a : α) :
    toSubtype p f a = ⟨p (f a), Subtype.mk _⟩
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem binomial_eq_binomial {k l m n : ℕ} {u v : R} (hu : u ≠ 0) (hv : v ≠ 0) :
    C u * X ^ k + C v * X ^ l = C u * X ^ m + C v * X ^ n ↔
      k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
-- Mathlib/Geometry/Euclidean/Inversion/Calculus.lean
protected theorem DifferentiableAt.inversion (hc : DifferentiableAt ℝ c a)
    (hR : DifferentiableAt ℝ R a) (hx : DifferentiableAt ℝ x a) (hne : x a ≠ c a) :
    DifferentiableAt ℝ (fun a ↦ inversion (c a) (R a) (x a)) a
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem vecHead_vecAlt1 (hm : m + 2 = n + 1 + (n + 1)) (v : Fin (m + 2) → α) :
    vecHead (vecAlt1 hm v) = v 1
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem one_apply (x) : (1 : Perm α) x = x
-- Mathlib/Order/MinMax.lean
theorem min_le_of_right_le : b ≤ c → min a b ≤ c
-- Mathlib/Algebra/Order/Floor.lean
theorem map_round (f : F) (hf : StrictMono f) (a : α) : round (f a) = round a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
/-- **Jordan's inequality** for negative values. -/
lemma sin_le_two_div_pi_mul (hx : -(π / 2) ≤ x) (hx₀ : x ≤ 0) : sin x ≤ 2 / π * x
-- Mathlib/Algebra/Lie/Submodule.lean
@[elab_as_elim]
theorem iSup_induction' {ι} (N : ι → LieSubmodule R L M) {C : (x : M) → (x ∈ ⨆ i, N i) → Prop}
    (hN : ∀ (i) (x) (hx : x ∈ N i), C x (mem_iSup_of_mem i hx)) (h0 : C 0 (zero_mem _))
    (hadd : ∀ x y hx hy, C x hx → C y hy → C (x + y) (add_mem ‹_› ‹_›)) {x : M}
    (hx : x ∈ ⨆ i, N i) : C x hx
-- Mathlib/Data/Finsupp/Basic.lean
theorem sumElim_apply {α β γ : Type*} [Zero γ] (f : α →₀ γ) (g : β →₀ γ) (x : α ⊕ β) :
    sumElim f g x = Sum.elim f g x
-- Mathlib/Algebra/Group/WithOne/Defs.lean
@[to_additive (attr := simp) unzero_coe]
theorem unone_coe {x : α} (hx : (x : WithOne α) ≠ 1) : unone hx = x
-- Mathlib/SetTheory/Game/PGame.lean
@[refl, simp]
theorem equiv_rfl {x : PGame} : x ≈ x
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem Matrix.toLinearMap₂'_apply (M : Matrix n m N₂) (x : n → S₁) (y : m → S₂) :
    -- porting note: we don't seem to have `∑ i j` as valid notation yet
    Matrix.toLinearMap₂' R M x y = ∑ i, ∑ j, x i • y j • M i j
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iio_inter_Ioi : Iio a ∩ Ioi b = Ioo b a
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem roth_lower_bound : (N : ℝ) * exp (-4 * √(log N)) ≤ rothNumberNat N
-- Mathlib/MeasureTheory/Function/LpSpace.lean
private theorem tsum_nnnorm_sub_ae_lt_top {f : ℕ → α → E} (hf : ∀ n, AEStronglyMeasurable (f n) μ)
    {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h : (∫⁻ a, (∑' i, ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) ≤ ∑' i, B i) :
    ∀ᵐ x ∂μ, (∑' i, ‖f (i + 1) x - f i x‖₊ : ℝ≥0∞) < ∞
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalExtrOn.comp_antitone (hf : IsLocalExtrOn f s a) {g : β → γ}
    (hg : Antitone g) : IsLocalExtrOn (g ∘ f) s a
-- Mathlib/MeasureTheory/Integral/CircleTransform.lean
/-- The derivative of a `circleTransform` is locally bounded. -/
theorem circleTransformDeriv_bound {R : ℝ} (hR : 0 < R) {z x : ℂ} {f : ℂ → ℂ} (hx : x ∈ ball z R)
    (hf : ContinuousOn f (sphere z R)) : ∃ B ε : ℝ, 0 < ε ∧
      ball x ε ⊆ ball z R ∧ ∀ (t : ℝ), ∀ y ∈ ball x ε, ‖circleTransformDeriv R z y f t‖ ≤ B
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem map_congr_perm [DecidableEq ι] [Fintype ι] (σ : Equiv.Perm ι) :
    g v = Equiv.Perm.sign σ • g (v ∘ σ)
-- Mathlib/Algebra/Ring/Hom/Basic.lean
/-- `f : α →+* β` has a trivial codomain iff its range is `{0}`. -/
theorem codomain_trivial_iff_range_eq_singleton_zero : (0 : β) = 1 ↔ Set.range f = {0}
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[simp] theorem endofunctorMonoidalCategory_tensorObj_obj (F G : C ⥤ C) (X : C) :
    (F ⊗ G).obj X = G.obj (F.obj X)
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
theorem pullbackConeOfLeftLift_snd :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).snd = s.snd
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
@[simp] lemma equicontinuousWithinAt_univ (F : ι → X → α) (x₀ : X) :
    EquicontinuousWithinAt F univ x₀ ↔ EquicontinuousAt F x₀
-- Mathlib/Order/LiminfLimsup.lean
theorem _root_.Monotone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Monotone v) (hl : l.IsBoundedUnder (· ≥ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u)
-- Mathlib/Data/Sum/Order.lean
theorem le_def [LE α] [LE β] {a b : α ⊕ β} : a ≤ b ↔ LiftRel (· ≤ ·) (· ≤ ·) a b
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem getElem?_enumFrom :
    ∀ n (l : List α) m, (enumFrom n l)[m]? = l[m]?.map fun a => (n + m, a)
-- Mathlib/RingTheory/Unramified/Basic.lean
/-- This actually does not need the localization instance, and is stated here again for
consistency. See `Algebra.FormallyUnramified.of_comp` instead.

 The intended use is for copying proofs between `Formally{Unramified, Smooth, Etale}`
 without the need to change anything (including removing redundant arguments). -/
-- @[nolint unusedArguments] -- Porting note: removed
theorem localization_base [FormallyUnramified R Sₘ] : FormallyUnramified Rₘ Sₘ
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma Spec_presheaf (R : CommRingCat.{u}) : (Spec R).presheaf = (Spec.structureSheaf R).1
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
theorem gfpApprox_le {a : Ordinal} : gfpApprox f x a ≤ x
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem C_eq_zero : C a = 0 ↔ a = 0
-- Mathlib/Order/Partition/Finpartition.lean
theorem card_filter_atomise_le_two_pow (ht : t ∈ F) :
    ((atomise s F).parts.filter fun u ↦ u ⊆ t ∧ u.Nonempty).card ≤ 2 ^ (F.card - 1)
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- `zeta n A B` is a primitive `n`-th root of unity. -/
@[simp]
theorem zeta_spec : IsPrimitiveRoot (zeta n A B) n
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
/-- A non-trivial `concat` walk is representable as a `cons` walk. -/
theorem exists_concat_eq_cons {u v w : V} :
    ∀ (p : G.Walk u v) (h : G.Adj v w),
      ∃ (x : V) (h' : G.Adj u x) (q : G.Walk x w), p.concat h = cons h' q
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem mk_top [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) : mk ⊤ htop = ⊤
-- Mathlib/Tactic/Ring/Basic.lean
theorem sub_pf {R} [Ring R] {a b c d : R}
    (_ : -b = c) (_ : a + c = d) : a - b = d
-- Mathlib/Algebra/Polynomial/BigOperators.lean
theorem prod_X_sub_C_nextCoeff {s : Finset ι} (f : ι → R) :
    nextCoeff (∏ i ∈ s, (X - C (f i))) = -∑ i ∈ s, f i
-- Mathlib/Data/Finset/Image.lean
theorem image_biUnion_filter_eq [DecidableEq α] (s : Finset β) (g : β → α) :
    ((s.image g).biUnion fun a => s.filter fun c => g c = a) = s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arctan_add_eq_sub_pi {x y : ℝ} (h : 1 < x * y) (hx : x < 0) :
    arctan x + arctan y = arctan ((x + y) / (1 - x * y)) - π
-- Mathlib/Order/Bounds/Basic.lean
theorem isLeast_univ [OrderBot α] : IsLeast (univ : Set α) ⊥
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive (attr := simp)]
theorem unop_op (S : Submonoid M) : S.op.unop = S
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma sub {f g : 𝕜 → E} {x : 𝕜} (hf : MeromorphicAt f x) (hg : MeromorphicAt g x) :
    MeromorphicAt (f - g) x
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem uniformContinuousOn (hf : LipschitzOnWith K f s) : UniformContinuousOn f s
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- The natural equivalence between linear maps from `M` to `N`
and `1`-multilinear alternating maps from `M` to `N`. -/
@[simps!]
def ofSubsingleton [Subsingleton ι] (i : ι) : (M →ₗ[R] N) ≃ (M [⋀^ι]→ₗ[R] N)
-- Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean
/-- The free functor `Type u ⥤ ModuleCat R` sending a type `X` to the
free `R`-module with generators `x : X`, implemented as the type `X →₀ R`.
-/
@[simps]
def free : Type u ⥤ ModuleCat R
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem coe_injective : @Function.Injective (E ≃ₛₗᵢ[σ₁₂] E₂) (E → E₂) (↑)
-- Mathlib/Algebra/Group/Fin/Basic.lean
lemma coe_sub_one (a : Fin (n + 1)) : ↑(a - 1) = if a = 0 then n else a - 1
-- Mathlib/NumberTheory/MaricaSchoenheim.lean
/-- The special case of Graham's conjecture where all numbers are squarefree. -/
lemma grahamConjecture_of_squarefree {n : ℕ} (f : ℕ → ℕ) (hf' : ∀ k < n, Squarefree (f k)) :
    GrahamConjecture n f
-- Mathlib/Data/Sum/Basic.lean
theorem getLeft_eq_getLeft? (h₁ : x.isLeft) (h₂ : x.getLeft?.isSome) :
    x.getLeft h₁ = x.getLeft?.get h₂
-- Mathlib/Data/Matroid/Restrict.lean
theorem Restriction.finite {M : Matroid α} [M.Finite] (h : N ≤r M) : N.Finite
-- Mathlib/Order/Filter/Lift.lean
theorem lift_iInf [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β}
    (hg : ∀ s t, g (s ∩ t) = g s ⊓ g t) : (iInf f).lift g = ⨅ i, (f i).lift g
-- Mathlib/Algebra/Order/Monoid/Defs.lean
@[to_additive (attr := simp)]
theorem mul_self_le_one_iff : a * a ≤ 1 ↔ a ≤ 1
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem kextract_eq_dlookup_kerase (a : α) :
    ∀ l : List (Sigma β), kextract a l = (dlookup a l, kerase a l)
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_def (x : ℤ[i]) : (x : ℂ) = x.re + x.im * I
-- Mathlib/Data/Part.lean
theorem div_def [Div α] (a b : Part α) : a / b = bind a fun y => map (y / ·) b
-- Mathlib/Order/Filter/Ring.lean
@[to_additive EventuallyLE.add_le_add]
theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
    [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
    (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂
-- Mathlib/Control/Fold.lean
@[simp]
theorem foldl_map (g : β → γ) (f : α → γ → α) (a : α) (l : t β) :
    foldl f a (g <$> l) = foldl (fun x y => f x (g y)) a l
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tendsto_cofinite_zero_of_tsum_ne_top {α} {f : α → ℝ≥0∞} (hf : ∑' x, f x ≠ ∞) :
    Tendsto f cofinite (𝓝 0)
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem epi_of_cokernel_iso_zero {X Y : C} {f : X ⟶ Y} [HasColimit (parallelPair f 0)]
    (w : cokernel f ≅ 0) : Epi f
-- Mathlib/CategoryTheory/Skeletal.lean
theorem map_iso_eq {F₁ F₂ : D ⥤ C} (h : F₁ ≅ F₂) : map F₁ = map F₂
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem commute_iff_commute {f g : CircleDeg1Lift} : Commute f g ↔ Function.Commute f g