ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Order.lean
theorem coinduced_le_iff_le_induced {f : α → β} {tα : TopologicalSpace α}
    {tβ : TopologicalSpace β} : tα.coinduced f ≤ tβ ↔ tα ≤ tβ.induced f
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem toFinset_eq_nil {s : Cycle α} : s.toFinset = ∅ ↔ s = Cycle.nil
-- Mathlib/CategoryTheory/Category/TwoP.lean
/-- The functor from `Pointed` to `TwoP` which adds a first point. -/
@[simps]
noncomputable def pointedToTwoPSnd : Pointed.{u} ⥤ TwoP
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem getRight_inr (h : (inr x : α ⊕ β).isRight) : (inr x).getRight h = x
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
/-- `Real.sinh` as an `OrderIso`. -/
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ
-- Mathlib/Topology/ExtendFrom.lean
/-- If a function `f` to a T₃ space `Y` has a limit within a
dense set `A` for any `x`, then `extendFrom A f` is continuous. -/
theorem continuous_extendFrom [RegularSpace Y] {f : X → Y} {A : Set X} (hA : Dense A)
    (hf : ∀ x, ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)) : Continuous (extendFrom A f)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[fun_prop]
theorem DifferentiableOn.continuousOn (h : DifferentiableOn 𝕜 f s) : ContinuousOn f s
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- `HasColimit F` represents the mere existence of a colimit for `F`. -/
class HasColimit (F : J ⥤ C) : Prop where mk' ::
  /-- There exists a colimit for `F` -/
  exists_colimit : Nonempty (ColimitCocone F)
