ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem le_cof {r : α → α → Prop} [IsRefl α r] (c : Cardinal) :
    c ≤ cof r ↔ ∀ {S : Set α}, (∀ a, ∃ b ∈ S, r a b) → c ≤ #S
-- Mathlib/Topology/Basic.lean
theorem isClosed_iff_clusterPt : IsClosed s ↔ ∀ a, ClusterPt a (𝓟 s) → a ∈ s
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem bot_rel_eq_leftRel (H : Subgroup G) :
    (setoid ↑(⊥ : Subgroup G) ↑H).Rel = (QuotientGroup.leftRel H).Rel
-- Mathlib/FieldTheory/SeparableClosure.lean
@[simp]
theorem finInsepDegree_top : finInsepDegree F (⊤ : IntermediateField E K) = finInsepDegree F K
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma rnDeriv_def' (κ η : Kernel α γ) :
    rnDeriv κ η = fun a x ↦ ENNReal.ofReal (rnDerivAux κ (κ + η) a x)
      / ENNReal.ofReal (1 - rnDerivAux κ (κ + η) a x)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_iff_of_neg (hc : c < 0) : b / c < a ↔ a * c < b
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.count_normalizedFactors_eq {p x : Ideal R} [hp : p.IsPrime] {n : ℕ} (hle : x ≤ p ^ n)
    [DecidableEq (Ideal R)] (hlt : ¬x ≤ p ^ (n + 1)) : (normalizedFactors x).count p = n
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem disjoint_cons_left : Disjoint (a::l₁) l₂ ↔ (a ∉ l₂) ∧ Disjoint l₁ l₂
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem MonotoneOn.integrableOn_isCompact [IsFiniteMeasureOnCompacts μ] (hs : IsCompact s)
    (hmono : MonotoneOn f s) : IntegrableOn f s μ
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem exists_of_eraseP : ∀ {l : List α} {a} (al : a ∈ l) (pa : p a),
    ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l.eraseP p = l₁ ++ l₂
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem mul_sq_le_sum_sq (hst : s ⊆ t) (f : ι → 𝕜) (hs : x ^ 2 ≤ ((∑ i ∈ s, f i) / s.card) ^ 2)
    (hs' : (s.card : 𝕜) ≠ 0) : (s.card : 𝕜) * x ^ 2 ≤ ∑ i ∈ t, f i ^ 2
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma inr_desc : inr φ ≫ desc φ α β eq = β
-- Mathlib/Data/List/Infix.lean
theorem prefix_concat_iff {l₁ l₂ : List α} {a : α} :
    l₁ <+: l₂ ++ [a] ↔ l₁ = l₂ ++ [a] ∨ l₁ <+: l₂
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem norm_eq_sqrt_inner (x : F) : ‖x‖ = √(re ⟪x, x⟫)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
theorem integral_deriv_comp_mul_deriv' {f f' g g' : ℝ → ℝ} (hf : ContinuousOn f [[a, b]])
    (hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x)
    (hf' : ContinuousOn f' [[a, b]]) (hg : ContinuousOn g [[f a, f b]])
    (hgg' : ∀ x ∈ Ioo (min (f a) (f b)) (max (f a) (f b)), HasDerivWithinAt g (g' x) (Ioi x) x)
    (hg' : ContinuousOn g' (f '' [[a, b]])) :
    (∫ x in a..b, (g' ∘ f) x * f' x) = (g ∘ f) b - (g ∘ f) a
-- Mathlib/Data/List/Join.lean
/-- See `List.count_join` for the corresponding statement using `List.sum`. -/
lemma count_join' [BEq α] (L : List (List α)) (a : α) :
    L.join.count a = Nat.sum (L.map (count a))
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
lemma map_add_eq_map_add_linearDeriv_add [DecidableEq ι] [Fintype ι] (x h : (i : ι) → M₁ i) :
    f (x + h) = f x + f.linearDeriv x h +
      ∑ s ∈ univ.powerset.filter (2 ≤ ·.card), f (s.piecewise h x)
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- Isometries preserve the diameter in pseudoemetric spaces. -/
theorem ediam_image (hf : Isometry f) (s : Set α) : EMetric.diam (f '' s) = EMetric.diam s
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem IsPerfectClosure.ker_eq [PerfectRing L p] [IsPerfectClosure i p] :
    RingHom.ker i = pNilradical K p
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_tensorUnit : mop (𝟙_ C) = 𝟙_ Cᴹᵒᵖ
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biInter_insert_update {x : α} {t : Finset α} (f : α → Set β) {s : Set β} (hx : x ∉ t) :
    ⋂ i ∈ insert x t, @update _ _ _ f x s i = s ∩ ⋂ i ∈ t, f i
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem toList_mapVal (f : α → β → δ) (l : AssocList α β) :
    (mapVal f l).toList = l.toList.map (fun (a, b) => (a, f a b))
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- `sInf s < b` when there is an element `a` in `s` with `a < b`, when `s` is bounded below.
This is essentially an iff, except that the assumptions for the two implications are
slightly different (one needs boundedness below for one direction, nonemptiness and linear
order for the other one), so we formulate separately the two implications, contrary to
the `CompleteLattice` case. -/
theorem csInf_lt_of_lt : BddBelow s → a ∈ s → a < b → sInf s < b
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem pow_left_iff (hm : 0 < m) : IsRelPrime (x ^ m) y ↔ IsRelPrime x y
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[ext]
lemma hom_ext {M N : CoalgebraCat.{v} R} (f g : M ⟶ N) (h : f.toCoalgHom = g.toCoalgHom) :
    f = g
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem bnot_isLeft (x : α ⊕ β) : !x.isLeft = x.isRight
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem moebius_mul_coe_zeta : (μ * ζ : ArithmeticFunction ℤ) = 1
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
theorem integral_deriv_eq_sub' (f) (hderiv : deriv f = f')
    (hdiff : ∀ x ∈ uIcc a b, DifferentiableAt ℝ f x) (hcont : ContinuousOn f' (uIcc a b)) :
    ∫ y in a..b, f' y = f b - f a
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_surjective_eq_arrow_of_lift_le (lle : lift.{u} #β' ≤ lift.{v} #α) :
    #{f : α → β' | Surjective f} = #(α → β')
-- Mathlib/Order/Closure.lean
theorem closure_sup_closure_right (x y : α) : u (l (x ⊔ u (l y))) = u (l (x ⊔ y))
-- Mathlib/Order/Disjoint.lean
theorem eq_top_of_bot_isCompl (h : IsCompl ⊥ x) : x = ⊤
-- Mathlib/Data/Semiquot.lean
theorem liftOn_ofMem (q : Semiquot α) (f : α → β)
    (h : ∀ a ∈ q, ∀ b ∈ q, f a = f b) (a : α) (aq : a ∈ q) : liftOn q f h = f a
-- Mathlib/Data/Multiset/Basic.lean
@[simp 1100, nolint simpNF]
theorem mem_map_of_injective {f : α → β} (H : Function.Injective f) {a : α} {s : Multiset α} :
    f a ∈ map f s ↔ a ∈ s
-- Mathlib/Data/Finset/Grade.lean
/-- Finsets form an order-connected suborder of multisets. -/
lemma ordConnected_range_val : Set.OrdConnected (Set.range val : Set <| Multiset α)
-- Mathlib/Algebra/Group/Int.lean
@[parity_simps] lemma even_add_one : Even (n + 1) ↔ ¬Even n
-- Mathlib/Data/Real/Basic.lean
theorem cauchy_mul : ∀ a b, (a * b : ℝ).cauchy = a.cauchy * b.cauchy
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@[simp]
theorem mk'_one (h : IsIntegral R (1 : B) := isIntegral_one) : mk' A 1 h = 1
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
/-- The diagonal matrix `diagonal v` is symmetric. -/
@[simp]
theorem isSymm_diagonal [DecidableEq n] [Zero α] (v : n → α) : (diagonal v).IsSymm
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
/-- `Matrix.trace` as an `AddMonoidHom` -/
@[simps]
def traceAddMonoidHom : Matrix n n R →+ R
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
lemma homMk'_mk_id (f : S ⟶ T.obj Y) : homMk' (mk f) (𝟙 Y) = eqToHom (by aesop_cat)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Twice the angle between the negation of a vector and that vector is 0. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem two_zsmul_oangle_neg_self_left (x : V) : (2 : ℤ) • o.oangle (-x) x = 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem or_and_distrib_left  : ∀ (x y z : Bool), (x || y && z) = ((x || y) && (x || z))
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivAtFilter.mono (h : HasDerivAtFilter f f' x L₂) (hst : L₁ ≤ L₂) :
    HasDerivAtFilter f f' x L₁
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma finsetEquivSet_apply (s : Finset α) : finsetEquivSet s = s
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem mul_swap_eq_iff {i j : α} {σ : Perm α} : σ * swap i j = σ ↔ i = j
-- Mathlib/Tactic/CC/Lemmas.lean
theorem imp_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a → b) = True
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem _root_.SemiconjBy.tmul {a₁ a₂ a₃ : A} {b₁ b₂ b₃ : B}
    (ha : SemiconjBy a₁ a₂ a₃) (hb : SemiconjBy b₁ b₂ b₃) :
    SemiconjBy (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) (a₃ ⊗ₜ[R] b₃)
-- Mathlib/SetTheory/Game/PGame.lean
theorem ge {x y : PGame} (r : x ≡r y) : y ≤ x
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
lemma _root_.NonUnitalAlgHom.toAlgHom_zero :
    ⇑(0 : A →ₙₐ[R] R).toAlgHom = Unitization.fst
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Energy.lean
@[simp, norm_cast]
theorem coe_energy {𝕜 : Type*} [LinearOrderedField 𝕜] : (P.energy G : 𝕜) =
    (∑ uv ∈ P.parts.offDiag, (G.edgeDensity uv.1 uv.2 : 𝕜) ^ 2) / (P.parts.card : 𝕜) ^ 2
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[ext]
theorem ext {φ₁ φ₂ : (⨂[R] i, s i) →ₗ[R] E}
    (H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)) : φ₁ = φ₂
-- Mathlib/CategoryTheory/Bicategory/Kan/IsKan.lean
/-- Two 2-morphisms out of a left Kan extension are equal if their compositions with
each triangle 2-morphism are equal. -/
theorem hom_ext (H : IsKan t) {k : b ⟶ c} {τ τ' : t.extension ⟶ k}
    (w : t.unit ≫ f ◁ τ = t.unit ≫ f ◁ τ') : τ = τ'
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma Set.Finite.isCompact_exterior (hs : s.Finite) : IsCompact (exterior s)
-- Mathlib/Data/Nat/Defs.lean
/-- If `m` and `n` are equal mod `k`, `m - n` is zero mod `k`. -/
lemma sub_mod_eq_zero_of_mod_eq (h : m % k = n % k) : (m - n) % k = 0
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem abs_toZNum : ∀ n : Num, abs n.toZNum = n
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma hasSum_int_sinKernel (a : ℝ) {t : ℝ} (ht : 0 < t) : HasSum
    (fun n : ℤ ↦ -I * n * cexp (2 * π * I * a * n) * rexp (-π * n ^ 2 * t)) ↑(sinKernel a t)
-- Mathlib/Order/Filter/Basic.lean
/-- If `f : ι → Filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `iInf f ≠ ⊥`.
See also `iInf_neBot_of_directed'` for a version assuming `Nonempty ι` instead of `Nonempty α`. -/
theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
    (hb : ∀ i, NeBot (f i)) : NeBot (iInf f)
-- Mathlib/Algebra/Order/Monoid/NatCast.lean
lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
    (1 : α) ≤ 2
-- Mathlib/NumberTheory/NumberField/ClassNumber.lean
theorem classNumber_eq : NumberField.classNumber ℚ = 1
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_image {s : Set β} {f : β → α} : sSup (f '' s) = ⨆ a ∈ s, f a
-- Mathlib/Data/List/Basic.lean
theorem foldl_eq_of_comm_of_assoc (hcomm : Commutative f) (hassoc : Associative f) :
    ∀ a b l, foldl f a (b :: l) = f b (foldl f a l)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_blsub {o} (f : ∀ a < o, Ordinal) (i h) : f i h < blsub o f
-- Mathlib/Order/SuccPred/Limit.lean
protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a
-- Mathlib/Data/Set/Pointwise/Support.lean
theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
    (support fun x ↦ f (c⁻¹ • x)) = c • support f
-- Mathlib/Data/Set/Basic.lean
theorem _root_.Disjoint.inter_eq : Disjoint s t → s ∩ t = ∅
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Removal.lean
private lemma triangle_removal_aux (hε : 0 < ε) (hP₁ : P.IsEquipartition)
    (hP₃ : P.parts.card ≤ bound (ε / 8) ⌈4/ε⌉₊)
    (ht : t ∈ (G.regularityReduced P (ε/8) (ε/4)).cliqueFinset 3) :
    triangleRemovalBound ε * card α ^ 3 ≤ (G.cliqueFinset 3).card
-- Mathlib/Data/Sym/Sym2.lean
theorem toRel_fromRel (sym : Symmetric r) : ToRel (fromRel sym) = r
-- Mathlib/Data/Multiset/Sum.lean
theorem disjSum_mono_left (t : Multiset β) : Monotone fun s : Multiset α => s.disjSum t
-- Mathlib/Data/ENat/Basic.lean
theorem sub_top (a : ℕ∞) : a - ⊤ = 0
-- Mathlib/Algebra/Group/Invertible/Defs.lean
/-- `Invertible a` gives a two-sided multiplicative inverse of `a`. -/
class Invertible [Mul α] [One α] (a : α) : Type u where
  /-- The inverse of an `Invertible` element -/
  invOf : α
  /-- `invOf a` is a left inverse of `a` -/
  invOf_mul_self : invOf * a = 1
  /-- `invOf a` is a right inverse of `a` -/
  mul_invOf_self : a * invOf = 1
-- Mathlib/Algebra/Ring/Divisibility/Lemmas.lean
lemma add_pow_dvd_pow_of_pow_eq_zero_right (hp : n + m ≤ p + 1) (h_comm : Commute x y)
    (hx : x ^ n = 0) : (x + y) ^ m ∣ y ^ p
-- Mathlib/Data/Nat/Factorization/Basic.lean
theorem dvd_iff_prime_pow_dvd_dvd (n d : ℕ) :
    d ∣ n ↔ ∀ p k : ℕ, Prime p → p ^ k ∣ d → p ^ k ∣ n
-- Mathlib/Data/Complex/Exponential.lean
@[gcongr]
theorem exp_lt_exp_of_lt {x y : ℝ} (h : x < y) : exp x < exp y
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem associator_naturality_middle (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d) :
    (f ◁ η) ▷ h ≫ (α_ f g' h).hom = (α_ f g h).hom ≫ f ◁ η ▷ h
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem mem_ndinsert_self (a : α) (s : Multiset α) : a ∈ ndinsert a s
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem cos_sub_pi (θ : Angle) : cos (θ - π) = -cos θ
-- Mathlib/Tactic/CC/Lemmas.lean
theorem if_eq_of_eq_true {c : Prop} [d : Decidable c] {α : Sort u} (t e : α) (h : c = True) :
    @ite α c d t e = t
-- Mathlib/Data/List/Sort.lean
/-- Inserting then erasing an element that is absent is the identity. -/
theorem erase_orderedInsert_of_not_mem [DecidableEq α]
    {x : α} {xs : List α} (hx : x ∉ xs) :
    (xs.orderedInsert r x).erase x = xs
-- Mathlib/Data/Nat/Bits.lean
theorem bit_add' : ∀ (b : Bool) (n m : ℕ), bit b (n + m) = bit b n + bit false m
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem content_C_mul (r : R) (p : R[X]) : (C r * p).content = normalize r * p.content
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem coeff_mul_monomial (p : R[X]) (n d : ℕ) (r : R) :
    coeff (p * monomial n r) (d + n) = coeff p d * r
-- Mathlib/Data/Part.lean
@[to_additive]
theorem div_mem_div [Div α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma / mb ∈ a / b
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma π_comp_leftHomologyIso_inv :
    h.π ≫ h.leftHomologyIso.inv = h.cyclesIso.inv ≫ S.leftHomologyπ
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
theorem entry_norm_bound_of_unitary {U : Matrix n n 𝕜} (hU : U ∈ Matrix.unitaryGroup n 𝕜)
    (i j : n) : ‖U i j‖ ≤ 1
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_apply_right (a : α) : toIocDiv hp a (a + p) = 0
-- Mathlib/Data/Matrix/Reflection.lean
/-- This can be use to prove
```lean
example (P : Matrix (Fin 2) (Fin 3) α → Prop) :
  (∀ x, P x) ↔ ∀ a b c d e f, P !![a, b, c; d, e, f] :=
(forall_iff _).symm
```
-/
theorem forall_iff : ∀ {m n} (P : Matrix (Fin m) (Fin n) α → Prop), Forall P ↔ ∀ x, P x
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem derivWithin_sub (hxs : UniqueDiffWithinAt 𝕜 s x) (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) :
    derivWithin (fun y => f y - g y) s x = derivWithin f s x - derivWithin g s x
-- Mathlib/Algebra/Homology/ExactSequence.lean
lemma isComplex₂_mk (S : ComposableArrows C 2) (w : S.map' 0 1 ≫ S.map' 1 2 = 0) :
    S.IsComplex
-- Mathlib/Analysis/Complex/OperatorNorm.lean
@[simp]
theorem ofRealCLM_norm : ‖ofRealCLM‖ = 1
-- Mathlib/Data/Finmap.lean
theorem keys_union {s₁ s₂ : Finmap β} : (s₁ ∪ s₂).keys = s₁.keys ∪ s₂.keys
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem aevalTower_C (x : R) : aevalTower g y (C x) = g x
-- Mathlib/Order/Basic.lean
@[simp] lemma le_of_subsingleton [Subsingleton α] : a ≤ b
-- Mathlib/GroupTheory/GroupAction/Hom.lean
theorem ext_iff {f g : A →ₑ+[φ] B} : f = g ↔ ∀ x, f x = g x
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem Metric.finite_isBounded_inter_isClosed [ProperSpace α] {K s : Set α} [DiscreteTopology s]
    (hK : IsBounded K) (hs : IsClosed s) : Set.Finite (K ∩ s)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The abscissa of absolute convergence of the L-series of a Dirichlet character mod `N > 0`
is `1`. -/
lemma absicssaOfAbsConv_eq_one {N : ℕ} (hn : N ≠ 0) (χ : DirichletCharacter ℂ N) :
    abscissaOfAbsConv ↗χ = 1
-- Mathlib/Order/Cover.lean
theorem covBy_iff : x ⋖ y ↔ x.1 ⋖ y.1 ∧ x.2 = y.2 ∨ x.2 ⋖ y.2 ∧ x.1 = y.1
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
/-- For a self-adjoint operator `T`, a maximum of the Rayleigh quotient of `T` on a sphere centred
at the origin is an eigenvector of `T`, with eigenvalue the global supremum of the Rayleigh
quotient. -/
theorem hasEigenvector_of_isMaxOn (hT : IsSelfAdjoint T) {x₀ : E} (hx₀ : x₀ ≠ 0)
    (hextr : IsMaxOn T.reApplyInnerSelf (sphere (0 : E) ‖x₀‖) x₀) :
    HasEigenvector (T : E →ₗ[𝕜] E) (↑(⨆ x : { x : E // x ≠ 0 }, T.rayleighQuotient x)) x₀
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_mul_add_pos {b v : Ordinal} (hb : b ≠ 0) (u : Ordinal) (hv : v ≠ 0) (w : Ordinal) :
    0 < b ^ u * v + w
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
/-- A limit of a.e.-measurable `ℝ≥0∞` valued functions is a.e.-measurable. -/
lemma aemeasurable_of_tendsto {f : ℕ → α → ℝ≥0∞} {g : α → ℝ≥0∞} {μ : Measure α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hlim : ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (g a))) :
    AEMeasurable g μ
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- `cyclotomic' n K` splits. -/
theorem cyclotomic'_splits (n : ℕ) : Splits (RingHom.id K) (cyclotomic' n K)
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem sum_smul_index_linearMap' [Semiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid M₂]
    [Module R M₂] {v : α →₀ M} {c : R} {h : α → M →ₗ[R] M₂} :
    ((c • v).sum fun a => h a) = c • v.sum fun a => h a
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
@[simp] lemma support_one : support (1 : ι → R) = univ
-- Mathlib/Order/ConditionallyCompleteLattice/Finset.lean
theorem Set.Nonempty.csInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s
-- Mathlib/GroupTheory/Perm/Support.lean
theorem Disjoint.zpow_disjoint_zpow {σ τ : Perm α} (hστ : Disjoint σ τ) (m n : ℤ) :
    Disjoint (σ ^ m) (τ ^ n)
-- Mathlib/Algebra/Ring/CompTypeclasses.lean
/-- Class expressing the fact that a `RingHom` is surjective. This is needed in the context
of semilinear maps, where some lemmas require this. -/
class RingHomSurjective (σ : R₁ →+* R₂) : Prop where
  /-- The ring homomorphism is surjective -/
  is_surjective : Function.Surjective σ
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
/-- `SpecΓIdentity` is iso so these are mutually two-sided inverses. -/
theorem right_triangle (R : CommRingCat) :
    identityToΓSpec.app (Spec.toLocallyRingedSpace.obj <| op R) ≫
        Spec.toLocallyRingedSpace.map (SpecΓIdentity.inv.app R).op =
      𝟙 _
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
@[simp] lemma zeckendorf_zero : zeckendorf 0 = []
-- Mathlib/Data/NNReal/Basic.lean
theorem toNNReal_pow {x : ℝ} (hx : 0 ≤ x) (n : ℕ) : (x ^ n).toNNReal = x.toNNReal ^ n
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
@[to_additive (attr := simp, norm_cast)]
protected theorem val_smul_of_tower (r : M) (x : s) : (↑(r • x) : α) = r • (x : α)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasFDerivWithinAt.list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, HasFDerivWithinAt (f i ·) (f' i) s x) :
    HasFDerivWithinAt (fun x ↦ (l.map (f · x)).prod)
      (∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (f' (l.get i)) ((l.drop (.succ i)).map (f · x)).prod) s x
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma P24_of_ih (ihxy : IH1 x y) (i j) : P24 (x.moveLeft i) (x.moveLeft j) y
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem left_eq_id {X Y : StructuredArrow S T} (f : X ⟶ Y) : f.left = 𝟙 _
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The pigeonhole principle for finitely many pigeons counted by heads: there is a pigeonhole with
at least as many pigeons as the ceiling of the average number of pigeons across all pigeonholes.
("The maximum is at least the mean" specialized to integers.)

More formally, given a function between finite sets `s` and `t` and a natural number `n` such that
`card t * n < card s`, there exists `y ∈ t` such that its preimage in `s` has more than `n`
elements. -/
theorem exists_lt_card_fiber_of_mul_lt_card_of_maps_to (hf : ∀ a ∈ s, f a ∈ t)
    (hn : t.card * n < s.card) : ∃ y ∈ t, n < (s.filter fun x => f x = y).card
-- Mathlib/Algebra/AddConstMap/Basic.lean
/-- Pointwise scalar multiplication of `f : G →+c[a, b] H` as a map `G →+c[a, c • b] H`. -/
@[simps (config := .asFn)]
def smul [DistribSMul K H] (c : K) (f : G →+c[a, b] H) : G →+c[a, c • b] H
-- Mathlib/Data/ENNReal/Operations.lean
theorem sub_sub_cancel (h : a ≠ ∞) (h2 : b ≤ a) : a - (a - b) = b
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem mem_closure {x : R} {s : Set R} : x ∈ closure s ↔ ∀ S : Subring R, s ⊆ S → x ∈ S
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem exists_maximal_algebraicIndependent (s t : Set A) (hst : s ⊆ t)
    (hs : AlgebraicIndependent R ((↑) : s → A)) :
    ∃ u : Set A, AlgebraicIndependent R ((↑) : u → A) ∧ s ⊆ u ∧ u ⊆ t ∧
      ∀ x : Set A, AlgebraicIndependent R ((↑) : x → A) → u ⊆ x → x ⊆ t → x = u
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffAt.restrict_scalars (h : ContDiffAt 𝕜' n f x) : ContDiffAt 𝕜 n f x
-- Mathlib/LinearAlgebra/Prod.lean
theorem ker_prodMap (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄) :
    ker (LinearMap.prodMap f g) = Submodule.prod (ker f) (ker g)
-- Mathlib/Order/Lattice.lean
/-- A distributive lattice is a lattice that satisfies any of four
equivalent distributive properties (of `sup` over `inf` or `inf` over `sup`,
on the left or right).

The definition here chooses `le_sup_inf`: `(x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ (y ⊓ z)`. To prove distributivity
from the dual law, use `DistribLattice.of_inf_sup_le`.

A classic example of a distributive lattice
is the lattice of subsets of a set, and in fact this example is
generic in the sense that every distributive lattice is realizable
as a sublattice of a powerset lattice. -/
class DistribLattice (α) extends Lattice α where
  /-- The infimum distributes over the supremum -/
  protected le_sup_inf : ∀ x y z : α, (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_apply_of_not_continuousOn {f : R → R} (a : A) (hf : ¬ ContinuousOn f (spectrum R a)) :
    cfc f a = 0
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem piEquivFin_apply (n : ℕ) (x : AdicCompletion I (Fin n → R)) :
    piEquivFin I n x = pi I (fun _ : Fin n ↦ R) x
-- Mathlib/Algebra/Algebra/Operations.lean
theorem mul_mem_mul (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_inv (v : AddValuation K Γ₀) {x : K} : v x⁻¹ = - (v x)
-- .lake/packages/batteries/Batteries/Classes/Order.lean
@[simp] theorem swap_swap {o : Ordering} : o.swap.swap = o
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem toEuclideanLin_eq_toLin [Finite m] :
    (toEuclideanLin : Matrix m n 𝕜 ≃ₗ[𝕜] _) =
      Matrix.toLin (PiLp.basisFun _ _ _) (PiLp.basisFun _ _ _)
-- Mathlib/NumberTheory/ModularForms/Basic.lean
theorem ModularForm.toFun_eq_coe (f : ModularForm Γ k) : f.toFun = (f : ℍ → ℂ)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem endPos_eq_zero : ∀ (s : String), endPos s = 0 ↔ s = ""
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_right_inj (ha : AddLECancellable a) (hb : AddLECancellable b)
    (hc : AddLECancellable c) (hba : b ≤ a) (hca : c ≤ a) : a - b = a - c ↔ b = c
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem mul_upcrossingsBefore_le (hf : a ≤ f N ω) (hab : a < b) :
    (b - a) * upcrossingsBefore a b f N ω ≤
    ∑ k ∈ Finset.range N, upcrossingStrat a b f N k ω * (f (k + 1) - f k) ω
-- Mathlib/Topology/Order/Hom/Esakia.lean
theorem copy_eq (f : EsakiaHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm is multiplicative. -/
@[simp]
protected theorem mul (q r : ℚ) : padicNorm p (q * r) = padicNorm p q * padicNorm p r
-- Mathlib/Topology/Instances/AddCircle.lean
theorem addOrderOf_div_of_gcd_eq_one {m n : ℕ} (hn : 0 < n) (h : m.gcd n = 1) :
    addOrderOf (↑(↑m / ↑n * p) : AddCircle p) = n
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem ae_measure_preimage_mul_right_lt_top (hμs : μ' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((· * x) ⁻¹' s) < ∞