ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_Icc : BddBelow (Icc a b)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_sup_left {S T : Subgroup G} : ∀ {x : G}, x ∈ S → x ∈ S ⊔ T
-- Mathlib/CategoryTheory/Monad/Monadicity.lean
/--
We have a bijection of homsets which will be used to construct the left adjoint to the comparison
functor.
-/
@[simps!]
def comparisonLeftAdjointHomEquiv (A : adj.toMonad.Algebra) (B : D)
    [HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] :
    (comparisonLeftAdjointObj adj A ⟶ B) ≃ (A ⟶ (comparison adj).obj B)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.node {s l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : BalancedSz (size l) (size r)) (hs : s = size l + size r + 1) :
    Valid' o₁ (@node α s l x r) o₂
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
nonrec theorem norm_toLp [Fact (1 ≤ p)] (f : α →ₛ E) (hf : Memℒp f p μ) :
    ‖toLp f hf‖ = ENNReal.toReal (eLpNorm f p μ)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_sub_one (a : α) : round (a - 1) = round a - 1
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivWithinAt.smul_const (hc : HasDerivWithinAt c c' s x) (f : F) :
    HasDerivWithinAt (fun y => c y • f) (c' • f) s x
-- Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean
theorem bounded_mem (f : ℍ → ℂ) :
    IsBoundedAtImInfty f ↔ ∃ M A : ℝ, ∀ z : ℍ, A ≤ im z → abs (f z) ≤ M
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[simp]
theorem _root_.aestronglyMeasurable_union_iff [PseudoMetrizableSpace β] {s t : Set α} :
    AEStronglyMeasurable f (μ.restrict (s ∪ t)) ↔
      AEStronglyMeasurable f (μ.restrict s) ∧ AEStronglyMeasurable f (μ.restrict t)
-- Mathlib/Algebra/Lie/Basic.lean
@[norm_cast, simp]
theorem coe_sub (f g : M →ₗ⁅R,L⁆ N) : ⇑(f - g) = f - g
-- Mathlib/Algebra/GroupWithZero/Invertible.lean
theorem invOf_div (a b : α) [Invertible a] [Invertible b] [Invertible (a / b)] :
    ⅟ (a / b) = b / a
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem ae_lt_top {f : α → ℝ≥0∞} (hf : Measurable f) (h2f : ∫⁻ x, f x ∂μ ≠ ∞) :
    ∀ᵐ x ∂μ, f x < ∞
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp]
theorem coe_mul (f g : A →A[R] A) : ⇑(f * g) = f ∘ g
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem smul_fst : (c • x).fst = c • x.fst
-- Mathlib/Data/DFinsupp/NeLocus.lean
@[simp]
theorem neLocus_neg_neg : neLocus (-f) (-g) = f.neLocus g
-- Mathlib/Algebra/Ring/Defs.lean
@[simp]
theorem mul_neg (a b : α) : a * -b = -(a * b)
-- .lake/packages/lean4/src/lean/Init/Control/ExceptCps.lean
@[simp] theorem runCatch_bind_lift [Monad m] (x : m α) (f : α → ExceptCpsT β m β) : runCatch (ExceptCpsT.lift x >>= f : ExceptCpsT β m β) = x >>= fun a => runCatch (f a)
-- Mathlib/Data/DFinsupp/Basic.lean
/-- Bijection obtained by separating the term of index `none` of a dfinsupp over `Option ι`.

This is the dfinsupp version of `Equiv.piOptionEquivProd`. -/
@[simps]
noncomputable def equivProdDFinsupp [∀ i, Zero (α i)] :
    (Π₀ i, α i) ≃ α none × Π₀ i, α (some i)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformContinuous₂.bicompl {f : α → β → γ} {ga : δ → α} {gb : δ' → β}
    (hf : UniformContinuous₂ f) (hga : UniformContinuous ga) (hgb : UniformContinuous gb) :
    UniformContinuous₂ (bicompl f ga gb)
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (x : G) (n : ℕ) : f (x + n • a) = f x + n • b
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp, nolint simpNF] -- porting note (#10618): `simpNF` says `simp` can prove this, but it can't
theorem mem_carrier {s : StarSubalgebra R A} {x : A} : x ∈ s.carrier ↔ x ∈ s
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem image_mul : m '' (s * t) = m '' s * m '' t
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem comp_hom' {M N K : Mon_ C} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : Hom M K).hom = f.hom ≫ g.hom
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem lcongr_single {ι κ : Sort _} (e₁ : ι ≃ κ) (e₂ : M ≃ₗ[R] N) (i : ι) (m : M) :
    lcongr e₁ e₂ (Finsupp.single i m) = Finsupp.single (e₁ i) (e₂ m)
-- Mathlib/Data/Int/Defs.lean
lemma sign_natCast_of_ne_zero {n : ℕ} (hn : n ≠ 0) : Int.sign n = 1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem nextCoeff_of_natDegree_pos (hp : 0 < p.natDegree) :
    nextCoeff p = p.coeff (p.natDegree - 1)
-- Mathlib/Data/Nat/Cast/Defs.lean
@[simp]
theorem binCast_eq [AddMonoidWithOne R] (n : ℕ) :
    (Nat.binCast n : R) = ((n : ℕ) : R)
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (_ : b < a), b
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem all_iff (s : String) (p : Char → Bool) : all s p ↔ ∀ c ∈ s.1, p c
-- Mathlib/Order/CompleteLattice.lean
theorem Function.Surjective.iInf_comp {f : ι → ι'} (hf : Surjective f) (g : ι' → α) :
    ⨅ x, g (f x) = ⨅ y, g y
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma toFiniteAux_absolutelyContinuous_toFinite (μ : Measure α) [SFinite μ] :
    μ.toFiniteAux ≪ μ.toFinite
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem subgroup_moeb (A : Γ) (z : ℍ) : A • z = (A : GL(2, ℝ)⁺) • z
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_eq_algebraMap_mul_of [CommSemiring k] [Monoid G] (a : G) (b : k) :
    single a b = algebraMap k (MonoidAlgebra k G) b * of k G a
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem oneCocycles_map_mul_of_isTrivial [A.IsTrivial] (f : oneCocycles A) (g h : G) :
    f.1 (g * h) = f.1 g + f.1 h
-- Mathlib/Algebra/Ring/CentroidHom.lean
lemma centerToCentroid_apply (z : NonUnitalSubsemiring.center α) (a : α) :
    (centerToCentroid z) a = z * a
-- Mathlib/Data/Prod/PProd.lean
@[simp]
theorem «forall» {p : PProd α β → Prop} : (∀ x, p x) ↔ ∀ a b, p ⟨a, b⟩
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem mul_le_right_iff_opow_omega_dvd {a b : Ordinal} (ha : 0 < a) :
    a * b ≤ b ↔ (a^omega) ∣ b
-- Mathlib/Topology/Homotopy/Product.lean
@[simp]
theorem projRight_prod : projRight (prod q₁ q₂) = q₂
-- Mathlib/Data/ZMod/Basic.lean
@[simp, norm_cast]
theorem coe_valMinAbs : ∀ {n : ℕ} (x : ZMod n), (x.valMinAbs : ZMod n) = x
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- If the domain has a zero (and is nontrivial), then `χ 0 = 0`. -/
protected theorem map_zero {R : Type*} [CommMonoidWithZero R] [Nontrivial R] (χ : MulChar R R') :
    χ (0 : R) = 0
-- Mathlib/LinearAlgebra/Span.lean
theorem span_attach_biUnion [DecidableEq M] {α : Type*} (s : Finset α) (f : s → Finset M) :
    span R (s.attach.biUnion f : Set M) = ⨆ x, span R (f x)
-- Mathlib/CategoryTheory/Preadditive/EilenbergMoore.lean
/-- The category of coalgebras over an additive comonad on a preadditive category is preadditive. -/
@[simps]
instance Comonad.coalgebraPreadditive : Preadditive (Comonad.Coalgebra U)
-- Mathlib/Algebra/Field/Subfield.lean
theorem eq_of_eqOn_of_field_closure_eq_top {s : Set K} (hs : closure s = ⊤) {f g : K →+* L}
    (h : s.EqOn f g) : f = g
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_lt_sub_right : ∀ {a b c : Nat}, c ≤ a → a < b → a - c < b - c
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp]
theorem fst_prod_snd  : (fst R A B).prod (snd R A B) = ContinuousAlgHom.id R (A × B)
-- Mathlib/Data/Matrix/Basic.lean
lemma zero_le_one_row [Preorder α] [ZeroLEOneClass α] (i : n) :
    0 ≤ (1 : Matrix n n α) i
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem mkEmpty_eq (α n) : @mkEmpty α n = #[]
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- `P` is a sheaf for `R` iff it is separated for `R` and there exists an amalgamation. -/
theorem isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor :
    (IsSeparatedFor P R ∧ ∀ x : FamilyOfElements P R, x.Compatible → ∃ t, x.IsAmalgamation t) ↔
      IsSheafFor P R
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- The one-vertex subgraph. -/
@[simps]
protected def singletonSubgraph (G : SimpleGraph V) (v : V) : G.Subgraph
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem lt_of_gt {x y : Int} (h : x > y) : y < x
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
@[to_additive]
theorem tprod_comm' {f : β → γ → α} (h : Multipliable (Function.uncurry f))
    (h₁ : ∀ b, Multipliable (f b)) (h₂ : ∀ c, Multipliable fun b ↦ f b c) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c
-- Mathlib/CategoryTheory/Limits/IsConnected.lean
/-- The cocone on `constPUnitFunctor` with cone point `PUnit`. -/
@[simps]
def pUnitCocone : Cocone (constPUnitFunctor.{w} C)
-- Mathlib/RingTheory/RingHom/Finite.lean
theorem finite_respectsIso : RespectsIso @Finite
-- Mathlib/LinearAlgebra/Multilinear/TensorProduct.lean
@[simp]
theorem domCoprod'_apply (a : MultilinearMap R (fun _ : ι₁ => N) N₁)
    (b : MultilinearMap R (fun _ : ι₂ => N) N₂) : domCoprod' (a ⊗ₜ[R] b) = domCoprod a b
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem negSucc_mul_negOfNat (m n : Nat) : -[m+1] * negOfNat n = ofNat (succ m * n)
-- Mathlib/Algebra/Group/Units.lean
@[to_additive] lemma div (ha : IsUnit a) (hb : IsUnit b) : IsUnit (a / b)
-- Mathlib/Topology/Order.lean
@[simp] theorem dense_discrete {s : Set α} : Dense s ↔ s = univ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp]
theorem bmod_add_mul_cancel (x : Int) (n : Nat) (k : Int) : Int.bmod (x + n * k) n = Int.bmod x n
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem support_mul_subset_add_support [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
    support (x * y) ⊆ support x + support y
-- Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean
lemma tendsto_integral_of_forall_integral_le_liminf_integral {ι : Type*} {L : Filter ι}
    {μ : Measure X} [IsProbabilityMeasure μ] {μs : ι → Measure X} [∀ i, IsProbabilityMeasure (μs i)]
    (h : ∀ f : X →ᵇ ℝ, 0 ≤ f → ∫ x, f x ∂μ ≤ L.liminf (fun i ↦ ∫ x, f x ∂ (μs i)))
    (f : X →ᵇ ℝ) :
    Tendsto (fun i ↦ ∫ x, f x ∂ (μs i)) L (𝓝 (∫ x, f x ∂μ))
-- Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean
theorem solution_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    solution p a₁ a₂ ≠ 0
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem prodMap_comap_prod {G' : Type*} {N' : Type*} [Group G'] [Group N'] (f : G →* N)
    (g : G' →* N') (S : Subgroup N) (S' : Subgroup N') :
    (S.prod S').comap (prodMap f g) = (S.comap f).prod (S'.comap g)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[norm_cast]
theorem coe_bot : (⊥ : YoungDiagram).cells = (∅ : Set (ℕ × ℕ))
-- Mathlib/Data/Set/Basic.lean
theorem Nonempty.subset_pair_iff_eq (hs : s.Nonempty) :
    s ⊆ {a, b} ↔ s = {a} ∨ s = {b} ∨ s = {a, b}
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem deleteEdges_inter_edgeSet_left_eq :
    G'.deleteEdges (G'.edgeSet ∩ s) = G'.deleteEdges s
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/--
Show that the extension of `f : S.functor ⟶ P` to all of `yoneda.obj X` is in fact an extension, ie
that the triangle below commutes, provided `P` is a sheaf for `S`

      f
   S  →  P
   ↓  ↗
   yX

-/
@[reassoc (attr := simp)]
theorem IsSheafFor.functorInclusion_comp_extend {P : Cᵒᵖ ⥤ Type v₁} (h : IsSheafFor P S)
    (f : S.functor ⟶ P) : S.functorInclusion ≫ h.extend f = f
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_eq_univ : (s : Set α) = univ ↔ s = ⊥
-- Mathlib/Data/Set/Image.lean
theorem range_comp (g : α → β) (f : ι → α) : range (g ∘ f) = g '' range f
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem prod.lift_snd {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y) :
    prod.lift f g ≫ prod.snd = g
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_inj_left {m₁ m₂ n : ℕ} : ack m₁ n = ack m₂ n ↔ m₁ = m₂
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem add_coeff {x y : HahnSeries Γ R} {a : Γ} : (x + y).coeff a = x.coeff a + y.coeff a
-- Mathlib/Data/Finset/Pointwise.lean
theorem singleton_vsub_singleton (a b : β) : ({a} : Finset β) -ᵥ {b} = {a -ᵥ b}
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_prod_eq (a : α × β) : Iic a = Iic a.1 ×ˢ Iic a.2
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem stronglyMeasurable_derivWithin_Ioi :
    StronglyMeasurable (fun x ↦ derivWithin f (Ioi x) x)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem coe_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Subsemiring R}
    (hS : Directed (· ≤ ·) S) : ((⨆ i, S i : Subsemiring R) : Set R) = ⋃ i, S i