-- Mathlib/Combinatorics/SetFamily/LYM.lean
/-- A bound on any top part of the sum in LYM in terms of the size of `falling k 𝒜`. -/
theorem le_card_falling_div_choose [Fintype α] (hk : k ≤ Fintype.card α)
    (h𝒜 : IsAntichain (· ⊆ ·) (𝒜 : Set (Finset α))) :
    (∑ r ∈ range (k + 1),
        ((𝒜 # (Fintype.card α - r)).card : 𝕜) / (Fintype.card α).choose (Fintype.card α - r)) ≤
      (falling (Fintype.card α - k) 𝒜).card / (Fintype.card α).choose (Fintype.card α - k)
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
@[simp]
theorem AffineEquiv.coe_toHomeomorphOfFiniteDimensional (f : PE ≃ᵃ[𝕜] PF) :
    ⇑f.toHomeomorphOfFiniteDimensional = f
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_comap_eq_self {f : G →* N} {H : Subgroup N} (h : H ≤ f.range) :
    map f (comap f H) = H
-- Mathlib/Data/Nat/PartENat.lean
protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z
-- Mathlib/Data/Real/GoldenRatio.lean
theorem neg_one_lt_goldConj : -1 < ψ
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- A measure on a product space equals the product measure of sigma-finite measures if they are
equal on rectangles. -/
theorem prod_eq {μ : Measure α} [SigmaFinite μ] {ν : Measure β} [SigmaFinite ν]
    {μν : Measure (α × β)}
    (h : ∀ s t, MeasurableSet s → MeasurableSet t → μν (s ×ˢ t) = μ s * ν t) : μ.prod ν = μν
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
/-- If `f` has sum `a`, then `exp ∘ f` has product `exp a`. -/
lemma HasSum.rexp {ι} {f : ι → ℝ} {a : ℝ} (h : HasSum f a) : HasProd (rexp ∘ f) (rexp a)
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
theorem coordinate_eval_7 :
    (coordinate 7).eval
      (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: a7 :: t)) = a7
-- Mathlib/Order/Basic.lean
theorem strongLT_of_le_of_strongLT (hab : a ≤ b) (hbc : b ≺ c) : a ≺ c
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a)
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma subset_compl_singleton : s ⊆ {a}ᶜ ↔ a ∉ s
-- Mathlib/CategoryTheory/Monad/Equalizer.lean
theorem CofreeEqualizer.condition :
    CofreeEqualizer.ι X ≫ CofreeEqualizer.topMap X =
      CofreeEqualizer.ι X ≫ CofreeEqualizer.bottomMap X
-- Mathlib/Order/Filter/SmallSets.lean
theorem HasAntitoneBasis.tendsto_smallSets {ι} [Preorder ι] {s : ι → Set α}
    (hl : l.HasAntitoneBasis s) : Tendsto s atTop l.smallSets
-- Mathlib/RingTheory/Congruence/BigOperators.lean
/-- Congruence relation of a ring preserves finite sum indexed by a list. -/
protected lemma listSum {ι S : Type*} [AddMonoid S] [Mul S]
    (t : RingCon S) (l : List ι) {f g : ι → S} (h : ∀ i ∈ l, t (f i) (g i)) :
    t (l.map f).sum (l.map g).sum
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pullbackConeOfRightIso_x : (pullbackConeOfRightIso f g).pt = X
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
lemma SymmetricCategory.braiding_swap_eq_inv_braiding {C : Type u₁}
    [Category.{v₁} C] [MonoidalCategory C] [SymmetricCategory C] (X Y : C) :
    (β_ Y X).hom = (β_ X Y).inv
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Bounded.trans_right {t₁ t₂ : Ordnode α} {x : α} :
    ∀ {o₁ o₂}, Bounded t₁ o₁ x → Bounded t₂ x o₂ → Bounded t₁ o₁ o₂
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
private theorem norm_nonarchimedean_aux {f g : PadicSeq p} (hfg : ¬f + g ≈ 0) (hf : ¬f ≈ 0)
    (hg : ¬g ≈ 0) : (f + g).norm ≤ max f.norm g.norm
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
/-- Scaling by an element `k` of the scalar ring as a `DilationEquiv` with ratio `‖k‖₊`, mapping
from a normed space to a normed torsor over that space sending `0` to `c`. -/
@[simps]
def DilationEquiv.smulTorsor (c : P) {k : 𝕜} (hk : k ≠ 0) : E ≃ᵈ P
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem Tape.write_nth {Γ} [Inhabited Γ] (b : Γ) :
    ∀ (T : Tape Γ) {i : ℤ}, (T.write b).nth i = if i = 0 then b else T.nth i
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.ideal_fg [EssFiniteType R S] :
    (KaehlerDifferential.ideal R S).FG
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
/-- A more workable definition for `enumOrd`. -/
theorem enumOrd_def (o) : enumOrd S o = sInf (S ∩ { b | ∀ c, c < o → enumOrd S c < b })
-- Mathlib/Order/PFilter.lean
@[simp] theorem mem_principal : x ∈ principal y ↔ y ≤ x
-- Mathlib/Order/Cover.lean
theorem WCovBy.image (f : α ↪o β) (hab : a ⩿ b) (h : (range f).OrdConnected) : f a ⩿ f b
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem isCompactElement_finsetSup {α β : Type*} [CompleteLattice α] {f : β → α} (s : Finset β)
    (h : ∀ x ∈ s, IsCompactElement (f x)) : IsCompactElement (s.sup f)
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
protected theorem differentiableOn : DifferentiableOn 𝕜 f s
-- Mathlib/Topology/Basic.lean
theorem IsOpen.frontier_eq (hs : IsOpen s) : frontier s = closure s \ s
-- Mathlib/Algebra/CharP/Defs.lean
lemma exists' (R : Type*) [NonAssocRing R] [NoZeroDivisors R] [Nontrivial R] :
    CharZero R ∨ ∃ p : ℕ, Fact p.Prime ∧ CharP R p
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
/-- The function `coeff n : R⟦X⟧ → R` is continuous. I.e. `coeff n f` depends only on a sufficiently
long truncation of the power series `f`. -/
theorem coeff_coe_trunc_of_lt {n m} {f : R⟦X⟧} (h : n < m) :
    coeff R n (trunc m f) = coeff R n f
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem u_neg (x : E) : u (-x) = u x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem le_of_mod_lt {a b : Nat} (h : a % b < a) : b ≤ a
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp]
theorem map_zero [∀ i j, Zero (α i j)] {β : m → n → Type w} [∀ i j, Zero (β i j)]
    {f : ∀ ⦃i j⦄, α i j → β i j} (h : ∀ i j, f (0 : α i j) = 0) :
    (0 : DMatrix m n α).map f = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zipWith_foldr_eq_zip_foldr {f : α → β → γ} (i : δ):
    (zipWith f l₁ l₂).foldr g i = (zip l₁ l₂).foldr (fun p r => g (f p.1 p.2) r) i
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
@[continuity]
theorem continuous_tan : Continuous fun x : {x | cos x ≠ 0} => tan x
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is differentiable and `f'` is antitone on `ℝ` then `f` is concave. -/
theorem Antitone.concaveOn_univ_of_deriv {f : ℝ → ℝ} (hf : Differentiable ℝ f)
    (hf'_anti : Antitone (deriv f)) : ConcaveOn ℝ univ f
-- Mathlib/Analysis/NormedSpace/Extend.lean
/-- The norm of the extension is bounded by `‖fr‖`. -/
theorem norm_extendTo𝕜'_bound (fr : F →L[ℝ] ℝ) (x : F) :
    ‖(fr.toLinearMap.extendTo𝕜' x : 𝕜)‖ ≤ ‖fr‖ * ‖x‖
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem NonUnitalSubalgebra.toSubalgebra_toNonUnitalSubalgebra (S : NonUnitalSubalgebra R A)
    (h1 : (1 : A) ∈ S) : (NonUnitalSubalgebra.toSubalgebra S h1).toNonUnitalSubalgebra = S
-- Mathlib/Algebra/Module/Hom.lean
@[simp] theorem coe_smul' [Semiring R] [AddCommMonoid M] [Module R M] :
    ⇑(.smul : R →+ M →+ M) = AddMonoidHom.smulLeft
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
@[simp]
lemma autMulEquivAutGalois_symm_app (x : AutGalois F) (A : C) [IsGalois A] (a : F.obj A) :
    ((autMulEquivAutGalois F).symm ⟨x⟩).hom.app A a =
      F.map (AutGalois.π F ⟨A, a, inferInstance⟩ x).hom a
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[local simp]
theorem splitWrtCompositionAux_cons (l : List α) (n ns) :
    l.splitWrtCompositionAux (n::ns) = take n l::(drop n l).splitWrtCompositionAux ns
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
/-- The measurability of a set `A` is equivalent to the measurability of the indicator function
which takes a constant value `b ≠ 0` on a set `A` and `0` elsewhere. -/
lemma measurable_indicator_const_iff [Zero β] [MeasurableSingletonClass β] (b : β) [NeZero b] :
    Measurable (s.indicator (fun (_ : α) ↦ b)) ↔ MeasurableSet s
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem mulEquivOfMulEquiv_eq_map_apply {k : LocalizationMap T Q} {j : M ≃* P}
    (H : S.map j.toMonoidHom = T) (x) :
    f.mulEquivOfMulEquiv k H x =
      f.map (fun y : S ↦ show j.toMonoidHom y ∈ T from H ▸ Set.mem_image_of_mem j y.2) k x
-- Mathlib/Algebra/QuaternionBasis.lean
@[simp]
theorem i_mul_k : q.i * q.k = c₁ • q.j
-- Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean
theorem eLpNorm_sum_le {ι} {f : ι → α → E} {s : Finset ι}
    (hfs : ∀ i, i ∈ s → AEStronglyMeasurable (f i) μ) (hp1 : 1 ≤ p) :
    eLpNorm (∑ i ∈ s, f i) p μ ≤ ∑ i ∈ s, eLpNorm (f i) p μ
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
/-- The inclusion map (i.e., `coe`) from the sphere in `E` to `E` is smooth.  -/
theorem contMDiff_coe_sphere {n : ℕ} [Fact (finrank ℝ E = n + 1)] :
    ContMDiff (𝓡 n) 𝓘(ℝ, E) ∞ ((↑) : sphere (0 : E) 1 → E)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem isLUB_ciSup_set {f : β → α} {s : Set β} (H : BddAbove (f '' s)) (Hne : s.Nonempty) :
    IsLUB (f '' s) (⨆ i : s, f i)
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem bind_add : (s.bind fun a => f a + g a) = s.bind f + s.bind g
-- Mathlib/NumberTheory/MulChar/Basic.lean
@[simp]
theorem coe_equivToUnitHom (χ : MulChar R R') (a : Rˣ) : ↑(equivToUnitHom χ a) = χ a
-- Mathlib/Logic/Relation.lean
theorem EqvGen.mono {r p : α → α → Prop} (hrp : ∀ a b, r a b → p a b) (h : EqvGen r a b) :
    EqvGen p a b
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
theorem conjugateEquiv_comp (α : L₂ ⟶ L₁) (β : L₃ ⟶ L₂) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₃ β =
      conjugateEquiv adj₁ adj₃ (β ≫ α)
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma map_loopyOn (f : α → β) (hf) : (loopyOn E).map f hf = loopyOn (f '' E)
-- Mathlib/Data/Fintype/Perm.lean
theorem mem_of_mem_permsOfList :
    -- Porting note: was `∀ {x}` but need to capture the `x`
    ∀ {l : List α} {f : Perm α}, f ∈ permsOfList l → (x : α ) → f x ≠ x → x ∈ l
-- Mathlib/RingTheory/Bialgebra/Basic.lean
@[simp] lemma counit_algebraMap (r : R) : counit (R := R) (algebraMap R A r) = r
-- Mathlib/Data/Nat/PartENat.lean
theorem top_add (x : PartENat) : ⊤ + x = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem lt_ediv_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a / b + 1) * b
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_def {_ : MeasurableSpace α} (μ : Measure α) (f : α →ₛ F) :
    f.integral μ = f.setToSimpleFunc (weightedSMul μ)
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem derivBFamily_eq_derivFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) :
    derivBFamily.{u, v} o f = derivFamily.{u, v} (familyOfBFamily o f)
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.union (hs : StarConvex 𝕜 x s) (ht : StarConvex 𝕜 x t) :
    StarConvex 𝕜 x (s ∪ t)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem mul_lt_sin {x : ℝ} (hx : 0 < x) (hx' : x < π / 2) : 2 / π * x < sin x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arctan_eq_arccos {x : ℝ} (h : 0 ≤ x) : arctan x = arccos (√(1 + x ^ 2))⁻¹
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- `lpTrimToLpMeasSubgroup` is a right inverse of `lpMeasSubgroupToLpTrim`. -/
theorem lpMeasSubgroupToLpTrim_right_inv (hm : m ≤ m0) :
    Function.RightInverse (lpTrimToLpMeasSubgroup F p μ hm) (lpMeasSubgroupToLpTrim F p μ hm)
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem coeff_C_mul (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R) :
    coeff R n (C σ R a * φ) = a * coeff R n φ
-- Mathlib/Probability/Kernel/Invariance.lean
theorem Invariant.def (hκ : Invariant κ μ) : μ.bind κ = μ
-- Mathlib/CategoryTheory/Subobject/Basic.lean
theorem map_pullback [HasPullbacks C] {X Y Z W : C} {f : X ⟶ Y} {g : X ⟶ Z} {h : Y ⟶ W} {k : Z ⟶ W}
    [Mono h] [Mono g] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk f g comm))
    (p : Subobject Y) : (map g).obj ((pullback f).obj p) = (pullback k).obj ((map h).obj p)
