ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem tan_add_mul_I {x y : ℂ}
    (h :
      ((∀ k : ℤ, x ≠ (2 * k + 1) * π / 2) ∧ ∀ l : ℤ, y * I ≠ (2 * l + 1) * π / 2) ∨
        (∃ k : ℤ, x = (2 * k + 1) * π / 2) ∧ ∃ l : ℤ, y * I = (2 * l + 1) * π / 2) :
    tan (x + y * I) = (tan x + tanh y * I) / (1 - tan x * tanh y * I)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma evalEval_polynomialY (x y : R) :
    W.polynomialY.evalEval x y = 2 * y + W.a₁ * x + W.a₃
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma grade_eq (m : Multiset α) : grade ℕ m = card m
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem transpose_eq_intCast [DecidableEq n] [AddGroupWithOne α]
    {M : Matrix n n α} {d : ℤ} :
    Mᵀ = d ↔ M = d
-- Mathlib/GroupTheory/FixedPointFree.lean
theorem coe_eq_inv_of_sq_eq_one (hφ : FixedPointFree φ) (h2 : φ^[2] = _root_.id) : ⇑φ = (·⁻¹)
-- Mathlib/Order/CompleteLattice.lean
theorem le_sSup_iff : a ≤ sSup s ↔ ∀ b ∈ upperBounds s, a ≤ b
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- Multiplying by all the matrices in `listTransvecRow M` does not change the last column. -/
theorem mul_listTransvecRow_last_col (i : Fin r ⊕ Unit) :
    (M * (listTransvecRow M).prod) i (inr unit) = M i (inr unit)
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
/-- Auxiliary theorem used to prove `toBaseChange_reverse` without needing induction. -/
theorem toBaseChange_comp_reverseOp (Q : QuadraticForm R V) :
    (toBaseChange A Q).op.comp reverseOp =
      ((Algebra.TensorProduct.opAlgEquiv R A A (CliffordAlgebra Q)).toAlgHom.comp <|
        (Algebra.TensorProduct.map
          (AlgEquiv.toOpposite A A).toAlgHom (reverseOp (Q := Q))).comp
        (toBaseChange A Q))
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
theorem reverse_comp_involute :
    reverse.comp involute.toLinearMap =
      (involute.toLinearMap.comp reverse : _ →ₗ[R] CliffordAlgebra Q)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem aeval_unique (φ : MvPolynomial σ R →ₐ[R] S₁) : φ = aeval (φ ∘ X)
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α)
-- Mathlib/Algebra/Order/Monoid/Defs.lean
@[to_additive (attr := simp)]
theorem one_lt_mul_self_iff : 1 < a * a ↔ 1 < a
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_mulIndicator_eq_prod_filter (s : Finset ι) (f : ι → κ → β) (t : ι → Set κ) (g : ι → κ)
    [DecidablePred fun i ↦ g i ∈ t i] :
    ∏ i ∈ s, mulIndicator (t i) (f i) (g i) = ∏ i ∈ s.filter fun i ↦ g i ∈ t i, f i (g i)
-- Mathlib/CategoryTheory/Enriched/Basic.lean
/-- The identity in the "underlying" category of an enriched category. -/
@[simp]
theorem forgetEnrichment_id (X : ForgetEnrichment W C) :
    ForgetEnrichment.homTo W (𝟙 X) = eId W (ForgetEnrichment.to W X : C)
-- Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean
theorem aux_calc (n : ℕ) {m : ℝ} (hm : 2 ≤ m) :
    (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!) ≤ 1 / (m ^ n !) ^ n
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iInter_coe_set {α β : Type*} (s : Set α) (f : s → Set β) :
    ⋂ i, f i = ⋂ i ∈ s, f ⟨i, ‹i ∈ s›⟩
-- Mathlib/Order/GaloisConnection.lean
theorem l_comm_of_u_comm {X : Type*} [Preorder X] {Y : Type*} [Preorder Y] {Z : Type*}
    [Preorder Z] {W : Type*} [PartialOrder W] {lYX : X → Y} {uXY : Y → X}
    (hXY : GaloisConnection lYX uXY) {lWZ : Z → W} {uZW : W → Z} (hZW : GaloisConnection lWZ uZW)
    {lWY : Y → W} {uYW : W → Y} (hWY : GaloisConnection lWY uYW) {lZX : X → Z} {uXZ : Z → X}
    (hXZ : GaloisConnection lZX uXZ) (h : ∀ w, uXZ (uZW w) = uXY (uYW w)) {x : X} :
    lWZ (lZX x) = lWY (lYX x)
-- Mathlib/Order/Basic.lean
theorem forall_lt_iff_le' [LinearOrder α] {a b : α} : (∀ ⦃c⦄, a < c → b < c) ↔ b ≤ a
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := simp)]
theorem inv_comp [Inv γ] [ContinuousInv γ] (f : C(β, γ)) (g : C(α, β)) :
    f⁻¹.comp g = (f.comp g)⁻¹
-- Mathlib/Algebra/Ring/Commute.lean
lemma sq_ne_one_iff : a ^ 2 ≠ 1 ↔ a ≠ 1 ∧ a ≠ -1
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem forall_const (α : Sort _) [i : Nonempty α] : (α → b) ↔ b
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem center_toSubring (R A : Type*) [CommRing R] [Ring A] [Algebra R A] :
    (center R A).toSubring = Subring.center A
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_not_ge : ∀{a b : Nat}, ¬(a ≥ b) → a ≤ b
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean
/-- The morphism `C⁺ : Spec R[x] → Spec R` is open.
Stacks Project "Lemma 00FB", first part.

https://stacks.math.columbia.edu/tag/00FB
-/
theorem isOpenMap_comap_C : IsOpenMap (PrimeSpectrum.comap (C : R →+* R[X]))
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem map_mod [Field k] (f : R →+* k) : (p % q).map f = p.map f % q.map f
-- Mathlib/Data/Set/Defs.lean
@[mfld_simps] theorem mem_range_self (i : ι) : f i ∈ range f
-- Mathlib/ModelTheory/ElementarySubstructures.lean
@[simp]
theorem theory_model_iff (S : L.ElementarySubstructure M) (T : L.Theory) : S ⊨ T ↔ M ⊨ T
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem disjoint_cobounded_nhdsSet {s : Set α} (hs : IsCompact s) : Disjoint (cobounded α) (𝓝ˢ s)
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem ContDiff.cexp {n} (h : ContDiff 𝕜 n f) : ContDiff 𝕜 n fun x => Complex.exp (f x)
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl) This new cone is used to construct the algebra structure -/
@[simps! π_app]
def newCone : Cone (D ⋙ forget T)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem StructureGroupoid.le_iff {G₁ G₂ : StructureGroupoid H} : G₁ ≤ G₂ ↔ ∀ e, e ∈ G₁ → e ∈ G₂
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_Iic_eq_integral_Iio : ∫ t in Iic x, f t ∂μ = ∫ t in Iio x, f t ∂μ
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem one_symm : (1 : Perm α).symm = 1
-- Mathlib/Order/LiminfLimsup.lean
theorem HasBasis.liminf_eq_iSup_iInf {p : ι → Prop} {s : ι → Set β} {f : Filter β} {u : β → α}
    (h : f.HasBasis p s) : liminf u f = ⨆ (i) (_ : p i), ⨅ a ∈ s i, u a
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
/-- Variant of `mul_le_of_le_one_left` for `b` non-positive instead of non-negative.  -/
theorem le_mul_of_le_one_left [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hb : b ≤ 0) (h : a ≤ 1) : b ≤ a * b
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem ghostComponent_apply (n : ℕ) (x : 𝕎 R) : ghostComponent n x = aeval x.coeff (W_ ℤ n)
-- Mathlib/Data/Nat/Defs.lean
lemma le_add_pred_of_pos (a : ℕ) (hb : b ≠ 0) : a ≤ b + (a - 1)
-- Mathlib/Order/Filter/EventuallyConst.lean
theorem eventuallyConst_pred {p : α → Prop} :
    EventuallyConst p l ↔ (∀ᶠ x in l, p x) ∨ (∀ᶠ x in l, ¬p x)
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- The reduction formula for the integral of `sin x ^ n` for any natural `n ≥ 2`. -/
theorem integral_sin_pow :
    (∫ x in a..b, sin x ^ (n + 2)) =
      (sin a ^ (n + 1) * cos a - sin b ^ (n + 1) * cos b) / (n + 2) +
        (n + 1) / (n + 2) * ∫ x in a..b, sin x ^ n
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected theorem map [OpensMeasurableSpace α] [MeasurableSpace β] [TopologicalSpace β]
    [BorelSpace β] (f : α ≃ₜ β) (μ : Measure α) [OuterRegular μ] :
    (Measure.map f μ).OuterRegular