-- Mathlib/Data/PNat/Xgcd.lean
theorem isSpecial_iff : u.IsSpecial ↔ u.IsSpecial'
-- Mathlib/Data/Nat/Totient.lean
theorem dvd_two_of_totient_le_one {a : ℕ} (han : 0 < a) (ha : a.totient ≤ 1) : a ∣ 2
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
lemma equicontinuousAt_restrict_iff (F : ι → X → α) {S : Set X} (x₀ : S) :
    EquicontinuousAt (S.restrict ∘ F) x₀ ↔ EquicontinuousWithinAt F S x₀
-- Mathlib/Logic/Equiv/Defs.lean
theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
    (f : α₁ → β₁) (g : β₁ → γ₁) :
    arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f
-- Mathlib/Tactic/LinearCombination.lean
theorem pf_sub_c [Sub α] (p : a = b) (c : α) : a - c = b - c
-- Mathlib/Algebra/CharP/Defs.lean
lemma dvd {x : ℕ} (hx : (x : R) = 0) : ringChar R ∣ x
-- Mathlib/Data/List/Basic.lean
theorem modifyLast_append (f : α → α) (l₁ l₂ : List α) (_ : l₂ ≠ []) :
    modifyLast f (l₁ ++ l₂) = l₁ ++ modifyLast f l₂
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem msb_eq_false_iff_two_mul_lt (x : BitVec w) : x.msb = false ↔ 2 * x.toNat < 2^w
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem comm_sq₂ (hf : ψ.comp f₁ = f₂.comp φ) (hf' : ψ'.comp f₂ = f₃.comp φ') :
    (ψ'.comp ψ).comp f₁ = f₃.comp (φ'.comp φ)
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
@[nontriviality]
theorem of_subsingleton [Subsingleton α] : NullMeasurableSet s μ
-- Mathlib/GroupTheory/OrderOfElement.lean
/-- See also `injective_pow_iff_not_isOfFinOrder`. -/
@[to_additive "See also `injective_nsmul_iff_not_isOfFinAddOrder`."]
theorem not_isOfFinOrder_of_injective_pow {x : G} (h : Injective fun n : ℕ => x ^ n) :
    ¬IsOfFinOrder x
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mul_inter_subset : s * (t₁ ∩ t₂) ⊆ s * t₁ ∩ (s * t₂)
-- Mathlib/Data/Int/ModEq.lean
protected theorem add_left_cancel' (c : ℤ) (h : c + a ≡ c + b [ZMOD n]) : a ≡ b [ZMOD n]
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_add (s t : Multiset α) : toFinset (s + t) = toFinset s ∪ toFinset t
-- .lake/packages/lean4/src/lean/Init/Data/Array/Basic.lean
theorem ext' {as bs : Array α} (h : as.data = bs.data) : as = bs
-- Mathlib/Order/SupClosed.lean
/-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def supClosure : ClosureOperator (Set α)
-- Mathlib/Data/Multiset/Basic.lean
theorem union_le_add (s t : Multiset α) : s ∪ t ≤ s + t
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem IciExtend_coe (f : Ici a → β) (x : Ici a) : IciExtend f x = f x
-- Mathlib/Order/Basic.lean
theorem lt_of_le_of_lt' : b ≤ c → a < b → a < c
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformContinuous_iff {α β} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β} :
    UniformContinuous f ↔ uα ≤ uβ.comap f
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem diam_image (s : Set P) : Metric.diam (e '' s) = Metric.diam s
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem mul_left (a b : N ⋊[φ] G) : (a * b).left = a.left * φ a.right b.left
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem pmap_eq_nil {p : α → Prop} {f : ∀ a, p a → β} {l H} : pmap f l H = [] ↔ l = []
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem mem_sort {s : Finset α} {a : α} : a ∈ sort r s ↔ a ∈ s
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem one_le_blocksFun (i : Fin c.length) : 1 ≤ c.blocksFun i
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem fderivWithin_exp (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
    fderivWithin ℝ (fun x => Real.exp (f x)) s x = Real.exp (f x) • fderivWithin ℝ f s x
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_conjTranspose [InvolutiveStar α] (M : Matrix m n α) : Mᴴᴴ = M
-- Mathlib/Topology/Category/Sequential.lean
/-- The fully faithful embedding of `Sequential` in `TopCat`. -/
@[simps!]
def sequentialToTop : Sequential.{u} ⥤ TopCat.{u}
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
/-- "iff" version of `Multipliable.of_nat_of_neg`. -/
@[to_additive "\"iff\" version of `Summable.of_nat_of_neg`."]
lemma multipliable_int_iff_multipliable_nat_and_neg {f : ℤ → G} :
    Multipliable f ↔ (Multipliable fun n : ℕ ↦ f n) ∧ (Multipliable fun n : ℕ ↦ f (-n))
-- Mathlib/GroupTheory/Index.lean
@[to_additive relindex_mul_relindex]
theorem relindex_mul_relindex (hHK : H ≤ K) (hKL : K ≤ L) :
    H.relindex K * K.relindex L = H.relindex L
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- Functor composition induces a functor on truncated cosimplicial objects. -/
@[simps!]
def whiskering {n} (D : Type*) [Category D] : (C ⥤ D) ⥤ Truncated C n ⥤ Truncated D n
-- Mathlib/Data/Part.lean
theorem mod_mem_mod [Mod α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma % mb ∈ a % b
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem bind_singleton (f : α → List β) (x : α) : [x].bind f = f x
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- Angles in a vector space are invariant to inversion -/
@[simp]
theorem angle_const_sub (v : V) (v₁ v₂ v₃ : V) : ∠ (v - v₁) (v - v₂) (v - v₃) = ∠ v₁ v₂ v₃
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem blsub_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal} (ho : o.card < c.cof)
    (hf : ∀ i hi, f i hi < c) : blsub.{u, u} o f < c
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
@[field_simps] lemma div_eq_div_iff (hb : b ≠ 0) (hd : d ≠ 0) : a / b = c / d ↔ a * d = c * b
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem toMeasure_normalize_eq_of_nonzero (nonzero : μ ≠ 0) :
    (μ.normalize : Measure Ω) = μ.mass⁻¹ • μ
-- Mathlib/Order/WellFoundedSet.lean
protected nonrec theorem IsWF.union (hs : IsWF s) (ht : IsWF t) : IsWF (s ∪ t)
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
/-- The function `(x ^ n) / (b * exp x + c)` tends to `0` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is nonzero. -/
theorem tendsto_div_pow_mul_exp_add_atTop (b c : ℝ) (n : ℕ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma map_polynomialX : (W'.map f).toJacobian.polynomialX = MvPolynomial.map f W'.polynomialX
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem compContinuousLinearMapEquivL_symm (f : ∀ i, E i ≃L[𝕜] E₁ i) :
    (compContinuousLinearMapEquivL G f).symm =
      compContinuousLinearMapEquivL G fun i : ι => (f i).symm
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- When a function has a limit at infinity, and its derivative is nonnegative, then the derivative
is automatically integrable on `(a, +∞)`. Version assuming differentiability
on `[a, +∞)`. -/
theorem integrableOn_Ioi_deriv_of_nonneg' (hderiv : ∀ x ∈ Ici a, HasDerivAt g (g' x) x)
    (g'pos : ∀ x ∈ Ioi a, 0 ≤ g' x) (hg : Tendsto g atTop (𝓝 l)) : IntegrableOn g' (Ioi a)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem op (h : IsPushout f g inl inr) : IsPullback inr.op inl.op g.op f.op
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive tendsto_norm]
theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_left_ne_self : a * b ≠ b ↔ a ≠ 1
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/--
Giving a continuous map out of a disjoint union is the same as giving a continuous map out of
each term. This is a version of `Equiv.piCurry` for continuous maps.
-/
@[simps]
def sigmaEquiv : (∀ i, C(X i, A)) ≃ C((Σ i, X i), A)
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem NNReal.tendsto_const_div_atTop_nhds_zero_nat (C : ℝ≥0) :
    Tendsto (fun n : ℕ ↦ C / n) atTop (𝓝 0)
-- Mathlib/Data/List/AList.lean
theorem insert_entries_of_neg {a} {b : β a} {s : AList β} (h : a ∉ s) :
    (insert a b s).entries = ⟨a, b⟩ :: s.entries
-- Mathlib/Data/List/Intervals.lean
@[simp]
theorem self_empty {n : ℕ} : Ico n n = []
-- Mathlib/SetTheory/Cardinal/Divisibility.lean
theorem is_prime_iff {a : Cardinal} : Prime a ↔ ℵ₀ ≤ a ∨ ∃ p : ℕ, a = p ∧ p.Prime
-- Mathlib/Algebra/Lie/Submodule.lean
theorem lie_mem_left (I : LieIdeal R L) (x y : L) (h : x ∈ I) : ⁅x, y⁆ ∈ I
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
protected theorem coe_coe {F : Type*} [EquivLike F A₁ A₂] [AlgEquivClass F R A₁ A₂] (f : F) :
    ⇑(f : A₁ ≃ₐ[R] A₂) = f
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem cast_one' : (cast (1 : ZMod n) : R) = 1
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem mul_apply (f g : α →*o β) (a : α) : (f * g) a = f a * g a
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
lemma zero_add' (f : L.obj X ⟶ L.obj Y) :
    add' W (L.map 0) f = f
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean
@[reassoc]
theorem map_π_preserves_coequalizer_inv_desc {W : D} (k : G.obj Y ⟶ W)
    (wk : G.map f ≫ k = G.map g ≫ k) : G.map (coequalizer.π f g) ≫
      (PreservesCoequalizer.iso G f g).inv ≫ coequalizer.desc k wk = k
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
protected theorem disjoint_right (C : G.ComponentCompl K) : Disjoint K C
-- Mathlib/RingTheory/DedekindDomain/SInteger.lean
theorem unit_valuation_eq_one (x : S.unit K) {v : HeightOneSpectrum R} (hv : v ∉ S) :
    v.valuation ((x : Kˣ) : K) = 1
