ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- A single point is collinear. -/
theorem collinear_singleton (p : P) : Collinear k ({p} : Set P)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_add_tsub_cancel (hab : b ≤ a) (hcb : c ≤ b) : a - b + (b - c) = a - c
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[nontriviality]
theorem of_subsingleton [Subsingleton M] (x : M) : IsPrimitiveRoot x 1
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem add_apply [Add α] (A B : Matrix m n α) (i : m) (j : n) :
    (A + B) i j = (A i j) + (B i j)
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem coe_toNonUnitalRingHom (f : A →⋆ₙ+* B) : ⇑f.toNonUnitalRingHom = f
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive]
theorem prod_map_zpow {n : ℤ} : (m.map fun i => f i ^ n).prod = (m.map f).prod ^ n
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem cons_vec_bit0_eq_alt0 (x : α) (u : Fin n → α) (i : Fin (n + 1)) :
    vecCons x u (i + i) = vecAlt0 rfl (vecAppend rfl (vecCons x u) (vecCons x u)) i
-- Mathlib/Data/Set/Function.lean
theorem InjOn.rightInvOn_of_leftInvOn (hf : InjOn f s) (hf' : LeftInvOn f f' t)
    (h₁ : MapsTo f s t) (h₂ : MapsTo f' t s) : RightInvOn f f' s
-- Mathlib/Data/List/Lattice.lean
theorem mem_of_mem_inter_right (h : a ∈ l₁ ∩ l₂) : a ∈ l₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem foldr_eq_foldrM (f : α → β → β) (b) (l : List α) :
    l.foldr f b = l.foldrM (m := Id) f b
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfp_mul_opow_omega_add {a c : Ordinal} (b) (ha : 0 < a) (hc : 0 < c) (hca : c ≤ (a^omega)) :
    nfp (a * ·) ((a^omega) * b + c) = (a^omega.{u}) * succ b
-- Mathlib/RingTheory/Smooth/StandardSmooth.lean
/--
An `R`-algebra `S` is called standard smooth, if there
exists a submersive presentation.
-/
class IsStandardSmooth : Prop where
  out : Nonempty (SubmersivePresentation.{t, w} R S)
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Given a point in the affine span from which all the points are
equidistant, that point is the circumcenter. -/
theorem eq_circumcenter_of_dist_eq {n : ℕ} (s : Simplex ℝ P n) {p : P}
    (hp : p ∈ affineSpan ℝ (Set.range s.points)) {r : ℝ} (hr : ∀ i, dist (s.points i) p = r) :
    p = s.circumcenter
-- Mathlib/Data/Complex/Order.lean
@[simp, norm_cast]
theorem zero_lt_real {x : ℝ} : (0 : ℂ) < (x : ℂ) ↔ 0 < x
-- Mathlib/Algebra/Lie/Basic.lean
/-- A morphism of Lie algebra modules is a linear map which commutes with the action of the Lie
algebra. -/
structure LieModuleHom extends M →ₗ[R] N where
  /-- A module of Lie algebra modules is compatible with the action of the Lie algebra on the
  modules. -/
  map_lie' : ∀ {x : L} {m : M}, toFun ⁅x, m⁆ = ⁅x, toFun m⁆
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem monic_of_b_eq_one' : (toPoly ⟨0, 1, c, d⟩).Monic
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
@[simp]
theorem X_inv : (X : k⟦X⟧)⁻¹ = 0
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma integrable_toReal_rnDeriv [IsFiniteMeasure μ] :
    Integrable (fun x ↦ (μ.rnDeriv ν x).toReal) ν
-- Mathlib/FieldTheory/IsAlgClosed/Classification.lean
/-- The cardinality of an algebraic extension is at most the maximum of the cardinality
of the base ring or `ℵ₀` -/
theorem cardinal_mk_le_max : #L ≤ max #R ℵ₀
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive norm_le_of_mem_closedBall]
theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
/-- Any `K`-algebra module that is 1-dimensional over `K` is simple. -/
theorem is_simple_module_of_finrank_eq_one {A} [Semiring A] [Module A V] [SMul K A]
    [IsScalarTower K A V] (h : finrank K V = 1) : IsSimpleOrder (Submodule A V)
