ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
@[simp]
theorem image_const_add_Ioi : (fun x => a + x) '' Ioi b = Ioi (a + b)
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem tendsto_logGammaSeq_of_le_one (hf_conv : ConvexOn ℝ (Ioi 0) f)
    (hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y) (hx : 0 < x) (hx' : x ≤ 1) :
    Tendsto (logGammaSeq x) atTop (𝓝 <| f x - f 1)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem _root_.IsFractional.mul {I J : Submodule R P} :
    IsFractional S I → IsFractional S J → IsFractional S (I * J : Submodule R P)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
/-- For 0 < x, we have sin x < x. -/
theorem sin_lt (h : 0 < x) : sin x < x
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
/-- The counit isomorphism of the equivalence `(C ⥤ Karoubi D) ≌ (Karoubi C ⥤ Karoubi D)`. -/
@[simps!]
def KaroubiUniversal₁.counitIso :
    (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C) ⋙ functorExtension₁ C D ≅ 𝟭 _
-- Mathlib/FieldTheory/RatFunc/Defs.lean
theorem liftOn_ofFractionRing_mk {P : Sort v} (n : K[X]) (d : K[X]⁰) (f : K[X] → K[X] → P)
    (H : ∀ {p q p' q'} (_hq : q ∈ K[X]⁰) (_hq' : q' ∈ K[X]⁰), q' * p = q * p' → f p q = f p' q') :
    RatFunc.liftOn (ofFractionRing (Localization.mk n d)) f @H = f n d
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem degree_gcd_le_left {p : R[X]} (hp : p ≠ 0) (q) : (gcd p q).degree ≤ p.degree
-- Mathlib/FieldTheory/Minpoly/Basic.lean
/-- A minimal polynomial is irreducible. -/
theorem irreducible (hx : IsIntegral A x) : Irreducible (minpoly A x)
-- Mathlib/Data/List/Forall2.lean
theorem forall₂_refl [IsRefl α Rₐ] (l : List α) : Forall₂ Rₐ l l
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.toMatrix₂_compl₂ (B : M₁ →ₗ[R] M₂ →ₗ[R] R) (f : M₂' →ₗ[R] M₂) :
    LinearMap.toMatrix₂ b₁ b₂' (B.compl₂ f) =
      LinearMap.toMatrix₂ b₁ b₂ B * toMatrix b₂' b₂ f
-- Mathlib/CategoryTheory/Comma/Arrow.lean
theorem mk_injective (A B : T) :
    Function.Injective (Arrow.mk : (A ⟶ B) → Arrow T)
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_sub_self_right {m n : ℕ} (h : m ≤ n) : gcd m (n - m) = gcd m n
-- Mathlib/Logic/Basic.lean
theorem BAll.imp_left (H : ∀ x, p x → q x) (h₁ : ∀ x, q x → r x) (x) (h : p x) : r x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_le_pow_iff_right {a n m : Nat} (h : 1 < a) :
    a ^ n ≤ a ^ m ↔ n ≤ m
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem sup_factors_of_factors_right {A B : C} {X Y : Subobject B} {f : A ⟶ B} (P : Y.Factors f) :
    (X ⊔ Y).Factors f
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_copy (S : Subfield K) (s : Set K) (hs : s = ↑S) : (S.copy s hs : Set K) = s
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem union_def (l₁ l₂ : List α)  : l₁ ∪ l₂ = foldr .insert l₂ l₁
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem add_omega_opow {a b : Ordinal} (h : a < (omega^b)) : a + (omega^b) = (omega^b)
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem support_uniformOfFintype (α : Type*) [Fintype α] [Nonempty α] :
    (uniformOfFintype α).support = ⊤
-- Mathlib/Data/Seq/WSeq.lean
theorem dropn_add (s : WSeq α) (m) : ∀ n, drop s (m + n) = drop (drop s m) n
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast] lemma coe_inj : (p : ℝ≥0∞) = q ↔ p = q
-- Mathlib/Order/Filter/Ker.lean
@[simp] lemma ker_iInf (f : ι → Filter α) : ker (⨅ i, f i) = ⨅ i, ker (f i)
-- Mathlib/Order/MinMax.lean
theorem min_right_comm (a b c : α) : min (min a b) c = min (min a c) b
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.Finset.aestronglyMeasurable_prod {ι : Type*} {f : ι → α → M} (s : Finset ι)
    (hf : ∀ i ∈ s, AEStronglyMeasurable (f i) μ) :
    AEStronglyMeasurable (fun a => ∏ i ∈ s, f i a) μ
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp]
theorem one_rpow (x : ℝ) : (1 : ℝ≥0∞) ^ x = 1
-- Mathlib/Data/Rat/Lemmas.lean
theorem den_mk (n d : ℤ) : (n /. d).den = if d = 0 then 1 else d.natAbs / n.gcd d
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem Continuous.Prod.mk_left (y : Y) : Continuous fun x : X => (x, y)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem map_add [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x + y)) = f (update m i x) + f (update m i y)
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive] lemma AntivaryOn.div_right (h₁ : AntivaryOn f g₁ s) (h₂ : MonovaryOn f g₂ s) :
    AntivaryOn f (g₁ / g₂) s