-- Mathlib/SetTheory/Cardinal/Subfield.lean
lemma cardinal_mk_closure [Infinite s] : #(closure s) = #s
-- Mathlib/LinearAlgebra/Span.lean
theorem span_eq_iSup_of_singleton_spans (s : Set M) : span R s = ⨆ x ∈ s, R ∙ x
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- A separating family of seminorms induces a T₁ topology. -/
theorem WithSeminorms.T1_of_separating (hp : WithSeminorms p)
    (h : ∀ x, x ≠ 0 → ∃ i, p i x ≠ 0) : T1Space E
-- Mathlib/Algebra/Algebra/Basic.lean
@[simp]
lemma LinearEquiv.extendScalarsOfSurjective_apply (f : M ≃ₗ[R] N) (x) :
    f.extendScalarsOfSurjective h x = f x
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem snd_map_prod_mk₀ {X : α → β} {Y : α → γ} {μ : Measure α} (hX : AEMeasurable X μ) :
    (μ.map fun a => (X a, Y a)).snd = μ.map Y
-- Mathlib/Topology/Sequences.lean
/-- In a sequential space, a set is closed iff it's sequentially closed. -/
theorem isSeqClosed_iff_isClosed [SequentialSpace X] {M : Set X} : IsSeqClosed M ↔ IsClosed M
-- Mathlib/Data/Finset/Basic.lean
theorem insert_ne_self : insert a s ≠ s ↔ a ∉ s
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- An isometry from an emetric space is a uniform embedding -/
protected theorem uniformEmbedding (hf : Isometry f) : UniformEmbedding f
-- Mathlib/Data/Nat/Digits.lean
theorem ofDigits_zmod (b : ℤ) (k : ℕ) (L : List ℕ) : ofDigits b L % k = ofDigits (b % k) L % k
-- Mathlib/Logic/Function/Basic.lean
theorem RightInverse.comp {f : α → β} {g : β → α} {h : β → γ} {i : γ → β} (hf : RightInverse f g)
    (hh : RightInverse h i) : RightInverse (h ∘ f) (g ∘ i)
-- Mathlib/Topology/VectorBundle/Constructions.lean
theorem trivialization.coordChangeL (b : B) :
    (trivialization B F).coordChangeL 𝕜 (trivialization B F) b =
      ContinuousLinearEquiv.refl 𝕜 F
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_equiv_eq_comap_symm (f : G ≃* N) (K : Subgroup G) :
    K.map f = K.comap (G := N) f.symm
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem getLsb_rev (x : BitVec w) (i : Fin w) :
    x.getLsb i.rev = x.getMsb i