-- Mathlib/Algebra/Group/Action/Basic.lean
/-- Given an action of a group `α` on a set `β`, each `g : α` defines a permutation of `β`. -/
@[simps]
def MulAction.toPermHom : α →* Equiv.Perm β
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measure_compl_le_add_iff [IsFiniteMeasure μ] (hs : MeasurableSet s) (ht : MeasurableSet t)
    {ε : ℝ≥0∞} : μ sᶜ ≤ μ tᶜ + ε ↔ μ t ≤ μ s + ε
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem mul_le_mul_left₀ (ha : a ≠ 0) : a * b ≤ a * c ↔ b ≤ c
-- Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
theorem Matrix.Represents.one : (1 : Matrix ι ι R).Represents b 1
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
lemma posSemidef_sqrt : PosSemidef hA.sqrt
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
lemma dualBasis_flip_dualBasis (B : BilinForm K V) (hB : B.Nondegenerate) {ι}
    [Finite ι] [DecidableEq ι] [FiniteDimensional K V] (b : Basis ι K V) :
    B.flip.dualBasis hB.flip (B.dualBasis hB b) = b
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
@[simp]
theorem to_mul_symm_eq : (@toConjAct G _).symm = ofConjAct
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_insert (a : α) (s : Finset α) : ↑(insert a s) = (insert a s : Set α)
-- Mathlib/Algebra/Order/Monovary.lean
@[simp] lemma antivary_inv_left₀ (hf : StrongLT 0 f) : Antivary f⁻¹ g ↔ Monovary f g
-- Mathlib/Logic/Equiv/Set.lean
/-- A family of equivalences between preimages of points gives an equivalence between domains. -/
@[simps!]
def ofPreimageEquiv {α β γ} {f : α → γ} {g : β → γ} (e : ∀ c, f ⁻¹' {c} ≃ g ⁻¹' {c}) : α ≃ β
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_map {E' : Type*} [Field E'] [Algebra F E'] (f : E →ₐ[F] E') :
    (adjoin F S).map f = adjoin F (f '' S)
-- Mathlib/Topology/Sheaves/Stalks.lean
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkSpecializes_stalkFunctor_map {F G : X.Presheaf C} (f : F ⟶ G) {x y : X} (h : x ⤳ y) :
    F.stalkSpecializes h ≫ (stalkFunctor C x).map f =
      (stalkFunctor C y).map f ≫ G.stalkSpecializes h
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem nhds_eq_iInf_abs_sub (a : α) : 𝓝 a = ⨅ r > 0, 𝓟 { b | |a - b| < r }
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
protected theorem add_tsub_cancel_right (hb : AddLECancellable b) : a + b - b = a
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma iff_eventuallyEq {f g : ℝ → ℝ} (h : f =ᶠ[atTop] g) :
    GrowsPolynomially f ↔ GrowsPolynomially g
-- Mathlib/Algebra/Lie/Abelian.lean
@[simp]
theorem LieSubmodule.trivial_lie_oper_zero [LieModule.IsTrivial L M] : ⁅I, N⁆ = ⊥
-- Mathlib/Data/Multiset/Range.lean
theorem coe_range (n : ℕ) : ↑(List.range n) = range n
-- Mathlib/Data/Part.lean
theorem Dom.of_bind {f : α → Part β} {a : Part α} (h : (a.bind f).Dom) : a.Dom
-- Mathlib/Analysis/Convex/Basic.lean
theorem Monotone.convex_le (hf : Monotone f) (r : β) : Convex 𝕜 { x | f x ≤ r }
-- Mathlib/RingTheory/Noetherian.lean
theorem IsNoetherianRing.isNilpotent_nilradical (R : Type*) [CommRing R] [IsNoetherianRing R] :
    IsNilpotent (nilradical R)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean
/-- If `m₁` and `m₂` are both homogenous,
and the quadratic spaces `Q₁` and `Q₂` map into
orthogonal subspaces of `Qₙ` (for instance, when `Qₙ = Q₁.prod Q₂`),
then the product of the embedding in `CliffordAlgebra Q` commutes up to a sign factor. -/
nonrec theorem map_mul_map_of_isOrtho_of_mem_evenOdd
    {i₁ i₂ : ZMod 2} (hm₁ : m₁ ∈ evenOdd Q₁ i₁) (hm₂ : m₂ ∈ evenOdd Q₂ i₂) :
    map f₁ m₁ * map f₂ m₂ = (-1 : ℤˣ) ^ (i₂ * i₁) • (map f₂ m₂ * map f₁ m₁)
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- If `K` is a compact set in a uniform space and `{V i | p i}` is a basis of entourages,
then `{⋃ x ∈ K, UniformSpace.ball x (V i) | p i}` is a basis of `𝓝ˢ K`.

Here "`{s i | p i}` is a basis of a filter `l`" means `Filter.HasBasis l p s`. -/
theorem IsCompact.nhdsSet_basis_uniformity {p : ι → Prop} {V : ι → Set (α × α)}
    (hbasis : (𝓤 α).HasBasis p V) (hK : IsCompact K) :
    (𝓝ˢ K).HasBasis p fun i => ⋃ x ∈ K, ball x (V i)
-- Mathlib/Algebra/DirectSum/LinearMap.lean
/-- If `f` and `g` are commuting endomorphisms of a finite, free `R`-module `M`, such that `f`
is triangularizable, then to prove that the trace of `g ∘ f` vanishes, it is sufficient to prove
that the trace of `g` vanishes on each generalized eigenspace of `f`. -/
lemma trace_comp_eq_zero_of_commute_of_trace_restrict_eq_zero
    [IsDomain R] [IsPrincipalIdealRing R] [Module.Free R M] [Module.Finite R M]
    {f g : Module.End R M}
    (h_comm : Commute f g)
    (hf : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤)
    (hg : ∀ μ, trace R _ (g.restrict (f.mapsTo_iSup_genEigenspace_of_comm h_comm μ)) = 0) :
    trace R _ (g ∘ₗ f) = 0
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem add_eq_zero_iff {a b : Tropical (WithTop R)} : a + b = 0 ↔ a = 0 ∧ b = 0
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem support_iteratedFDeriv_subset (n : ℕ) : support (iteratedFDeriv 𝕜 n f) ⊆ tsupport f
-- Mathlib/NumberTheory/PythagoreanTriples.lean
private theorem coprime_sq_sub_sq_sum_of_odd_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 1)
    (hn : n % 2 = 1) :
    2 ∣ m ^ 2 + n ^ 2 ∧
      2 ∣ m ^ 2 - n ^ 2 ∧
        (m ^ 2 - n ^ 2) / 2 % 2 = 0 ∧ Int.gcd ((m ^ 2 - n ^ 2) / 2) ((m ^ 2 + n ^ 2) / 2) = 1
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem ofInt_mul {n} (x y : Int) : BitVec.ofInt n (x * y) =
    BitVec.ofInt n x * BitVec.ofInt n y
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_lt_of_lt_of_le_one [CovariantClass α α (· * ·) (· ≤ ·)] {a b c : α} (hbc : b < c)
    (ha : a ≤ 1) :
    b * a < c
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp]
theorem one_apply (x : A) : (1 : A →ₐ[R] A) x = x
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
lemma not_inv_le_one_of_ne_bot [IsDedekindDomain A] {I : Ideal A}
    (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) : ¬(I⁻¹ : FractionalIdeal A⁰ K) ≤ 1
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.tendsto_norm_atTop_iff (h : f' =Θ[l] g') :
    Tendsto (norm ∘ f') l atTop ↔ Tendsto (norm ∘ g') l atTop
-- Mathlib/Data/Finset/Functor.lean
/-- `Finset.image₂` in terms of monadic operations. Note that this can't be taken as the definition
because of the lack of universe polymorphism. -/
theorem image₂_def {α β γ : Type u} (f : α → β → γ) (s : Finset α) (t : Finset β) :
    image₂ f s t = f <$> s <*> t