-- Mathlib/Data/Set/Function.lean
theorem StrictMono.codRestrict [Preorder α] [Preorder β] {f : α → β} (hf : StrictMono f)
    {s : Set β} (hs : ∀ x, f x ∈ s) : StrictMono (Set.codRestrict f s hs)
-- Mathlib/CategoryTheory/Yoneda.lean
theorem reprW_app_hom (X : Cᵒᵖ) (f : unop X ⟶ F.reprX) :
    (F.reprW.app X).hom f = F.map f.op F.reprx
-- Mathlib/Data/Matrix/Block.lean
theorem toSquareBlock_def (M : Matrix m m α) (b : m → β) (k : β) :
    -- Porting note: added missing `of`
    toSquareBlock M b k = of (fun i j : { a // b a = k } => M ↑i ↑j)
-- Mathlib/Topology/Instances/NNReal.lean
@[simp] theorem map_coe_atTop : map toReal atTop = atTop
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diag_sum {ι} [AddCommMonoid α] (s : Finset ι) (f : ι → Matrix n n α) :
    diag (∑ i ∈ s, f i) = ∑ i ∈ s, diag (f i)
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toDFinsupp_neg [AddGroup M] (f : ι →₀ M) : (-f).toDFinsupp = -f.toDFinsupp
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_inv_lt_iff {x y : ℝ≥0} {z : ℝ} (hz : 0 < z) : x ^ z⁻¹ < y ↔ x < y ^ z
-- Mathlib/Algebra/Ring/Fin.lean
/-- The product over `Fin 2` of some rings is just the cartesian product of these rings. -/
@[simps]
def RingEquiv.piFinTwo (R : Fin 2 → Type*) [∀ i, Semiring (R i)] :
    (∀ i : Fin 2, R i) ≃+* R 0 × R 1
-- Mathlib/Logic/Embedding/Basic.lean
/-- Transfer an embedding along a pair of equivalences. -/
@[simps! (config := { fullyApplied := false, simpRhs := true })]
protected def congr {α : Sort u} {β : Sort v} {γ : Sort w} {δ : Sort x} (e₁ : α ≃ β) (e₂ : γ ≃ δ)
    (f : α ↪ γ) : β ↪ δ
-- Mathlib/Topology/Order/ScottTopology.lean
lemma lowerClosure_subset_closure : ↑(lowerClosure s) ⊆ closure s
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : s) : R) = (0 : R)
-- Mathlib/Data/Finset/Sups.lean
lemma diffs_union_right : s \\ (t₁ ∪ t₂) = s \\ t₁ ∪ s \\ t₂
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem Fintype.card_fin (n : ℕ) : Fintype.card (Fin n) = n
-- Mathlib/CategoryTheory/Equivalence.lean
@[simp]
theorem cancel_counitInv_right {X Y : D} (f f' : X ⟶ Y) :
    f ≫ e.counitInv.app Y = f' ≫ e.counitInv.app Y ↔ f = f'
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem Adj.reachable {u v : V} (h : G.Adj u v) : G.Reachable u v
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
lemma functor_additive_iff {E : Type*} [Category E] [Preadditive E] [Preadditive D] [L.Additive]
    (G : D ⥤ E) :
    G.Additive ↔ (L ⋙ G).Additive
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_strict_mono_of_ae_le_of_frequently_ae_lt {f g : α → ℝ≥0∞} (hg : AEMeasurable g μ)
    (hfi : ∫⁻ x, f x ∂μ ≠ ∞) (h_le : f ≤ᵐ[μ] g) (h : ∃ᵐ x ∂μ, f x ≠ g x) :
    ∫⁻ x, f x ∂μ < ∫⁻ x, g x ∂μ
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
@[simp]
lemma Algebra.intNorm_zero : Algebra.intNorm A B 0 = 0
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
theorem set_smul_sphere_zero {s : Set 𝕜} (hs : 0 ∉ s) (r : ℝ) :
    s • sphere (0 : E) r = (‖·‖) ⁻¹' ((‖·‖ * r) '' s)
-- Mathlib/Data/ENNReal/Inv.lean
theorem top_div : ∞ / a = if a = ∞ then 0 else ∞
-- Mathlib/Topology/Separation.lean
theorem Embedding.t5Space [TopologicalSpace Y] [T5Space Y] {e : X → Y} (he : Embedding e) :
    T5Space X
-- Mathlib/Data/Complex/Exponential.lean
theorem cot_conj : cot (conj x) = conj (cot x)
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma LSeriesSummable_congr {f g : ℕ → ℂ} (s : ℂ) (h : ∀ {n}, n ≠ 0 → f n = g n) :
    LSeriesSummable f s ↔ LSeriesSummable g s
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure of `A` in `L` is
Noetherian. -/
theorem integralClosure.isNoetherianRing [IsIntegrallyClosed A] [IsNoetherianRing A] :
    IsNoetherianRing (integralClosure A L)
-- Mathlib/RingTheory/Ideal/Operations.lean
@[simp]
theorem bot_smul : (⊥ : Ideal R) • N = ⊥
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma _root_.IsSl2Triple.h_eq_coroot {α : Weight K H L} (hα : α.IsNonZero)
    {h e f : L} (ht : IsSl2Triple h e f) (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (- α)) :
    h = coroot α
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)] lemma f'_i : h.f' ≫ h.i = S.f
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- The direction of the affine span of a finite set is
finite-dimensional. -/
theorem finiteDimensional_direction_affineSpan_of_finite {s : Set P} (h : Set.Finite s) :
    FiniteDimensional k (affineSpan k s).direction
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ f ▷ Y') = (λ_ _).hom ≫ f
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem coe_ofMapMidpoint (f : E → F) (h0 : f 0 = 0)
    (hm : ∀ x y, f (midpoint R x y) = midpoint R' (f x) (f y)) :
    ⇑(ofMapMidpoint R R' f h0 hm) = f
-- Mathlib/Analysis/RCLike/Basic.lean
/-- The natural `ℝ`-linear isometry equivalence between `𝕜` satisfying `RCLike 𝕜` and `ℝ` when
`RCLike.I = 0`. -/
@[simps]
noncomputable def realLinearIsometryEquiv (h : I = (0 : K)) : K ≃ₗᵢ[ℝ] ℝ
-- Mathlib/Data/Set/Pointwise/Basic.lean
theorem Nonempty.mul_zero (hs : s.Nonempty) : s * 0 = 0
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a * b ∈ s ↔ b * a ∈ s
-- Mathlib/Data/Set/Finite.lean
/-- Constructor for `Set.Finite` using a `Finite` instance. -/
theorem toFinite (s : Set α) [Finite s] : s.Finite
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_pair (h : a ≠ b) : ({a, b} : Finset α).card = 2
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem mem_Lp_iff_memℒp {f : α →ₘ[μ] E} : f ∈ Lp E p μ ↔ Memℒp f p μ
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- Local instance for `OrientedOrd (oα.lex' oβ)`. -/
theorem OrientedOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@OrientedOrd _ ord₁] [@OrientedOrd _ ord₂] :
    @OrientedOrd _ (ord₁.lex' ord₂)
-- Mathlib/Data/Set/Countable.lean
lemma range_enumerateCountable_of_mem {s : Set α} (h : s.Countable) {default : α}
    (h_mem : default ∈ s) :
    range (enumerateCountable h default) = s
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem midpoint_pointReflection_left (x y : P) :
    midpoint R (Equiv.pointReflection x y) y = x
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
@[simp]
theorem colimit_carrier (F : J ⥤ PresheafedSpace.{_, _, v} C) :
    (colimit F).carrier = Limits.colimit (F ⋙ PresheafedSpace.forget C)
-- Mathlib/MeasureTheory/Measure/Tilted.lean
lemma isProbabilityMeasure_tilted [NeZero μ] (hf : Integrable (fun x ↦ exp (f x)) μ) :
    IsProbabilityMeasure (μ.tilted f)
-- Mathlib/RingTheory/Valuation/Integers.lean
/-- Given a valuation v : R → Γ₀ and a ring homomorphism O →+* R, we say that O is the integers of v
if f is injective, and its range is exactly `v.integer`. -/
structure Integers : Prop where
  hom_inj : Function.Injective (algebraMap O R)
  map_le_one : ∀ x, v (algebraMap O R x) ≤ 1
  exists_of_le_one : ∀ ⦃r⦄, v r ≤ 1 → ∃ x, algebraMap O R x = r
-- Mathlib/Topology/Separation.lean
theorem RegularSpace.of_hasBasis {ι : X → Sort*} {p : ∀ a, ι a → Prop} {s : ∀ a, ι a → Set X}
    (h₁ : ∀ a, (𝓝 a).HasBasis (p a) (s a)) (h₂ : ∀ a i, p a i → IsClosed (s a i)) :
    RegularSpace X
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem mul_right_mono (I : FractionalIdeal S P) : Monotone fun J => J * I
-- Mathlib/Data/Matroid/Map.lean
lemma map_image_indep_iff {hf} {I : Set α} (hI : I ⊆ M.E) :
    (M.map f hf).Indep (f '' I) ↔ M.Indep I
-- Mathlib/Computability/Partrec.lean
theorem fix {f : α →. σ ⊕ α} (hf : Partrec f) : Partrec (PFun.fix f)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
/-- The multiplicity of `a` as root of `(X - a) ^ n` is `n`. -/
theorem rootMultiplicity_X_sub_C_pow [Nontrivial R] (a : R) (n : ℕ) :
    rootMultiplicity a ((X - C a) ^ n) = n
-- Mathlib/Analysis/Convolution.lean
@[simp]
theorem convolution_zero : f ⋆[L, μ] 0 = 0
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem cos_sub_cos : cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem cospanExt_hom_app_left :
    (cospanExt iX iY iZ wf wg).hom.app WalkingCospan.left = iX.hom
-- Mathlib/Data/Num/Lemmas.lean
@[simp high, norm_cast]
theorem of_to_int (n : ZNum) : ((n : ℤ) : ZNum) = n
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem comap_symm (e : P₁ ≃ᵃ[k] P₂) (s : AffineSubspace k P₁) :
    s.comap (e.symm : P₂ →ᵃ[k] P₁) = s.map e
-- Mathlib/NumberTheory/VonMangoldt.lean
theorem sum_moebius_mul_log_eq {n : ℕ} : (∑ d ∈ n.divisors, (μ d : ℝ) * log d) = -Λ n
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_eq_prod' {s : Finset β} (hf : mulSupport f ⊆ s) :
    ∏' b, f b = ∏ b ∈ s, f b
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem nontrivial_iff_exists_ne_one (S : Submonoid M) : Nontrivial S ↔ ∃ x ∈ S, x ≠ (1 : M)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem ExprCnstr.denote_toPoly (ctx : Context) (c : ExprCnstr) : c.toPoly.denote ctx = c.denote ctx
-- Mathlib/Topology/Instances/EReal.lean
private lemma continuousAt_mul_swap {a b : EReal}
    (h : ContinuousAt (fun p : EReal × EReal ↦ p.1 * p.2) (a, b)) :
    ContinuousAt (fun p : EReal × EReal ↦ p.1 * p.2) (b, a)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem hasLimitsOfShape_of_hasColimitsOfShape_op [HasColimitsOfShape Jᵒᵖ Cᵒᵖ] :
    HasLimitsOfShape J C
-- Mathlib/MeasureTheory/Integral/Periodic.lean
/-- If `g : ℝ → ℝ` is periodic with period `T > 0` and `∀ x, 0 < g x`, then `t ↦ ∫ x in 0..t, g x`
tends to `-∞` as `t` tends to `-∞`. -/
theorem tendsto_atBot_intervalIntegral_of_pos' (h₀ : ∀ x, 0 < g x) (hT : 0 < T) :
    Tendsto (fun t => ∫ x in (0)..t, g x) atBot atBot
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem snd_himp [HImp α] [HImp β] (a b : α × β) : (a ⇨ b).2 = a.2 ⇨ b.2
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem iInf_lcs_le_of_isNilpotent_quot (h : IsNilpotent R L (M ⧸ N)) :
    ⨅ k, lowerCentralSeries R L M k ≤ N
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem sub_ediv_of_dvd (a : Int) {b c : Int}
    (hcb : c ∣ b) : (a - b) / c = a / c - b / c
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem eq_bot_iff (I : HomogeneousIdeal 𝒜) : I = ⊥ ↔ I.toIdeal = ⊥
-- Mathlib/RingTheory/Flat/Algebra.lean
/-- If `T` is a flat `S`-algebra and `S` is a flat `R`-algebra,
then `T` is a flat `R`-algebra. -/
theorem comp (T : Type w) [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T]
    [IsScalarTower R S T] [Algebra.Flat R S] [Algebra.Flat S T] : Algebra.Flat R T