ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp]
theorem gcd_zero : (0 : Multiset α).gcd = 0
-- Mathlib/Data/Fintype/Card.lean
theorem Fintype.card_pempty : Fintype.card PEmpty = 0
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun _ => ∅ : ∀ i, Set (α i)) = ∅
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.comp_injective {i : γ → β} (hf : Multipliable f) (hi : Injective i) :
    Multipliable (f ∘ i)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Given a finite-dimensional space `E` and subspace `K`, the dimensions of `K` and `Kᗮ` add to
that of `E`. -/
theorem Submodule.finrank_add_finrank_orthogonal [FiniteDimensional 𝕜 E] (K : Submodule 𝕜 E) :
    finrank 𝕜 K + finrank 𝕜 Kᗮ = finrank 𝕜 E
-- Mathlib/Topology/Sets/Compacts.lean
@[ext]
protected theorem ext {s t : CompactOpens α} (h : (s : Set α) = t) : s = t
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
/-- Multiplication of a matrix by its inverse is commutative.
This is the column and row partitioned matrix form of `Matrix.mul_eq_one_comm`.

The condition `e : n ≃ n₁ ⊕ n₂` states that `fromColumns A₁ A₂` and `fromRows B₁ B₂` are "square".
-/
lemma fromColumns_mul_fromRows_eq_one_comm (e : n ≃ n₁ ⊕ n₂)
    (A₁ : Matrix n n₁ R) (A₂ : Matrix n n₂ R) (B₁ : Matrix n₁ n R) (B₂ : Matrix n₂ n R) :
    fromColumns A₁ A₂ * fromRows B₁ B₂ = 1 ↔ fromRows B₁ B₂ * fromColumns A₁ A₂ = 1
-- Mathlib/Data/Finmap.lean
@[elab_as_elim]
theorem induction_on₃ {C : Finmap β → Finmap β → Finmap β → Prop} (s₁ s₂ s₃ : Finmap β)
    (H : ∀ a₁ a₂ a₃ : AList β, C ⟦a₁⟧ ⟦a₂⟧ ⟦a₃⟧) : C s₁ s₂ s₃
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
/-- Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure NumDenSameDeg where
  deg : ι
  (num den : 𝒜 deg)
  den_mem : (den : A) ∈ x
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem opRingEquiv_symm_single [Monoid G] (r : kᵐᵒᵖ) (x : Gᵐᵒᵖ) :
    MonoidAlgebra.opRingEquiv.symm (single x r) = op (single x.unop r.unop)
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem le_of_not_gt {x y : Int} (h : ¬ (y > x)) : y ≤ x
-- Mathlib/Data/List/Basic.lean
theorem mem_map_of_involutive {f : α → α} (hf : Involutive f) {a : α} {l : List α} :
    a ∈ map f l ↔ f a ∈ l
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrixAlgEquiv_mul (f g : M₁ →ₗ[R] M₁) :
    LinearMap.toMatrixAlgEquiv v₁ (f * g) =
      LinearMap.toMatrixAlgEquiv v₁ f * LinearMap.toMatrixAlgEquiv v₁ g
-- Mathlib/Topology/Constructions.lean
theorem nhds_toMul (x : Additive X) : 𝓝 (toMul x) = map toMul (𝓝 x)
-- Mathlib/RingTheory/AlgebraicIndependent.lean
@[simp]
theorem AlgebraicIndependent.aeval_repr (p) : aeval x (hx.repr p) = p
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem map_sub_nat (x : ℝ) (n : ℕ) : f (x - n) = f x - n
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.injective [Nontrivial R] (hv : LinearIndependent R v) : Injective v
-- Mathlib/Algebra/Star/CentroidHom.lean
@[simp]
lemma starCenterIsoCentroid_apply (a : ↥(NonUnitalStarSubsemiring.center α)) :
    CentroidHom.starCenterIsoCentroid a = CentroidHom.starCenterToCentroid a
-- .lake/packages/batteries/Batteries/Data/HashMap/WF.lean
theorem update_update (self : Buckets α β) (i d d' h h') :
    (self.update i d h).update i d' h' = self.update i d' h
-- Mathlib/Topology/Instances/NNReal.lean
/-- Embedding of `ℝ≥0` to `ℝ` as a bundled continuous map. -/
@[simps (config := .asFn)]
def _root_.ContinuousMap.coeNNRealReal : C(ℝ≥0, ℝ)
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma meas_countablePartitionSet_le_of_fst_le (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (x : γ)
    (s : Set β) :
    κ a (countablePartitionSet n x ×ˢ s) ≤ ν a (countablePartitionSet n x)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_neg (p : R[X]) (x : R) : (-p).eval x = -p.eval x
-- Mathlib/Data/Finset/Basic.lean
@[ext]
theorem ext {s₁ s₂ : Finset α} : (∀ a, a ∈ s₁ ↔ a ∈ s₂) → s₁ = s₂
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_le_one (z : ℤ_[p]) : ‖z‖ ≤ 1
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mulPosStrictMono_iff_mulPosReflectLE : MulPosStrictMono α ↔ MulPosReflectLE α
-- Mathlib/Data/Finset/Lattice.lean
theorem iSup_insert_update {x : α} {t : Finset α} (f : α → β) {s : β} (hx : x ∉ t) :
    ⨆ i ∈ insert x t, Function.update f x s i = s ⊔ ⨆ i ∈ t, f i
-- Mathlib/LinearAlgebra/TensorAlgebra/Basis.lean
@[simp]
lemma equivFreeAlgebra_symm_ι (b : Basis κ R M) (i : κ) :
    (equivFreeAlgebra b).symm (FreeAlgebra.ι R i) = ι R (b i)
-- Mathlib/Analysis/Convex/Deriv.lean
lemma strictAntiOn_derivWithin (hfc : StrictConcaveOn ℝ S f) (hfd : DifferentiableOn ℝ f S) :
    StrictAntiOn (derivWithin f S) S
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toOuterMeasure_apply_le_toMeasure_apply : p.toOuterMeasure s ≤ p.toMeasure s
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[ext 1200]
theorem algHom_ext {f g : R[X] →ₐ[R] B} (hX : f X = g X) :
    f = g
-- Mathlib/Data/Multiset/Nodup.lean
theorem nodup_iff_pairwise {α} {s : Multiset α} : Nodup s ↔ Pairwise (· ≠ ·) s
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
theorem summable_of_isEquivalent_nat {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [FiniteDimensional ℝ E] {f : ℕ → E} {g : ℕ → E} (hg : Summable g) (h : f ~[atTop] g) :
    Summable f
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem associated_eq_self_apply (x : M) : associatedHom S Q x x = Q x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The following diagram is a pullback
```
X --id--> X
|         |
f         f
v         v
Z --id--> Z
```
-/
lemma id_horiz (f : X ⟶ Z) : IsPushout (𝟙 X) f f (𝟙 Z)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- `padicValNat p 0` is `0` for any `p`. -/
@[simp]
protected theorem zero : padicValNat p 0 = 0
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma mem_ofUnits (S : Subgroup Mˣ) {x : M} {y : Mˣ} (h₁ : y ∈ S) (h₂ : y = x) : x ∈ S.ofUnits
-- Mathlib/Order/Atoms/Finite.lean
theorem univ : (Finset.univ : Finset α) = {⊤, ⊥}
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem coe_expand : (expand R p : R[X] → R[X]) = eval₂ C (X ^ p)
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem map_T (f : R →+* S) (n : ℤ) : map f (T R n) = T S n
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr_mapAccumr :
    mapAccumr f₁ (mapAccumr f₂ xs s₂).snd s₁
    = let m := (mapAccumr (fun x s =>
        let r₂ := f₂ x s.snd
        let r₁ := f₁ r₂.snd s.fst
        ((r₁.fst, r₂.fst), r₁.snd)
      ) xs (s₁, s₂))
      (m.fst.fst, m.snd)
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
theorem hasSum_inner (f g : lp G 2) : HasSum (fun i => ⟪f i, g i⟫) ⟪f, g⟫
-- Mathlib/Analysis/Fourier/RiemannLebesgueLemma.lean
/-- The Riemann-Lebesgue lemma for functions on `ℝ`. -/
theorem Real.tendsto_integral_exp_smul_cocompact (f : ℝ → E) :
    Tendsto (fun w : ℝ => ∫ v : ℝ, 𝐞 (-(v * w)) • f v) (cocompact ℝ) (𝓝 0)
-- Mathlib/Order/CompleteLattice.lean
lemma isLUB_iff_sSup_eq : IsLUB s a ↔ sSup s = a
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem fromLoop_apply (i : N) {p : Ω (Ω^ { j // j ≠ i } X x) const} {t : I^N} :
    fromLoop i p t = p (t i) (Cube.splitAt i t).snd
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
/-- If the set where you want `f` to be smooth lies entirely in a single chart, and `f` maps it
  into a single chart, the smoothness of `f` on that set can be expressed by purely looking in
  these charts.
  Note: this lemma uses `extChartAt I x '' s` instead of `(extChartAt I x).symm ⁻¹' s` to ensure
  that this set lies in `(extChartAt I x).target`. -/
theorem contMDiffOn_iff_of_subset_source {x : M} {y : M'} (hs : s ⊆ (chartAt H x).source)
    (h2s : MapsTo f s (chartAt H' y).source) :
    ContMDiffOn I I' n f s ↔
      ContinuousOn f s ∧
        ContDiffOn 𝕜 n (extChartAt I' y ∘ f ∘ (extChartAt I x).symm) (extChartAt I x '' s)
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.int_even_mul_periodic [Ring α] [InvolutiveNeg β] (h : Antiperiodic f c)
    (n : ℤ) : Periodic f (n * (2 * c))
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp 1100]
theorem normalize_lcm (s : Multiset α) : normalize s.lcm = s.lcm
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp]
theorem card_eq_coe_fintype_card [Fintype α] : card α = Fintype.card α
-- Mathlib/Data/Fintype/Basic.lean
theorem Fintype.coe_image_univ [Fintype α] [DecidableEq β] {f : α → β} :
    ↑(Finset.image f Finset.univ) = Set.range f
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_map {f : α → β} {x : Filter α} : Tendsto f x (map f x)
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem factors_lemma {k} : (k + 2) / minFac (k + 2) < k + 2
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem liftRel_cons (R : α → β → Prop) (a b s t) :
    LiftRel R (cons a s) (cons b t) ↔ R a b ∧ LiftRel R s t
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
@[gcongr]
theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem mem_finset_inf {ι} {s : Finset ι} {p : ι → Submodule R M} {x : M} :
    x ∈ s.inf p ↔ ∀ i ∈ s, x ∈ p i
-- Mathlib/Init/Logic.lean
theorem let_body_eq {α : Sort v} {β : α → Sort u} (a : α) {b₁ b₂ : ∀ x : α, β x}
    (h : ∀ x, b₁ x = b₂ x) : (let x : α := a; b₁ x) = (let x : α := a; b₂ x)
-- Mathlib/Order/WithBot.lean
@[simp, deprecated coe_lt_coe "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem some_lt_some : @LT.lt (WithTop α) _ (Option.some a) (Option.some b) ↔ a < b
-- Mathlib/Topology/Connected/LocallyConnected.lean
theorem IsOpen.locallyConnectedSpace [LocallyConnectedSpace α] {U : Set α} (hU : IsOpen U) :
    LocallyConnectedSpace U
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps, norm_cast]
theorem ratCast_im (q : ℚ) : im (q : K) = 0
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
theorem _root_.Matrix.toLin_finTwoProd_toContinuousLinearMap (a b c d : 𝕜) :
    LinearMap.toContinuousLinearMap
      (Matrix.toLin (Basis.finTwoProd 𝕜) (Basis.finTwoProd 𝕜) !![a, b; c, d]) =
      (a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
        (c • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + d • ContinuousLinearMap.snd 𝕜 𝕜 𝕜)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b
-- Mathlib/Topology/MetricSpace/PiNat.lean
protected theorem dist_self (x : ∀ n, E n) : dist x x = 0
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem finTwoProd_zero (R : Type*) [Semiring R] : Basis.finTwoProd R 0 = (1, 0)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem IsOfFinOrder.snd {x : α × β} (hx : IsOfFinOrder x) : IsOfFinOrder x.2
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem map_toPoly : (map φ P).toPoly = Polynomial.map φ P.toPoly
-- Mathlib/Algebra/Module/LinearMap/End.lean
/-- Each element of the semiring defines a module endomorphism.

This is a stronger version of `DistribMulAction.toModuleEnd`. -/
@[simps]
def toModuleEnd : S →+* Module.End R M
-- Mathlib/Probability/Process/Stopping.lean
theorem condexp_min_stopping_time_ae_eq_restrict_le_const (hτ : IsStoppingTime ℱ τ) (i : ι)
    [SigmaFinite (μ.trim (hτ.min_const i).measurableSpace_le)] :
    μ[f|(hτ.min_const i).measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ i}] μ[f|hτ.measurableSpace]
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
/-- The functor `Over S ⥤ Over S` that is constructed in order to apply the small
object argument to a family of morphisms `f i : A i ⟶ B i`, see the introduction
of the file `Mathlib.CategoryTheory.SmallObject.Construction` -/
@[simps! obj map]
noncomputable def functor : Over S ⥤ Over S
-- Mathlib/Order/Interval/Multiset.lean
theorem Ioo_cons_left (h : a < b) : a ::ₘ Ioo a b = Ico a b
-- Mathlib/Topology/Separation.lean
theorem Set.Subsingleton.isGδ_compl {s : Set X} [T1Space X] (hs : s.Subsingleton) : IsGδ sᶜ
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma map_of_mono_of_preservesKernel (hS : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [(S.map F).HasHomology] (_ : Mono S.f)
    (_ : PreservesLimit (parallelPair S.g 0) F) :
    (S.map F).Exact
-- Mathlib/Data/Complex/Exponential.lean
theorem two_sin : 2 * sin x = (exp (-x * I) - exp (x * I)) * I
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem extract.go₁_add_right_cancel (s : List Char) (i b e n : Nat) :
    go₁ s ⟨i + n⟩ ⟨b + n⟩ ⟨e + n⟩ = go₁ s ⟨i⟩ ⟨b⟩ ⟨e⟩
-- Mathlib/Data/Set/Function.lean
theorem _root_.StrictMonoOn.congr (h₁ : StrictMonoOn f₁ s) (h : s.EqOn f₁ f₂) :
    StrictMonoOn f₂ s
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem reverseInduction_last {n : Nat} {motive : Fin (n + 1) → Sort _} {zero succ} :
    (reverseInduction zero succ (Fin.last n) : motive (Fin.last n)) = zero
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem _root_.MeasurableSet.cylinder [∀ i, MeasurableSpace (α i)] (s : Finset ι)
    {S : Set (∀ i : s, α i)} (hS : MeasurableSet S) :
    MeasurableSet (cylinder s S)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
    a ^ n ∈ closedBall (b ^ n) (n • r)
-- Mathlib/Data/List/Sections.lean
theorem mem_sections {L : List (List α)} {f} : f ∈ sections L ↔ Forall₂ (· ∈ ·) f L
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
theorem MulEquivClass.toMulEquiv_injective [Mul α] [Mul β] [MulEquivClass F α β] :
    Function.Injective ((↑) : F → α ≃* β)
-- Mathlib/Topology/UniformSpace/CompactConvergence.lean
theorem uniformInducing_comp (g : C(β, δ)) (hg : UniformInducing g) :
    UniformInducing (ContinuousMap.comp g : C(α, β) → C(α, δ))
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
/-- For a self-adjoint operator `T`, a local extremum of the Rayleigh quotient of `T` on a sphere
centred at the origin is an eigenvector of `T`. -/
theorem hasEigenvector_of_isLocalExtrOn (hT : IsSelfAdjoint T) {x₀ : E} (hx₀ : x₀ ≠ 0)
    (hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere (0 : E) ‖x₀‖) x₀) :
    HasEigenvector (T : E →ₗ[𝕜] E) (↑(T.rayleighQuotient x₀)) x₀
-- Mathlib/Topology/Algebra/GroupCompletion.lean
@[norm_cast]
theorem UniformSpace.Completion.coe_zero [Zero α] : ((0 : α) : Completion α) = 0
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
theorem unop_sup (S₁ S₂ : Subsemiring Rᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop
-- Mathlib/Data/List/Sort.lean
theorem perm_mergeSort : ∀ l : List α, mergeSort r l ~ l
-- Mathlib/Data/Seq/WSeq.lean
theorem map_comp (f : α → β) (g : β → γ) (s : WSeq α) : map (g ∘ f) s = map g (map f s)
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation is continuous. -/
theorem toContinuous : Continuous (f : α → β)
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem product_singleton {b : β} : s ×ˢ {b} = s.map ⟨fun i => (i, b), Prod.mk.inj_right _⟩
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma LeftFractionRel.unop {W : MorphismProperty Cᵒᵖ} {X Y : Cᵒᵖ}
    {z₁ z₂ : W.LeftFraction X Y}
    (h : LeftFractionRel z₁ z₂) : RightFractionRel z₁.unop z₂.unop
-- Mathlib/Analysis/Quaternion.lean
@[continuity]
theorem continuous_im : Continuous fun q : ℍ => q.im
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp, norm_cast]
theorem coe_one : (↑(1 : R) : c.Quotient) = 1
-- Mathlib/FieldTheory/IntermediateField.lean
theorem mem_lift {F : IntermediateField K L} {E : IntermediateField K F} (x : F) :
    x.1 ∈ lift E ↔ x ∈ E
-- Mathlib/Tactic/Peel.lean
private theorem eventually_congr {α : Type*} {p q : α → Prop} {f : Filter α}
    (hq : ∀ (x : α), p x ↔ q x) : (∀ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, q x
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
lemma rpow_mul_natCast (x : ℝ≥0∞) (y : ℝ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_updateRow_smul' (M : Matrix n n R) (j : n) (s : R) (u : n → R) :
    det (updateRow (s • M) j u) = s ^ (Fintype.card n - 1) * det (updateRow M j u)
-- Mathlib/NumberTheory/Bernoulli.lean
/-- Alternate form of **Faulhaber's theorem**, relating the sum of p-th powers to the Bernoulli
numbers: $$\sum_{k=1}^{n} k^p = \sum_{i=0}^p (-1)^iB_i\binom{p+1}{i}\frac{n^{p+1-i}}{p+1}.$$
Deduced from `sum_range_pow`. -/
theorem sum_Ico_pow (n p : ℕ) :
    (∑ k ∈ Ico 1 (n + 1), (k : ℚ) ^ p) =
      ∑ i ∈ range (p + 1), bernoulli' i * (p + 1).choose i * (n : ℚ) ^ (p + 1 - i) / (p + 1)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem map_map [Semiring T] (g : S →+* T) (p : R[X]) : (p.map f).map g = p.map (g.comp f)
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
/-- The recursion `hermite (n+1) = (x - d/dx) (hermite n)` -/
@[simp]
theorem hermite_succ (n : ℕ) : hermite (n + 1) = X * hermite n - derivative (hermite n)
-- Mathlib/Data/Multiset/Basic.lean
theorem eq_union_right (h : s ≤ t) : s ∪ t = t
-- Mathlib/Data/NNReal/Basic.lean
theorem toNNReal_of_nonpos {r : ℝ} : r ≤ 0 → Real.toNNReal r = 0
-- Mathlib/Data/Complex/Basic.lean
theorem normSq_inv (z : ℂ) : normSq z⁻¹ = (normSq z)⁻¹
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem of_natCast [AddGroupWithOne α] (n : ℕ) : ((n : ZNum) : α) = n
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The sine of an angle in a right-angled triangle as a ratio of sides. -/
theorem sin_oangle_add_right_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    Real.Angle.sin (o.oangle x (x + y)) = ‖y‖ / ‖x + y‖
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
theorem algebraMap_adicCompletion :
    ⇑(algebraMap K <| v.adicCompletion K) = ((↑) : K → adicCompletion K v)
-- Mathlib/Algebra/Module/Torsion.lean
lemma isTorsionBy_quotient_element_smul :
    IsTorsionBy R (M⧸r • (⊤ : Submodule R M)) r
-- Mathlib/Topology/Instances/ENNReal.lean
theorem continuousOn_toNNReal : ContinuousOn ENNReal.toNNReal { a | a ≠ ∞ }
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem coe_top : ((⊤ : Subsemiring R) : Set R) = Set.univ
-- Mathlib/Order/Basic.lean
@[ext]
theorem LinearOrder.toPartialOrder_injective :
    Function.Injective (@LinearOrder.toPartialOrder α)
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem up_eq_up {a b : ULower α} : a.up = b.up ↔ a = b
-- Mathlib/Algebra/Ring/BooleanRing.lean
/-- A Boolean ring is a ring where multiplication is idempotent. -/
class BooleanRing (α) extends Ring α where
  /-- Multiplication in a boolean ring is idempotent. -/
  mul_self : ∀ a : α, a * a = a
-- Mathlib/Data/Real/EReal.lean
theorem abs_def (x : ℝ) : (x : EReal).abs = ENNReal.ofReal |x|
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[integral_simps]
theorem integral_smul (c : 𝕜) (f : α →₁[μ] E) : integral (c • f) = c • integral f
-- Mathlib/Analysis/Normed/Group/Uniform.lean
/-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
@[to_additive "A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C`
such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`"]
theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : Continuous f
-- Mathlib/Order/Bounded.lean
theorem bounded_ge_of_bounded_gt [Preorder α] (h : Bounded (· > ·) s) : Bounded (· ≥ ·) s
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
@[simp 1100]
theorem normalize_gcd (s : Multiset α) : normalize s.gcd = s.gcd
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem map_mul_right_nhds_one₀ (ha : a ≠ 0) : map (· * a) (𝓝 1) = 𝓝 (a)
-- Mathlib/CategoryTheory/SingleObj.lean
theorem mapHom_id : mapHom M M (MonoidHom.id M) = 𝟭 _
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_pos_of_pos {a : Nat} (h : 0 < a) : 0 < (a : Int)
-- Mathlib/Logic/Nontrivial/Defs.lean
theorem subsingleton_iff : Subsingleton α ↔ ∀ x y : α, x = y
-- Mathlib/Analysis/Convex/Jensen.lean
/-- **Minimum principle** for concave functions on a segment. If a function `f` is concave on the
segment `[x, y]`, then the eventual minimum of `f` on `[x, y]` is at `x` or `y`. -/
lemma ConcaveOn.min_le_of_mem_segment (hf : ConcaveOn 𝕜 [x -[𝕜] y] f) (hz : z ∈ [x -[𝕜] y]) :
    min (f x) (f y) ≤ f z
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `reverse` function reverses the ordering invariants. -/
protected theorem Ordered.reverse : ∀ {t : RBNode α}, t.Ordered cmp → t.reverse.Ordered (flip cmp)
-- Mathlib/SetTheory/Game/PGame.lean
/-- A new left option cannot hurt Left. -/
lemma le_insertLeft (x x' : PGame) : x ≤ insertLeft x x'
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
lemma X_smul_of (m : M) : (X : R[X]) • (of R M a m) = of R M a (a • m)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem mem_rat_span_latticeBasis [NumberField K] (x : K) :
    canonicalEmbedding K x ∈ Submodule.span ℚ (Set.range (latticeBasis K))
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_single_ne_bot (i : α) (h : b ≠ 0) : (single i b).support ≠ ⊥
-- Mathlib/GroupTheory/Exponent.lean
theorem Group.exponent_dvd_card [Fintype G] : Monoid.exponent G ∣ Fintype.card G
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_rel₂ {R : L.Relations 2} {t₁ t₂ : L.Term _} :
    (R.formula₂ t₁ t₂).Realize v ↔ RelMap R ![t₁.realize v, t₂.realize v]
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem symm_apply_apply (f : M ≃[L] N) (a : M) : f.symm (f a) = a
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := fun_prop, aesop safe 20 apply (rule_sets := [Measurable]))]
theorem AEMeasurable.div [MeasurableDiv₂ G] (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun a => f a / g a) μ
-- Mathlib/Logic/Basic.lean
theorem forall_or_right {q} {p : α → Prop} : (∀ x, p x ∨ q) ↔ (∀ x, p x) ∨ q
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_C_mul_X_pow_le (a : R) (n : ℕ) : natDegree (C a * X ^ n) ≤ n
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem continuousAt_const_smul_iff (c : G) :
    ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b
-- Mathlib/Topology/Sets/Order.lean
@[simp]
theorem coe_mk (s : Clopens α) (h) : (mk s h : Set α) = s
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem hasGradientAt_iff_isLittleO : HasGradientAt f f' x ↔
    (fun x' : F => f x' - f x - ⟪f', x' - x⟫) =o[𝓝 x] fun x' => x' - x
-- Mathlib/Algebra/RingQuot.lean
@[simp]
theorem lift_mkRingHom_apply (f : R →+* T) {r : R → R → Prop} (w : ∀ ⦃x y⦄, r x y → f x = f y) (x) :
    lift ⟨f, w⟩ (mkRingHom r x) = f x
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem HasDerivWithinAt.limsup_slope_le (hf : HasDerivWithinAt f f' s x) (hr : f' < r) :
    ∀ᶠ z in 𝓝[s \ {x}] x, slope f x z < r
-- Mathlib/Algebra/MvPolynomial/Variables.lean
theorem exists_rename_eq_of_vars_subset_range (p : MvPolynomial σ R) (f : τ → σ) (hfi : Injective f)
    (hf : ↑p.vars ⊆ Set.range f) : ∃ q : MvPolynomial τ R, rename f q = p
-- Mathlib/Data/Nat/Squarefree.lean
theorem sum_divisors_filter_squarefree {n : ℕ} (h0 : n ≠ 0) {α : Type*} [AddCommMonoid α]
    {f : ℕ → α} :
    ∑ i ∈ n.divisors.filter Squarefree, f i =
      ∑ i ∈ (UniqueFactorizationMonoid.normalizedFactors n).toFinset.powerset, f i.val.prod
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
lemma l2_opNorm_mul (A : Matrix m n 𝕜) (B : Matrix n l 𝕜) :
    ‖A * B‖ ≤ ‖A‖ * ‖B‖
-- Mathlib/Analysis/Convex/Hull.lean
theorem convexHull_smul (a : 𝕜) (s : Set E) : convexHull 𝕜 (a • s) = a • convexHull 𝕜 s
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem monic_mul_C_of_leadingCoeff_mul_eq_one {b : R} (hp : p.leadingCoeff * b = 1) :
    Monic (p * C b)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Certificate.of_combine_isUnsat (ctx : Context) (cs : Certificate) (h : cs.combine.isUnsat) : cs.denote ctx
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_add_left (a b : α) : toIcoDiv hp a (p + b) = toIcoDiv hp a b + 1