-- Mathlib/Topology/Order.lean
theorem isOpen_iff_continuous_mem {s : Set α} : IsOpen s ↔ Continuous (· ∈ s)
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
@[simp] lemma smul_τ₃ (a : R) (φ : S₁ ⟶ S₂) : (a • φ).τ₃ = a • φ.τ₃
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
theorem eq_symm_apply (e : P₁ ≃ᵃL[k] P₂) {x y} : y = e.symm x ↔ e y = x
-- Mathlib/Data/Matrix/Basic.lean
theorem algebraMap_eq_diagonal (r : R) :
    algebraMap R (Matrix n n α) r = diagonal (algebraMap R (n → α) r)
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@[simp]
theorem flip_apply (A : BilinForm R M) (x y : M) : flipHom A x y = A y x
-- Mathlib/Computability/TuringMachine.lean
/-- The `cons` and `head`/`tail` functions are mutually inverse, unlike in the case of `List` where
this only holds for nonempty lists. -/
@[simp]
theorem ListBlank.cons_head_tail {Γ} [Inhabited Γ] : ∀ l : ListBlank Γ, l.tail.cons l.head = l
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
    (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem Subgroup.exponent_toSubmonoid (H : Subgroup G) :
    Monoid.exponent H.toSubmonoid = Monoid.exponent H
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
nonrec theorem Smooth.inv {f : M → G} (hf : Smooth I' I f) : Smooth I' I fun x => (f x)⁻¹
-- Mathlib/Algebra/Category/MonCat/Basic.lean
@[to_additive (attr := simp)]
lemma coe_comp {X Y Z : MonCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f
-- Mathlib/CategoryTheory/Monoidal/Free/Basic.lean
@[simp]
theorem mk_id {X : F C} : ⟦Hom.id X⟧ = 𝟙 X
-- Mathlib/Order/SuccPred/CompleteLinearOrder.lean
lemma exists_eq_iInf_of_not_isPredLimit (hf : ¬ IsPredLimit (⨅ i, f i)) :
    ∃ i, f i = ⨅ i, f i
-- Mathlib/Order/Interval/Set/Infinite.lean
theorem Icc.infinite : Infinite (Icc a b)
-- Mathlib/Order/Heyting/Basic.lean
theorem Disjoint.sup_sdiff_cancel_right (h : Disjoint a b) : (a ⊔ b) \ b = a
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem hundred_div_ε_pow_five_le_m [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) : 100 / ε ^ 5 ≤ m