-- Mathlib/Topology/MetricSpace/Holder.lean
theorem ediam_image_le_of_subset (hf : HolderOnWith C r f s) (ht : t ⊆ s) :
    EMetric.diam (f '' t) ≤ (C : ℝ≥0∞) * EMetric.diam t ^ (r : ℝ)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem drop_succ_cons : (a :: l).drop (n + 1) = l.drop n
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
theorem not_mem_idealOfSet {s : Set X} {f : C(X, R)} : f ∉ idealOfSet R s ↔ ∃ x ∈ sᶜ, f x ≠ 0
-- Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
@[simp]
theorem star_algebraMap (r : R) :
    star (algebraMap R (CliffordAlgebra Q) r) = algebraMap R (CliffordAlgebra Q) r
-- Mathlib/Algebra/RingQuot.lean
@[ext 1100]
theorem ringQuot_ext' {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B)
    (w : f.comp (mkAlgHom S s) = g.comp (mkAlgHom S s)) : f = g
-- Mathlib/Data/Sym/Sym2.lean
/-- `mk a` as an embedding. This is the symmetric version of `Function.Embedding.sectl`. -/
@[simps]
def mkEmbedding (a : α) : α ↪ Sym2 α
-- Mathlib/Topology/Sequences.lean
theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu : ∀ n, u n ∈ s)
    (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_compl_iff : a ∈ s.compl ↔ a ∉ s
-- Mathlib/Logic/Basic.lean
theorem Not.imp_symm : (¬a → b) → ¬b → a
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem OneHom.coe_comp [One M] [One N] [One P] (g : OneHom N P) (f : OneHom M N) :
    ↑(g.comp f) = g ∘ f
-- Mathlib/Order/SupClosed.lean
@[simp] protected lemma LinearOrder.isSublattice (s : Set α) : IsSublattice s
-- Mathlib/RingTheory/Artinian.lean
theorem IsArtinianRing.of_finite (R S) [CommRing R] [Ring S] [Algebra R S]
    [IsArtinianRing R] [Module.Finite R S] : IsArtinianRing S
-- Mathlib/Order/Atoms.lean
theorem isAtom_of_u_bot [OrderBot α] [OrderBot β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (hbot : u ⊥ = ⊥) {b : β} (hb : IsAtom (u b)) : IsAtom b
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem coe_id : ⇑(id : L₁ →ₗ⁅R⁆ L₁) = _root_.id
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem unitLattice_span_eq_top :
    Submodule.span ℝ (unitLattice K : Set ({w : InfinitePlace K // w ≠ w₀} → ℝ)) = ⊤
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
theorem exists_separating_of_ne {x y : V} (h : x ≠ y) :
    ∃ f : V →L[R] R, f x ≠ f y
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_zero_map (f : R →+* S) (p : R[X]) : (p.map f).eval 0 = f (p.eval 0)
-- Mathlib/Data/Real/Hyperreal.lean
nonrec theorem Infinitesimal.add {x y : ℝ*} (hx : Infinitesimal x) (hy : Infinitesimal y) :
    Infinitesimal (x + y)
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_mul (a b c : Ordinal) : a ^ (b * c) = (a ^ b) ^ c
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The adjoint is involutive. -/
@[simp]
theorem adjoint_adjoint (A : E →ₗ[𝕜] F) : LinearMap.adjoint (LinearMap.adjoint A) = A
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem map_hnot (a : α) : f (￢a) = ￢f a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
private theorem measure_sInf_le (h : μ ∈ m) : sInf m ≤ μ
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem zero_le (I : FractionalIdeal S P) : 0 ≤ I
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma sub_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w)
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem map_pure (f : α → β) (a : α) : map f (pure a) = pure (f a)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_eq_support_max' (h : p ≠ 0) :
    p.natDegree = p.support.max' (nonempty_support_iff.mpr h)
-- Mathlib/Order/UpperLower/Basic.lean
protected theorem IsUpperSet.upperClosure (hs : IsUpperSet s) : ↑(upperClosure s) = s
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem squarefree_iff_irreducible_sq_not_dvd_of_ne_zero {r : R} (hr : r ≠ 0) :
    Squarefree r ↔ ∀ x : R, Irreducible x → ¬x * x ∣ r
-- Mathlib/Topology/ContinuousFunction/Compact.lean
@[simp]
theorem _root_.BoundedContinuousFunction.norm_mkOfCompact (f : C(α, E)) : ‖mkOfCompact f‖ = ‖f‖
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- The subgroup generated by an element of a group equals the set of integer number powers of
    the element. -/
@[to_additive
      "The `AddSubgroup` generated by an element of an `AddGroup` equals the set of
      natural number multiples of the element."]
theorem mem_closure_singleton {x y : G} : y ∈ closure ({x} : Set G) ↔ ∃ n : ℤ, x ^ n = y
-- Mathlib/Algebra/Associated/Basic.lean
theorem Irreducible.prime [DecompositionMonoid α] {a : α} (irr : Irreducible a) : Prime a
-- Mathlib/LinearAlgebra/Vandermonde.lean
theorem det_vandermonde_eq_zero_iff [IsDomain R] {n : ℕ} {v : Fin n → R} :
    det (vandermonde v) = 0 ↔ ∃ i j : Fin n, v i = v j ∧ i ≠ j
-- Mathlib/RingTheory/Nullstellensatz.lean
theorem isMaximal_iff_eq_vanishingIdeal_singleton (I : Ideal (MvPolynomial σ k)) :
    I.IsMaximal ↔ ∃ x : σ → k, I = vanishingIdeal {x}
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[csimp] theorem leftpad_eq_leftpadTR : @leftpad = @leftpadTR
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[elab_as_elim]
protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r : R} (hr : r ∈ M * N)
    (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r
-- Mathlib/Data/List/Chain.lean
theorem Chain.iff {S : α → α → Prop} (H : ∀ a b, R a b ↔ S a b) {a : α} {l : List α} :
    Chain R a l ↔ Chain S a l
-- Mathlib/Algebra/Order/ZeroLEOne.lean
/-- See `zero_lt_one'` for a version with the type explicit. -/
@[simp] lemma zero_lt_one : (0 : α) < 1
-- Mathlib/Data/Finset/Interval.lean
theorem Ioc_eq_filter_powerset : Ioc s t = t.powerset.filter (s ⊂ ·)
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
lemma IsHamiltonian.map {H : SimpleGraph β} (f : G →g H) (hf : Bijective f) (hp : p.IsHamiltonian) :
    (p.map f).IsHamiltonian
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- Pushforwards of finite submodules have a smaller finrank. -/
theorem Submodule.finrank_map_le (f : M →ₗ[R] M') (p : Submodule R M) [Module.Finite R p] :
    finrank R (p.map f) ≤ finrank R p
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem mk (s : Set α) (hs : MeasurableSet s) (h₁ : ∀ t ⊆ s, MeasurableSet t → v t = 0)
    (h₂ : ∀ t ⊆ sᶜ, MeasurableSet t → w t = 0) : v ⟂ᵥ w
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- Reinterpret `BoxIntegral.HasIntegral` as `Filter.Tendsto`, e.g., dot-notation theorems
that are shadowed in the `BoxIntegral.HasIntegral` namespace. -/
theorem HasIntegral.tendsto (h : HasIntegral I l f vol y) :
    Tendsto (integralSum f vol) (l.toFilteriUnion I ⊤) (𝓝 y)
-- Mathlib/Algebra/Lie/DirectSum.lean
/-- The projection map onto one component, as a morphism of Lie algebras. -/
@[simps]
def lieAlgebraComponent (j : ι) : (⨁ i, L i) →ₗ⁅R⁆ L j
-- Mathlib/Algebra/Algebra/Pi.lean
/-- `Function.const` as an `AlgHom`. The name matches `Pi.constRingHom`, `Pi.constMonoidHom`,
etc. -/
@[simps]
def constAlgHom : B →ₐ[R] A → B
-- Mathlib/Algebra/Category/Grp/Colimits.lean
@[simp]
theorem cocone_naturality {j j' : J} (f : j ⟶ j') :
    F.map f ≫ coconeMorphism.{w} F j' = coconeMorphism F j
-- Mathlib/Algebra/Lie/Submodule.lean
theorem lie_mem_right (I : LieIdeal R L) (x y : L) (h : y ∈ I) : ⁅x, y⁆ ∈ I
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem coeff_smul {S₁ : Type*} [SMulZeroClass S₁ R] (m : σ →₀ ℕ) (C : S₁) (p : MvPolynomial σ R) :
    coeff m (C • p) = C • coeff m p
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[elab_as_elim]
protected theorem InClosure.recOn {C : R → Prop} {x : R} (hx : x ∈ closure s) (h1 : C 1)
    (hneg1 : C (-1)) (hs : ∀ z ∈ s, ∀ n, C n → C (z * n)) (ha : ∀ {x y}, C x → C y → C (x + y)) :
    C x
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem countable_of_Lindelof_of_discrete [LindelofSpace X] [DiscreteTopology X] : Countable X
-- Mathlib/CategoryTheory/Yoneda.lean
lemma coyonedaEquiv_symm_map {X Y : C} (f : X ⟶ Y) {F : C ⥤ Type v₁} (t : F.obj X) :
    coyonedaEquiv.symm (F.map f t) = coyoneda.map f.op ≫ coyonedaEquiv.symm t
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma PosSMulMono.toPosSMulStrictMono [PosSMulMono α β] : PosSMulStrictMono α β
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
/-- A seminorm on a group `G` is a function `f : G → ℝ` that sends one to zero, is submultiplicative
and such that `f x⁻¹ = f x` for all `x`. -/
@[to_additive]
structure GroupSeminorm (G : Type*) [Group G] where
  /-- The bare function of a `GroupSeminorm`. -/
  protected toFun : G → ℝ
  /-- The image of one is zero. -/
  protected map_one' : toFun 1 = 0
  /-- The seminorm applied to a product is dominated by the sum of the seminorm applied to the
  factors. -/
  protected mul_le' : ∀ x y, toFun (x * y) ≤ toFun x + toFun y
  /-- The seminorm is invariant under inversion. -/
  protected inv' : ∀ x, toFun x⁻¹ = toFun x
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
theorem Γ_def : (Γ : _ ⥤ C) = forgetToPresheafedSpace.op ⋙ PresheafedSpace.Γ
-- Mathlib/Computability/Ackermann.lean
theorem ack_le_ack {m₁ m₂ n₁ n₂ : ℕ} (hm : m₁ ≤ m₂) (hn : n₁ ≤ n₂) : ack m₁ n₁ ≤ ack m₂ n₂
-- Mathlib/Algebra/GroupWithZero/Prod.lean
/-- Multiplication as a multiplicative homomorphism with zero. -/
@[simps]
def mulMonoidWithZeroHom [CommMonoidWithZero M₀] : M₀ × M₀ →*₀ M₀
-- Mathlib/Data/Part.lean
theorem eq_none_or_eq_some (o : Part α) : o = none ∨ ∃ x, o = some x
-- Mathlib/Logic/Equiv/Fin.lean
theorem finSuccEquiv'_symm_some_below {i : Fin (n + 1)} {m : Fin n} (h : Fin.castSucc m < i) :
    (finSuccEquiv' i).symm (some m) = Fin.castSucc m
-- Mathlib/Combinatorics/Additive/Dissociation.lean
@[to_additive (attr := simp)]
lemma mulDissociated_singleton : MulDissociated ({a} : Set α) ↔ a ≠ 1
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma root_coroot_eq_pairing : P.toLin (P.root i) (P.coroot j) = P.pairing i j
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem Filter.HasBasis.uniformity_closure {p : ι → Prop} {U : ι → Set (α × α)}
    (h : (𝓤 α).HasBasis p U) : (𝓤 α).HasBasis p fun i => closure (U i)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem union_sdiff_self_eq_union : s ∪ t \ s = s ∪ t
-- Mathlib/CategoryTheory/DiscreteCategory.lean
/-- We can convert an equivalence of `discrete` categories to a type-level `Equiv`. -/
@[simps]
def equivOfEquivalence {α : Type u₁} {β : Type u₂} (h : Discrete α ≌ Discrete β) : α ≃ β
-- Mathlib/Analysis/MeanInequalitiesPow.lean
theorem rpow_add_le_add_rpow {p : ℝ} (a b : ℝ≥0∞) (hp : 0 ≤ p) (hp1 : p ≤ 1) :
    (a + b) ^ p ≤ a ^ p + b ^ p
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_le_sin_of_le_of_le_pi_div_two {x y : ℝ} (hx₁ : -(π / 2) ≤ x) (hy₂ : y ≤ π / 2)
    (hxy : x ≤ y) : sin x ≤ sin y
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem outerMeasure_of_isOpen (U : Set G) (hU : IsOpen U) :
    μ.outerMeasure U = μ.innerContent ⟨U, hU⟩
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
theorem isSymm_transpose_mul_self [Fintype n] [CommSemiring α] (A : Matrix n n α) :
    (Aᵀ * A).IsSymm
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem SameCycle.rfl : SameCycle f x x
-- Mathlib/RingTheory/Trace/Defs.lean
theorem trace_trace_of_basis [Algebra S T] [IsScalarTower R S T] {ι κ : Type*} [Finite ι]
    [Finite κ] (b : Basis ι R S) (c : Basis κ S T) (x : T) :
    trace R S (trace S T x) = trace R T x
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsion_gc :
    @GaloisConnection (Submodule R M) (Ideal R)ᵒᵈ _ _ annihilator fun I =>
      torsionBySet R M ↑(OrderDual.ofDual I)
-- Mathlib/Topology/Sequences.lean
theorem SequentialSpace.coinduced [SequentialSpace X] (f : X → Y) :
    @SequentialSpace Y (.coinduced f ‹_›)
-- Mathlib/Combinatorics/SimpleGraph/Finsubgraph.lean
@[simp, norm_cast] lemma coe_compl (G' : G.Finsubgraph) : ↑(G'ᶜ) = (G'ᶜ : G.Subgraph)
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem star_comm_self' [Mul R] [Star R] (x : R) [IsStarNormal x] : star x * x = x * star x
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp)]
theorem smul_set_univ : a • (univ : Set β) = univ
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem tendsto_prod_uniformity_snd [UniformSpace α] [UniformSpace β] :
    Tendsto (fun p : (α × β) × α × β => (p.1.2, p.2.2)) (𝓤 (α × β)) (𝓤 β)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_mul (a b : MvPolynomial σ R) :
    (a * b).totalDegree ≤ a.totalDegree + b.totalDegree
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem HasColimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K) :
    colimit.ι G k ≫ (HasColimit.isoOfEquivalence e w).inv =
      G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ colimit.ι F (e.inverse.obj k)
-- Mathlib/Algebra/Polynomial/Div.lean
theorem multiplicity_X_sub_C_finite (a : R) (h0 : p ≠ 0) : multiplicity.Finite (X - C a) p
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem Filter.EventuallyEq.isEquivalent {u v : α → β} (h : u =ᶠ[l] v) : u ~[l] v
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem support_eq_inter_preimage :
    support f = (chartAt H c).source ∩ extChartAt I c ⁻¹' ball (extChartAt I c c) f.rOut
-- Mathlib/AlgebraicTopology/ExtraDegeneracy.lean
theorem ExtraDegeneracy.s_comp_π_succ (n : ℕ) (i : Fin (n + 1)) :
    ExtraDegeneracy.s f S n ≫ WidePullback.π _ i.succ =
      @WidePullback.π _ _ _ f.right (fun _ : Fin (n + 1) => f.left) (fun _ => f.hom) _ i
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem pow_inj_iff_of_orderOf_eq_zero (h : orderOf x = 0) {n m : ℕ} : x ^ n = x ^ m ↔ n = m
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem toSubmonoid_le {p q : Subgroup G} : p.toSubmonoid ≤ q.toSubmonoid ↔ p ≤ q
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extend_nhds {x : M} (hy : x ∈ f.source) :
    map (f.extend I) (𝓝 x) = 𝓝[range I] f.extend I x
-- Mathlib/Computability/Ackermann.lean
theorem ack_strictMono_right : ∀ m, StrictMono (ack m)