-- Mathlib/CategoryTheory/FullSubcategory.lean
lemma FullSubcategory.comp_def {X Y Z : FullSubcategory Z} (f : X ⟶ Y) (g : Y ⟶ Z) :
    f ≫ g = (f ≫ g : X.obj ⟶ Z.obj)
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc, simp]
theorem leftUnitor_inv_whiskerRight (f : a ⟶ b) (g : b ⟶ c) :
    (λ_ f).inv ▷ g = (λ_ (f ≫ g)).inv ≫ (α_ (𝟙 a) f g).inv
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_le_of_le_comap {T : Submonoid N} {f : F} : S ≤ T.comap f → S.map f ≤ T
-- Mathlib/Data/Set/MulAntidiagonal.lean
@[to_additive Set.AddAntidiagonal.eq_of_snd_eq_snd]
theorem eq_of_snd_eq_snd (h : (x : α × α).snd = (y : α × α).snd) : x = y
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem or_iff_right_iff_imp : ∀(a b : Bool), ((a || b) = b) ↔ (a → b)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem range_sin : range sin = (Icc (-1) 1 : Set ℝ)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
/-- The function `expNegInvGlue` is positive on `(0, +∞)`. -/
theorem pos_of_pos {x : ℝ} (hx : 0 < x) : 0 < expNegInvGlue x
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem pi_refl : (PartialEquiv.pi fun i ↦ PartialEquiv.refl (αi i)) = .refl (∀ i, αi i)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem principalUnitGroup_symm_apply (a : (Units.map (LocalRing.residue A).toMonoidHom).ker) :
    ((A.principalUnitGroupEquiv.symm a : Kˣ) : K) = ((a : Aˣ) : A)
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem smul_set_univ₀ (ha : a ≠ 0) : a • (univ : Set β) = univ
-- Mathlib/Order/BoundedOrder.lean
theorem StrictAnti.apply_eq_top_iff (hf : StrictAnti f) : f a = f ⊤ ↔ a = ⊤
-- Mathlib/Data/Matrix/Basic.lean
/-- `Matrix.diag` as a `LinearMap`. -/
@[simps]
def diagLinearMap [Semiring R] [AddCommMonoid α] [Module R α] : Matrix n n α →ₗ[R] n → α
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- This is an internal lemma used inside the default of `PseudoMetricSpace.edist`. -/
private theorem dist_nonneg' {α} {x y : α} (dist : α → α → ℝ)
    (dist_self : ∀ x : α, dist x x = 0) (dist_comm : ∀ x y : α, dist x y = dist y x)
    (dist_triangle : ∀ x y z : α, dist x z ≤ dist x y + dist y z) : 0 ≤ dist x y
-- Mathlib/Order/Filter/Pointwise.lean
@[simp]
theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem eq_aleph'_of_eq_card_ord {o : Ordinal} (ho : o.card.ord = o) : ∃ a, (aleph' a).ord = o
-- Mathlib/Algebra/Order/Floor.lean
theorem preimage_ceil_of_ne_zero (hn : n ≠ 0) : (Nat.ceil : α → ℕ) ⁻¹' {n} = Ioc (↑(n - 1) : α) n
-- Mathlib/Topology/Basic.lean
theorem frequently_nhds_iff {p : X → Prop} :
    (∃ᶠ y in 𝓝 x, p y) ↔ ∀ U : Set X, x ∈ U → IsOpen U → ∃ y ∈ U, p y
-- Mathlib/CategoryTheory/Sites/Sieves.lean
@[simp]
theorem functorPullback_id (R : Presieve X) : R.functorPullback (𝟭 _) = R
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
/-- The constant `C` provided by the definition of `LiouvilleWith` can be made positive.
We also add `1 ≤ n` to the list of assumptions about the denominator. While it is equivalent to
the original statement, the case `n = 0` breaks many arguments. -/
theorem exists_pos (h : LiouvilleWith p x) :
    ∃ (C : ℝ) (_h₀ : 0 < C),
      ∃ᶠ n : ℕ in atTop, 1 ≤ n ∧ ∃ m : ℤ, x ≠ m / n ∧ |x - m / n| < C / n ^ p
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Integration by parts**. Special case of
`intervalIntegrable.integral_mul_deriv_eq_deriv_mul_of_hasDeriv_right`
where the functions have a one-sided derivative at the endpoints. -/
theorem integral_mul_deriv_eq_deriv_mul_of_hasDerivWithinAt {u v u' v' : ℝ → A}
    (hu : ∀ x ∈ [[a, b]], HasDerivWithinAt u (u' x) [[a, b]] x)
    (hv : ∀ x ∈ [[a, b]], HasDerivWithinAt v (v' x) [[a, b]] x)
    (hu' : IntervalIntegrable u' volume a b)
    (hv' : IntervalIntegrable v' volume a b) :
    ∫ x in a..b, u x * v' x = u b * v b - u a * v a - ∫ x in a..b, u' x * v x
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
/-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
doesn't assume `0≤K`. -/
protected theorem of_le_add_mul' {f : α → ℝ} (K : ℝ)
    (h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + K * dist x y) : LipschitzOnWith (Real.toNNReal K) f s
-- Mathlib/RingTheory/Presentation.lean
@[simp]
lemma quotientEquiv_mk (p : P.Ring) : P.quotientEquiv p = algebraMap P.Ring S p
-- Mathlib/Order/LiminfLimsup.lean
theorem not_isBoundedUnder_of_tendsto_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atTop) : ¬IsBoundedUnder (· ≤ ·) l f
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem modByMonicHom_mk (hg : g.Monic) (f : R[X]) : modByMonicHom hg (mk g f) = f %ₘ g
-- Mathlib/Order/Bounds/Basic.lean
theorem upperBounds_Ico {a b : γ} (hab : a < b) : upperBounds (Ico a b) = Ici b
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csSup_eq_univ_of_not_bddAbove {s : Set α} (hs : ¬BddAbove s) : sSup s = sSup univ
-- Mathlib/Data/Matroid/Dual.lean
theorem Base.compl_base_dual (h : M.Base B) : M✶.Base (M.E \ B)
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
@[norm_cast]
theorem coe_pow (e : X ≃ᵈ X) (n : ℕ) : ⇑(e ^ n) = e^[n]
-- Mathlib/Topology/Algebra/OpenSubgroup.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_toOpens : ((U : Opens G) : Set G) = U
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem tendsto_arctan_atTop : Tendsto arctan atTop (𝓝[<] (π / 2))
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_horiz_isIso [IsIso fst] [IsIso g] (sq : CommSq fst snd f g) : IsPullback fst snd f g
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem prime_iff {p : ℕ} : p.Prime ↔ _root_.Prime p
-- Mathlib/Algebra/Field/Subfield.lean
theorem map_sup (s t : Subfield K) (f : K →+* L) : (s ⊔ t).map f = s.map f ⊔ t.map f
-- Mathlib/Order/LiminfLimsup.lean
theorem bliminf_antitone (h : ∀ x, p x → q x) : bliminf u f q ≤ bliminf u f p
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem pellZd_re (n : ℕ) : (pellZd a1 n).re = xn a1 n
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma sqrt_eq_one : sqrt x = 1 ↔ x = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasFDerivAt.ccos (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) • f') x
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem foldrM_push' [Monad m] (f : α → β → m β) (init : β) (arr : Array α) (a : α) :
    (arr.push a).foldrM f init (start := arr.size + 1) = f a init >>= arr.foldrM f
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem aleph0_mul_mk_eq {α : Type*} [Infinite α] : ℵ₀ * #α = #α
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
theorem dvd_lcm_left {a b : Int} : a ∣ lcm a b
-- Mathlib/RingTheory/OreLocalization/Ring.lean
protected theorem left_distrib (x y z : R[S⁻¹]) : x * (y + z) = x * y + x * z
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval_monomial (n : ℕ) :
    (monomial n r).smeval x = r • x ^ n
-- Mathlib/Data/Complex/Exponential.lean
theorem cosh_mul_I : cosh (x * I) = cos x
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem alternatization_coe (m : MultilinearMap R (fun _ : ι => M) N') :
    ↑(alternatization m) = (∑ σ : Perm ι, Equiv.Perm.sign σ • m.domDomCongr σ : _)
-- Mathlib/Topology/Connected/Basic.lean
theorem IsConnected.union {s t : Set α} (H : (s ∩ t).Nonempty) (Hs : IsConnected s)
    (Ht : IsConnected t) : IsConnected (s ∪ t)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem zipWith_distrib_tail : (zipWith f l l').tail = zipWith f l.tail l'.tail
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
/-- The associativity of the composition of cochains. -/
lemma comp_assoc {n₁ n₂ n₃ n₁₂ n₂₃ n₁₂₃ : ℤ}
    (z₁ : Cochain F G n₁) (z₂ : Cochain G K n₂) (z₃ : Cochain K L n₃)
    (h₁₂ : n₁ + n₂ = n₁₂) (h₂₃ : n₂ + n₃ = n₂₃) (h₁₂₃ : n₁ + n₂ + n₃ = n₁₂₃) :
    (z₁.comp z₂ h₁₂).comp z₃ (show n₁₂ + n₃ = n₁₂₃ by rw [← h₁₂, h₁₂₃]) =
      z₁.comp (z₂.comp z₃ h₂₃) (by rw [← h₂₃, ← h₁₂₃, add_assoc])
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem dslope_of_ne (f : 𝕜 → E) (h : b ≠ a) : dslope f a b = slope f a b
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_univ_pi (ι : Type*) [Fintype ι] : dimH (univ : Set (ι → ℝ)) = Fintype.card ι
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma lift' (hS : S.Exact) {A : C} (k : A ⟶ S.X₂) (hk : k ≫ S.g = 0) [Mono S.f] :
    ∃ (l : A ⟶ S.X₁), l ≫ S.f = k
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem comp_id (f : α →ₙ+* β) : f.comp (NonUnitalRingHom.id α) = f
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_le_mul_of_nonneg_right {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a * c ≤ b * c
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem coe_zero : ⇑(0 : M ≃ₛₗ[σ₁₂] M₂) = 0
-- Mathlib/Data/NNReal/Basic.lean
theorem coe_nonneg (r : ℝ≥0) : (0 : ℝ) ≤ r
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem IsLimit.succ_lt {x c} (h : IsLimit c) : x < c → succ x < c
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
    I.splitLower i x ≠ I.splitUpper i x
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem preCDF_le_one (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] :
    ∀ᵐ a ∂ρ.fst, ∀ r, preCDF ρ r a ≤ 1
-- Mathlib/RingTheory/Nilpotent/Defs.lean
lemma IsNilpotent.pow_succ (n : ℕ) {S : Type*} [MonoidWithZero S] {x : S}
    (hx : IsNilpotent x) : IsNilpotent (x ^ n.succ)
-- Mathlib/Topology/Homotopy/HSpaces.lean
theorem qRight_zero_right (t : I) :
    (qRight (t, 0) : ℝ) = if (t : ℝ) ≤ 1 / 2 then (2 : ℝ) * t else 1
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem ker_eq_bot_iff_eq_zero : ker f = ⊥ ↔ ∀ x, f x = 0 → x = 0
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
@[simp] lemma id_τ₂ : Hom.τ₂ (𝟙 S) = 𝟙 _
-- Mathlib/Data/Int/Defs.lean
lemma natAbs_eq_of_dvd_dvd (hmn : m ∣ n) (hnm : n ∣ m) : natAbs m = natAbs n
-- Mathlib/Data/Set/Defs.lean
@[simp] theorem mem_diff {s t : Set α} (x : α) : x ∈ s \ t ↔ x ∈ s ∧ x ∉ t
-- Mathlib/RingTheory/Ideal/Cotangent.lean
@[simp]
lemma mapCotangent_toCotangent
    (I₁ : Ideal A) (I₂ : Ideal B) (f : A →ₐ[R] B) (h : I₁ ≤ I₂.comap f) (x : I₁) :
    Ideal.mapCotangent I₁ I₂ f h (Ideal.toCotangent I₁ x) = Ideal.toCotangent I₂ ⟨f x, h x.2⟩
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_id : ⇑(BoundedLatticeHom.id α) = id
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp)]
lemma Pi.isoLimit_hom_π (j : α) :
    (Pi.isoLimit X).hom ≫ limit.π _ (Discrete.mk j) = Pi.π _ j
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem le_einfsep_pi_of_le {π : β → Type*} [Fintype β] [∀ b, PseudoEMetricSpace (π b)]
    {s : ∀ b : β, Set (π b)} {c : ℝ≥0∞} (h : ∀ b, c ≤ einfsep (s b)) :
    c ≤ einfsep (Set.pi univ s)
-- Mathlib/Topology/Basic.lean
theorem Continuous.frontier_preimage_subset (hf : Continuous f) (t : Set Y) :
    frontier (f ⁻¹' t) ⊆ f ⁻¹' frontier t
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isInt_zpow_neg {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsInt (a ^ nb)⁻¹ (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne)
-- Mathlib/Data/Complex/FiniteDimensional.lean
@[simp]
theorem finrank_real_complex : finrank ℝ ℂ = 2
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
/-- See also `Ergodic.ae_empty_or_univ_of_image_ae_le`. -/
theorem ae_empty_or_univ_of_image_ae_le' (hf : Ergodic f μ) (hs : MeasurableSet s)
    (hs' : f '' s ≤ᵐ[μ] s) (h_fin : μ s ≠ ∞) : s =ᵐ[μ] (∅ : Set α) ∨ s =ᵐ[μ] univ
-- Mathlib/Algebra/Star/StarAlgHom.lean
theorem rightInverse_symm (e : A ≃⋆ₐ[R] B) : Function.RightInverse e.symm e
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma toSpec_fromSpec {f : A} {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m) (x : Spec.T (A⁰_ f)) :
    toSpec 𝒜 f (FromSpec.toFun f_deg hm x) = x
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
protected theorem add (hf : UnifIntegrable f p μ) (hg : UnifIntegrable g p μ) (hp : 1 ≤ p)
    (hf_meas : ∀ i, AEStronglyMeasurable (f i) μ) (hg_meas : ∀ i, AEStronglyMeasurable (g i) μ) :
    UnifIntegrable (f + g) p μ
-- Mathlib/Data/ENNReal/Basic.lean
theorem coe_sInf {s : Set ℝ≥0} (hs : s.Nonempty) : (↑(sInf s) : ℝ≥0∞) = ⨅ a ∈ s, ↑a
-- Mathlib/Data/Fin/Basic.lean
/-- `succ` commutes with `predAbove`. -/
@[simp] lemma succ_predAbove_succ (a : Fin n) (b : Fin (n + 1)) :
    a.succ.predAbove b.succ = (a.predAbove b).succ
-- Mathlib/Analysis/Complex/Asymptotics.lean
@[simp, norm_cast]
theorem isBigO_ofReal_left {f : α → ℝ} {g : α → E} : (f · : α → ℂ) =O[l] g ↔ f =O[l] g
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem equivOfEq_trans {S T U : IntermediateField F E} (hST : S = T) (hTU : T = U) :
    (equivOfEq hST).trans (equivOfEq hTU) = equivOfEq (hST.trans hTU)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_deriv_rpow_p_mul_one_add_smoothingFn (p : ℝ) :
    deriv (fun z => z ^ p * (1 + ε z))
      =ᶠ[atTop] fun z => p * z ^ (p-1) * (1 + ε z) - z ^ (p-1) / (log z ^ 2)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₁ =O[l] g₁ ↔ f₂ =O[l] g₂
-- Mathlib/Geometry/Euclidean/Triangle.lean
/-- The cosine of the sum of the angles of a possibly degenerate
triangle (where two given sides are nonzero), vector angle form. -/
theorem cos_angle_add_angle_sub_add_angle_sub_eq_neg_one {x y : V} (hx : x ≠ 0) (hy : y ≠ 0) :
    Real.cos (angle x y + angle x (x - y) + angle y (y - x)) = -1
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem Fin.image_castSucc (n : ℕ) :
    (univ : Finset (Fin n)).image Fin.castSucc = {Fin.last n}ᶜ
-- Mathlib/CategoryTheory/Abelian/LeftDerived.lean
@[reassoc (attr := simp)]
lemma pOpcycles_comp_fromLeftDerivedZero' {X : C}
    (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    HomologicalComplex.pOpcycles _ _ ≫ P.fromLeftDerivedZero' F = F.map (P.π.f 0)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
lemma leftShift_comp (a n' : ℤ) (hn' : n + a = n') {m t t' : ℤ} (γ' : Cochain L M m)
    (h : n + m = t) (ht' : t + a = t') :
    (γ.comp γ' h).leftShift a t' ht' = (a * m).negOnePow • (γ.leftShift a n' hn').comp γ'
      (by rw [← ht', ← h, ← hn', add_assoc, add_comm a, add_assoc])
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_algebraMap {A : Type*} [CommSemiring A] [Algebra A R] (m : A) :
    mk (algebraMap A R m) 1 = algebraMap A (Localization M) m