-- Mathlib/Data/Set/Function.lean
theorem injOn_subtype_val {s : Set { x // p x }} : Set.InjOn Subtype.val s
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
/-- The change of variables mapped over a ring homomorphism `φ : R →+* A`. -/
@[simps]
def map : VariableChange A
-- Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean
@[simp]
theorem withDensityᵥ_smul {𝕜 : Type*} [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E]
    [SMulCommClass ℝ 𝕜 E] (f : α → E) (r : 𝕜) : μ.withDensityᵥ (r • f) = r • μ.withDensityᵥ f
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
theorem IsSRGWith.card_neighborFinset_union_of_adj {v w : V} (h : G.IsSRGWith n k ℓ μ)
    (ha : G.Adj v w) : (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - ℓ
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem prodMap_zero : (0 : M →ₗ[R] M₂).prodMap (0 : M₃ →ₗ[R] M₄) = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem neg_eq_self_iff {θ : Angle} : -θ = θ ↔ θ = 0 ∨ θ = π
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem Summable.tsum_mul_left (a) (hf : Summable f) : ∑' i, a * f i = a * ∑' i, f i
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_mul (z w : K) : normSq (z * w) = normSq z * normSq w
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
protected theorem hasCompactSupport [FiniteDimensional ℝ E] : HasCompactSupport f
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
theorem subsingleton_of_no_eigenvalue_finiteDimensional (hT : T.IsSymmetric)
    (hT' : ∀ μ : 𝕜, Module.End.eigenspace (T : E →ₗ[𝕜] E) μ = ⊥) : Subsingleton E
-- Mathlib/GroupTheory/GroupAction/BigOperators.lean
theorem Multiset.smul_sum {r : α} {s : Multiset β} : r • s.sum = (s.map (r • ·)).sum
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem comap_injective {f : G →* N} (h : Function.Surjective f) : Function.Injective (comap f)
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
theorem smul_inv (r : k) (φ : MvPowerSeries σ k) : (r • φ)⁻¹ = r⁻¹ • φ⁻¹
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simp]
lemma id_hom₁ (A : Triangle C) : TriangleMorphism.hom₁ (𝟙 A) = 𝟙 _
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_add_nonneg_left' (hf : ∀ᶠ x in l, 0 ≤ f x) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop
-- Mathlib/Order/RelClasses.lean
theorem IsIrrefl.swap (r) [IsIrrefl α r] : IsIrrefl α (swap r)
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y }
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_le_sub_left {a b : Int} (h : a ≤ b) (c : Int) : c - b ≤ c - a
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem toPlus_eq_mk {X : C} {P : Cᵒᵖ ⥤ D} (x : P.obj (op X)) :
    (J.toPlus P).app _ x = mk (Meq.mk ⊤ x)
-- Mathlib/Algebra/Group/Equiv/Basic.lean
/-- A family of multiplicative equivalences `Π j, (Ms j ≃* Ns j)` generates a
multiplicative equivalence between `Π j, Ms j` and `Π j, Ns j`.

This is the `MulEquiv` version of `Equiv.piCongrRight`, and the dependent version of
`MulEquiv.arrowCongr`.
-/
@[to_additive (attr := simps apply)
  "A family of additive equivalences `Π j, (Ms j ≃+ Ns j)`
  generates an additive equivalence between `Π j, Ms j` and `Π j, Ns j`.

  This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
  `AddEquiv.arrowCongr`."]
def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
    (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConcaveOn.mul' (hf : ConcaveOn 𝕜 s f) (hg : ConcaveOn 𝕜 s g) (hf₀ : ∀ ⦃x⦄, x ∈ s → f x ≤ 0)
    (hg₀ : ∀ ⦃x⦄, x ∈ s → g x ≤ 0) (hfg : MonovaryOn f g s) :
    ConvexOn 𝕜 s (f * g)
-- Mathlib/Algebra/MvPolynomial/PDeriv.lean
theorem pderiv_map {S} [CommSemiring S] {φ : R →+* S} {f : MvPolynomial σ R} {i : σ} :
    pderiv i (map φ f) = map φ (pderiv i f)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_val {a : α} {s : Finset α} : a ∈ s.1 ↔ a ∈ s
-- Mathlib/Data/Real/Basic.lean
theorem add_lt_add_iff_left {a b : ℝ} (c : ℝ) : c + a < c + b ↔ a < b
-- Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean
/-- **Ruzsa's triangle inequality**. Div-mul-mul version. -/
@[to_additive "**Ruzsa's triangle inequality**. Sub-add-add version."]
theorem ruzsa_triangle_inequality_div_mul_mul (A B C : Finset α) :
    (A / C).card * B.card ≤ (A * B).card * (B * C).card
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem tanh_eq_sinh_div_cosh : tanh x = sinh x / cosh x
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_zero_eval_zero : (ascPochhammer S 0).eval 0 = 1
-- Mathlib/Algebra/Order/Floor.lean
theorem fract_lt_one (a : α) : fract a < 1
-- Mathlib/Order/Filter/CardinalInter.lean
theorem EventuallyEq.cardinal_bInter {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
    ⋂ i ∈ S, s i ‹_› =ᶠ[l] ⋂ i ∈ S, t i ‹_›
-- Mathlib/Topology/Compactness/Compact.lean
theorem noncompactSpace_of_neBot (_ : NeBot (Filter.cocompact X)) : NoncompactSpace X
-- Mathlib/SetTheory/Game/PGame.lean
theorem Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x
-- Mathlib/Analysis/LocallyConvex/Basic.lean
lemma absorbs_iff_norm : Absorbs 𝕜 A B ↔ ∃ r, ∀ c : 𝕜, r ≤ ‖c‖ → B ⊆ c • A
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z
-- Mathlib/Order/GaloisConnection.lean
theorem l_u_eq [Preorder α] [PartialOrder β] (gi : GaloisInsertion l u) (b : β) : l (u b) = b
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tendsto_toNNReal {a : ℝ≥0∞} (ha : a ≠ ∞) :
    Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal)
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_compl [Fintype α] [Fintype (sᶜ : Set _)] : sᶜ.toFinset = s.toFinsetᶜ
-- Mathlib/MeasureTheory/Group/MeasurableEquiv.lean
@[to_additive (attr := simp)]
theorem symm_mulLeft (g : G) : (mulLeft g).symm = mulLeft g⁻¹
-- Mathlib/Data/Set/Opposite.lean
/-- The members of the opposite of a set are in bijection with the members of the set itself. -/
@[simps]
def opEquiv_self (s : Set α) : s.op ≃ s
-- Mathlib/Data/Set/Finite.lean
theorem infinite_range_of_injective [Infinite α] {f : α → β} (hi : Injective f) :
    (range f).Infinite
-- Mathlib/GroupTheory/Finiteness.lean
/-- An equivalent expression of `Monoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive
      "An equivalent expression of `AddMonoid.FG` in terms of `Set.Finite` instead of `Finset`."]
theorem Monoid.fg_iff :
    Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set M) = ⊤
-- Mathlib/Data/Part.lean
@[simp]
theorem some_ne_none (x : α) : some x ≠ none
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem map_sup (s t : NonUnitalSubring R) (f : F) : (s ⊔ t).map f = s.map f ⊔ t.map f
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_diagonal [SemilatticeInf α] : Tendsto (fun a : α => (a, a)) atBot atBot
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma baseChange_equation (hf : Function.Injective f) (x y : A) :
    (W.baseChange B).toAffine.Equation (f x) (f y) ↔ (W.baseChange A).toAffine.Equation x y
-- Mathlib/Data/Fintype/Card.lean
/-- See `Infinite.exists_superset_card_eq` for a version that, for an `s : Finset α`,
provides a superset `t : Finset α`, `s ⊆ t` such that `t.card` is fixed. -/
theorem exists_subset_card_eq (α : Type*) [Infinite α] (n : ℕ) : ∃ s : Finset α, s.card = n
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem union_ae_eq_left_of_ae_eq_empty (h : t =ᵐ[μ] (∅ : Set α)) : (s ∪ t : Set α) =ᵐ[μ] s
-- Mathlib/Data/Countable/Defs.lean
theorem Equiv.countable_iff (e : α ≃ β) : Countable α ↔ Countable β
-- Mathlib/CategoryTheory/HomCongr.lean
/-- If `X` is isomorphic to `X₁` and `Y` is isomorphic to `Y₁`, then
there is a bijection between `X ≅ Y` and `X₁ ≅ Y₁`. -/
@[simps]
def isoCongr {X₁ Y₁ X₂ Y₂ : C} (f : X₁ ≅ X₂) (g : Y₁ ≅ Y₂) : (X₁ ≅ Y₁) ≃ (X₂ ≅ Y₂)
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem HasDerivAt.arsinh (hf : HasDerivAt f f' a) :
    HasDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- Mathlib/Data/Int/GCD.lean
@[simp]
theorem xgcd_zero_left {s t r' s' t'} : xgcdAux 0 s t r' s' t' = (r', s', t')
-- Mathlib/Data/List/Chain.lean
theorem Chain'.left_of_append (h : Chain' R (l₁ ++ l₂)) : Chain' R l₁
-- Mathlib/Data/ENNReal/Operations.lean
theorem smul_top {R} [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [NoZeroSMulDivisors R ℝ≥0∞] [DecidableEq R] (c : R) :
    c • ∞ = if c = 0 then 0 else ∞
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
lemma IsComplement.mul_eq (h : IsComplement S T) : S * T = univ
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- The `p`-adic value of an integer `z ≠ 0` is the multiplicity of `p` in `z`. -/
theorem of_int_multiplicity {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0) :
    padicValRat p (z : ℚ) = (multiplicity (p : ℤ) z).get (finite_int_iff.2 ⟨hp, hz⟩)
-- Mathlib/Data/List/Sublists.lean
theorem sublists_eq_sublists' (l : List α) : sublists l = map reverse (sublists' (reverse l))
-- Mathlib/Data/Ordmap/Ordset.lean
theorem emem_iff_all {x : α} {t} : Emem x t ↔ ∀ P, All P t → P x
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem gluedLift_p2 : gluedLift 𝒰 f g s ≫ p2 𝒰 f g = s.snd
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem projIic_of_mem (hx : x ∈ Iic b) : projIic b x = ⟨x, hx⟩
-- Mathlib/Data/Real/EReal.lean
theorem range_coe : range Real.toEReal = {⊥, ⊤}ᶜ
-- Mathlib/Topology/UrysohnsLemma.lean
theorem lim_le_one (c : CU P) (x : X) : c.lim x ≤ 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive zsmul_nonneg]
theorem one_le_zpow {x : G} (H : 1 ≤ x) {n : ℤ} (hn : 0 ≤ n) : 1 ≤ x ^ n
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_C_mul : (C a * p).eval x = a * p.eval x
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
    ∀ {n : ℤ}, (f ^ n) a = a ↔ (s.card : ℤ) ∣ n
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
theorem mul_right_cancel_iff : b * a = c * a ↔ b = c
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[arith_mult]
theorem isMultiplicative_pow {k : ℕ} : IsMultiplicative (pow k)
-- Mathlib/Order/Disjoint.lean
theorem sup_eq_top (h : IsCompl x y) : x ⊔ y = ⊤
-- Mathlib/Topology/Instances/EReal.lean
nonrec theorem nhds_top_basis : (𝓝 (⊤ : EReal)).HasBasis (fun _ : ℝ ↦ True) (Ioi ·)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma zero_def : (zero : W.Point) = 0
-- Mathlib/Data/Finset/Pointwise.lean
/-- If a finset `u` is contained in the product of two sets `s * t`, we can find two finsets `s'`,
`t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' * t'`. -/
@[to_additive
      "If a finset `u` is contained in the sum of two sets `s + t`, we can find two finsets
      `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' + t'`."]
theorem subset_mul {s t : Set α} :
    ↑u ⊆ s * t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' * t'
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp)]
theorem powersEquivPowers_apply (h : orderOf x = orderOf y) (n : ℕ) :
    powersEquivPowers h ⟨x ^ n, n, rfl⟩ = ⟨y ^ n, n, rfl⟩
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive]
theorem haarMeasure_self {K₀ : PositiveCompacts G} : haarMeasure K₀ K₀ = 1
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp]
theorem lift_smul (k : 𝕜) : (k • X).1 = k • X.1
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive (attr := simp)] lemma oneLePart_one : (1 : α)⁺ᵐ = 1
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem inv_left_mul_aux (hA : A ∈ symplecticGroup l R) : -(J l R * Aᵀ * J l R * A) = 1
-- Mathlib/Algebra/Order/Field/Basic.lean
/-- `Equiv.mulRight₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulRight₀ (a : α) (ha : 0 < a) : α ≃o α
-- Mathlib/Order/Grade.lean
protected theorem CovBy.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
lemma next_add (p q : I) (hp : c.Rel p (c.next p)) :
    c.next (p + q) = c.next p + q
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Set.finite_iff_bddAbove [SemilatticeSup α] [LocallyFiniteOrder α] [OrderBot α] :
    s.Finite ↔ BddAbove s
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem reindexRange_repr (x : M) (i : ι) (h := Set.mem_range_self i) :
    b.reindexRange.repr x ⟨b i, h⟩ = b.repr x i
-- Mathlib/CategoryTheory/Monoidal/Center.lean
/-- Auxiliary definition for the `BraidedCategory` instance on `Center C`. -/
@[simps!]
def braiding (X Y : Center C) : X ⊗ Y ≅ Y ⊗ X
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem FiniteDimensional.finrank_eq_zero_of_rank_eq_zero (h : Module.rank R M = 0) :
    finrank R M = 0
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_smul (A : Matrix n n R) (c : R) : det (c • A) = c ^ Fintype.card n * det A
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem ofBoolRing_add (a b : AsBoolRing α) : ofBoolRing (a + b) = ofBoolRing a ∆ ofBoolRing b
-- Mathlib/Deprecated/Group.lean
/-- The composite of two monoid homomorphisms is a monoid homomorphism. -/
@[to_additive
      "The composite of two additive monoid homomorphisms is an additive monoid
      homomorphism."]
theorem comp (hf : IsMonoidHom f) {γ} [MulOneClass γ] {g : β → γ} (hg : IsMonoidHom g) :
    IsMonoidHom (g ∘ f)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem normSq_natCast (n : ℕ) : normSq n = n * n
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sigmaUncurry_add [∀ i j, AddZeroClass (δ i j)] [DecidableEq ι]
    (f g : Π₀ (i) (j), δ i j) :
    sigmaUncurry (f + g) = sigmaUncurry f + sigmaUncurry g
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem UniqueDiffWithinAt.inter' (hs : UniqueDiffWithinAt 𝕜 s x) (ht : t ∈ 𝓝[s] x) :
    UniqueDiffWithinAt 𝕜 (s ∩ t) x
-- Mathlib/GroupTheory/Abelianization.lean
theorem rank_commutator_le_card [Finite (commutatorSet G)] :
    Group.rank (commutator G) ≤ Nat.card (commutatorSet G)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem append_ne_nil_of_ne_nil_right (s t : List α) : t ≠ [] → s ++ t ≠ []
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean
theorem hasPullback_assoc [HasPullback (g₂ ≫ f₃) f₄] : HasPullback f₁ (g₃ ≫ f₂)
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_le_iSup {f : Filter β} {u : β → α} : limsup u f ≤ ⨆ n, u n
-- Mathlib/Order/BooleanAlgebra.lean
theorem compl_le_of_compl_le (h : yᶜ ≤ x) : xᶜ ≤ y
-- .lake/packages/lean4/src/lean/Init/GetElem.lean
theorem getElem!_pos [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    [Inhabited elem] (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)] :
    c[i]! = c[i]'h
-- Mathlib/Logic/Relator.lean
lemma rel_not : (Iff ⇒ Iff) Not Not
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem coe_copy (Q : QuadraticMap R M N) (Q' : M → N) (h : Q' = ⇑Q) : ⇑(Q.copy Q' h) = Q'
-- Mathlib/Algebra/Group/Action/Opposite.lean
@[to_additive]
lemma op_smul_eq_op_smul_op [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (r : M) (a : α) :
    op (r • a) = op r • op a
-- Mathlib/Order/Filter/AtTopBot.lean
theorem atTop_basis [Nonempty α] [SemilatticeSup α] : (@atTop α _).HasBasis (fun _ => True) Ici
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_tProd_elim [DecidableEq δ] :
    ∀ {l : List δ} {i : δ} (hi : i ∈ l), Measurable fun v : TProd π l => v.elim hi
-- Mathlib/MeasureTheory/Function/LpSpace/ContinuousCompMeasurePreserving.lean
theorem ContinuousOn.compMeasurePreservingLp (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) (hgm : ∀ z, MeasurePreserving (g z) μ ν) (hp : p ≠ ∞) :
    ContinuousOn (fun z ↦ Lp.compMeasurePreserving (g z) (hgm z) (f z)) s
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem IsOpen.closure_mul (ht : IsOpen t) (s : Set G) : closure s * t = s * t
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem symm_mk (f : M ≃ N) (h) :
    (MulEquiv.mk f h).symm = ⟨f.symm, (MulEquiv.mk f h).symm_map_mul⟩
-- Mathlib/Order/Irreducible.lean
theorem SupPrime.ne_bot (ha : SupPrime a) : a ≠ ⊥
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
    MeasurableSet[iInf m] s ↔ ∀ i, MeasurableSet[m i] s
-- Mathlib/Algebra/GCDMonoid/Basic.lean
/-- Normalized GCD monoid: a `CancelCommMonoidWithZero` with normalization and `gcd`
(greatest common divisor) and `lcm` (least common multiple) operations. In this setting `gcd` and
`lcm` form a bounded lattice on the associated elements where `gcd` is the infimum, `lcm` is the
supremum, `1` is bottom, and `0` is top. The type class focuses on `gcd` and we derive the
corresponding `lcm` facts from `gcd`.
-/
class NormalizedGCDMonoid (α : Type*) [CancelCommMonoidWithZero α] extends NormalizationMonoid α,
  GCDMonoid α where
  /-- The GCD is normalized to itself. -/
  normalize_gcd : ∀ a b, normalize (gcd a b) = gcd a b
  /-- The LCM is normalized to itself. -/
  normalize_lcm : ∀ a b, normalize (lcm a b) = lcm a b
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem toEquiv_injective : Injective (toEquiv : α ≃ᵐ β → α ≃ β)
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem mem_toCone' : x ∈ hs.toCone s ↔ ∃ c : 𝕜, 0 < c ∧ c • x ∈ s
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem antitone_lowerCentralSeries : Antitone <| lowerCentralSeries R L M
-- Mathlib/Data/Complex/Module.lean
@[simp]
theorem coe_basisOneI_repr (z : ℂ) : ⇑(basisOneI.repr z) = ![z.re, z.im]
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem set_next_add (s : String) (i : Pos) (c : Char) (b₁ b₂)
    (h : (s.next i).1 + b₁ = s.endPos.1 + b₂) :
    ((s.set i c).next i).1 + b₁ = (s.set i c).endPos.1 + b₂
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Congruence relations equal the smallest congruence relation in which they are contained. -/
@[to_additive (attr := simp) addConGen_of_addCon "Additive congruence relations equal the smallest
additive congruence relation in which they are contained."]
theorem conGen_of_con (c : Con M) : conGen c = c
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem not_one_mem_div_iff : (1 : α) ∉ s / t ↔ Disjoint s t
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csSup_Ioo [DenselyOrdered α] (h : a < b) : sSup (Ioo a b) = b
-- Mathlib/Data/Int/Defs.lean
lemma natCast_ne_zero_iff_pos {n : ℕ} : (n : ℤ) ≠ 0 ↔ 0 < n
-- Mathlib/Analysis/NormedSpace/MStructure.lean
@[simp]
theorem coe_inf [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    ↑(P ⊓ Q) = (↑P : M) * ↑Q
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem bound' : Tendsto (fun n : ℕ => ‖F.derivative.eval a‖ * T ^ 2 ^ n) atTop (𝓝 0)
-- Mathlib/Analysis/VonNeumannAlgebra/Basic.lean
@[ext]
theorem ext {S T : VonNeumannAlgebra H} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Topology/Compactness/Compact.lean
lemma Set.Infinite.exists_accPt_of_subset_isCompact {K : Set X} (hs : s.Infinite)
    (hK : IsCompact K) (hsub : s ⊆ K) : ∃ x ∈ K, AccPt x (𝓟 s)
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y) (wf : P.Factors f)
    (wg : P.Factors g) : P.Factors (f + g)
-- Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean
@[simp]
theorem inl_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
    coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl _ _