ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem contDiff_univBall : ContDiff ℝ n (univBall c r)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measure_compl_le_add_of_le_add [IsFiniteMeasure μ] (hs : MeasurableSet s)
    (ht : MeasurableSet t) {ε : ℝ≥0∞} (h : μ s ≤ μ t + ε) : μ tᶜ ≤ μ sᶜ + ε
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Composition by continuous linear equivs on the right respects higher differentiability on
domains. -/
theorem ContinuousLinearEquiv.contDiffOn_comp_iff (e : G ≃L[𝕜] E) :
    ContDiffOn 𝕜 n (f ∘ e) (e ⁻¹' s) ↔ ContDiffOn 𝕜 n f s
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
@[simp] lemma slope_neg (f : k → E) (x y : k) : slope (fun t ↦ -f t) x y = -slope f x y
-- Mathlib/Data/Finset/Basic.lean
theorem eq_singleton_iff_unique_mem {s : Finset α} {a : α} : s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a
-- Mathlib/Order/Cover.lean
theorem wcovBy_iff_covBy_or_eq : a ⩿ b ↔ a ⋖ b ∨ a = b
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem measurable_inl [MeasurableSpace α] [MeasurableSpace β] : Measurable (@Sum.inl α β)
-- Mathlib/LinearAlgebra/Dimension/RankNullity.lean
theorem nontrivial_of_hasRankNullity : Nontrivial R
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem toFinsupp_eq_one {a : R[X]} : a.toFinsupp = 1 ↔ a = 1
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem multiset_sum_mem {m : Multiset A} (h : ∀ x ∈ m, x ∈ S) : m.sum ∈ S
-- Mathlib/Data/Nat/Cast/Defs.lean
@[simp, norm_cast]
theorem cast_zero : ((0 : ℕ) : R) = 0
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[ext]
theorem ext {f g : C(α, β)} (h : ∀ a, f a = g a) : f = g
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem true_iff (p : Prop) : (True ↔ p) = p
-- Mathlib/Topology/DiscreteQuotient.lean
theorem proj_quotientMap : QuotientMap S.proj
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
lemma card_div_le : Nat.card (s / t) ≤ Nat.card s * Nat.card t
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem dropLast_single : [x].dropLast = []
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a positive constant, `fun x ↦ f x * r` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. -/
theorem tendsto_mul_const_atTop_of_pos (hr : 0 < r) :
    Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atTop
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem mem_spanningSets_of_index_le (μ : Measure α) [SigmaFinite μ] (x : α) {n : ℕ}
    (hn : spanningSetsIndex μ x ≤ n) : x ∈ spanningSets μ n
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
lemma hasFTaylorSeriesUpTo_fourierIntegral {N : ℕ∞}
    (hf : ∀ (n : ℕ), n ≤ N → Integrable (fun v ↦ ‖v‖^n * ‖f v‖) μ)
    (h'f : AEStronglyMeasurable f μ) :
    HasFTaylorSeriesUpTo N (fourierIntegral 𝐞 μ L.toLinearMap₂ f)
      (fun w n ↦ fourierIntegral 𝐞 μ L.toLinearMap₂ (fun v ↦ fourierPowSMulRight L f v n) w)
-- Mathlib/NumberTheory/LSeries/Basic.lean
theorem LSeriesSummable_iff_of_re_eq_re {f : ℕ → ℂ} {s s' : ℂ} (h : s.re = s'.re) :
    LSeriesSummable f s ↔ LSeriesSummable f s'
-- Mathlib/Algebra/GeomSum.lean
theorem mul_neg_geom_sum [Ring α] (x : α) (n : ℕ) : ((1 - x) * ∑ i ∈ range n, x ^ i) = 1 - x ^ n
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem join_nil (a : α) (S) : join ((a, nil), S) = (a, Seq.join S)
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem cos_ofReal_im (x : ℝ) : (cos x).im = 0
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem quot_mk_to_coe' (l : List α) : @Eq (Multiset α) (Quot.mk (· ≈ ·) l) l
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfMinpoly_map (pb : PowerBasis A S) (e : S ≃ₐ[A] S')
    (h : minpoly A pb.gen = minpoly A (pb.map e).gen) : pb.equivOfMinpoly (pb.map e) h = e
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem perm_ext_iff_of_nodup {l₁ l₂ : List α} (d₁ : Nodup l₁) (d₂ : Nodup l₂) :
    l₁ ~ l₂ ↔ ∀ a, a ∈ l₁ ↔ a ∈ l₂
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem X_pow_eq (s : σ) (n : ℕ) : (X s : MvPowerSeries σ R) ^ n = monomial R (single s n) 1
-- Mathlib/Analysis/Convex/Cone/Proper.lean
/-- The dual of the dual of a proper cone is itself. -/
@[simp]
theorem dual_dual (K : ProperCone ℝ E) : K.dual.dual = K
-- Mathlib/Algebra/Order/Group/Lattice.lean
@[to_additive]
lemma mul_sup (a b c : α) : c * (a ⊔ b) = c * a ⊔ c * b
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem forall_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (∀ h' : p, q h') ↔ q h
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem mem_nhds_left (x : α) {s : Set (α × α)} (h : s ∈ 𝓤 α) : { y : α | (x, y) ∈ s } ∈ 𝓝 x
-- Mathlib/CategoryTheory/Shift/Basic.lean
@[reassoc]
lemma shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app (m₁ m₂ m₃ : A) (X : C) :
    (shiftFunctorComm C m₁ (m₂ + m₃)).hom.app X ≫
    ((shiftFunctorAdd C m₂ m₃).hom.app X)⟦m₁⟧' =
  (shiftFunctorAdd C m₂ m₃).hom.app (X⟦m₁⟧) ≫
    ((shiftFunctorComm C m₁ m₂).hom.app X)⟦m₃⟧' ≫
    (shiftFunctorComm C m₁ m₃).hom.app (X⟦m₂⟧)
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem Measurable.div_const [MeasurableDiv G] (hf : Measurable f) (c : G) :
    Measurable fun x => f x / c
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem one_def : (1 : PerfectClosure K p) = mk K p (0, 1)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp] theorem of_symm_zero : (of R).symm (0 : HahnModule Γ R V) = 0
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem hasFTaylorSeriesUpTo_top_iff :
    HasFTaylorSeriesUpTo ∞ f p ↔ ∀ n : ℕ, HasFTaylorSeriesUpTo n f p
-- Mathlib/Data/ZMod/Basic.lean
theorem val_cast_of_lt {n : ℕ} {a : ℕ} (h : a < n) : (a : ZMod n).val = a
-- Mathlib/RingTheory/Polynomial/Vieta.lean
theorem prod_X_add_C_coeff' {σ} (s : Multiset σ) (r : σ → R) {k : ℕ} (h : k ≤ Multiset.card s) :
    (s.map fun i => X + C (r i)).prod.coeff k = (s.map r).esymm (Multiset.card s - k)
-- Mathlib/Data/List/InsertNth.lean
theorem insertNth_of_length_lt (l : List α) (x : α) (n : ℕ) (h : l.length < n) :
    insertNth n x l = l
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
@[simp]
theorem degree_scaleRoots (p : R[X]) {s : R} : degree (scaleRoots p s) = degree p
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem toEquiv_symm_fun (i : X ≅ Y) : (i.toEquiv.symm : Y → X) = i.inv
-- Mathlib/Algebra/Group/Semiconj/Basic.lean
@[to_additive (attr := simp)] lemma inv_right_iff : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.even_sub_one {p : ℕ} (hp : p.Prime) (h2 : p ≠ 2) : Even (p - 1)
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.sub (hf : ConcaveOn 𝕜 s f) (hg : ConvexOn 𝕜 s g) : ConcaveOn 𝕜 s (f - g)
-- Mathlib/Analysis/Quaternion.lean
/-- `QuaternionAlgebra.linearEquivTuple` as a `LinearIsometryEquiv`. -/
@[simps apply symm_apply]
noncomputable def linearIsometryEquivTuple : ℍ ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin 4)
-- Mathlib/Topology/Algebra/UniformRing.lean
@[deprecated UniformSpace.inseparableSetoid_ring (since := "2024-02-16")]
theorem ring_sep_quot (α : Type u) [r : CommRing α] [TopologicalSpace α] [TopologicalRing α] :
    SeparationQuotient α = (α ⧸ (⊥ : Ideal α).closure)
-- Mathlib/NumberTheory/LSeries/Convolution.lean
/-- We give an expression of the `LSeries.term` of the convolution of two functions
in terms of an a priori infinte sum over all pairs `(k, m)` with `k * m = n`
(the set we sum over is infinite when `n = 0`). This is the version needed for the
proof that `L (f ⍟ g) = L f * L g`. -/
lemma term_convolution' (f g : ℕ → ℂ) (s : ℂ) :
    term (f ⍟ g) s = fun n ↦
      ∑' (b : (fun p : ℕ × ℕ ↦ p.1 * p.2) ⁻¹' {n}), term f s b.val.1 * term g s b.val.2
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_sub_right (x y z : E) : ⟪x, y - z⟫ = ⟪x, y⟫ - ⟪x, z⟫
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem ediam_thickening_le (ε : ℝ≥0) : EMetric.diam (thickening ε s) ≤ EMetric.diam s + 2 * ε
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem neg_add_le_left_of_le_add {a b c : Int} (h : a ≤ b + c) : -b + a ≤ c
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[to_additive existing (attr := simp)]
theorem bot_div : ⊥ / t = ⊥
-- Mathlib/ModelTheory/Substructures.lean
theorem comap_iInf {ι : Sort*} (f : M →[L] N) (s : ι → L.Substructure N) :
    (iInf s).comap f = ⨅ i, (s i).comap f
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
@[simp] lemma op_zero (X Y : C) : (0 : X ⟶ Y).op = 0
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem getElem?_eq_data_get? (a : Array α) (i : Nat) : a[i]? = a.data.get? i
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- A continuous function is box-integrable with respect to any locally finite measure.

This is true for any volume with bounded variation. -/
theorem integrable_of_continuousOn [CompleteSpace E] {I : Box ι} {f : ℝⁿ → E}
    (hc : ContinuousOn f (Box.Icc I)) (μ : Measure ℝⁿ) [IsLocallyFiniteMeasure μ] :
    Integrable.{u, v, v} I l f μ.toBoxAdditive.toSMul
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem aevalTower_id :
    aevalTower (AlgHom.id S S) = (aeval : (σ → S) → MvPolynomial σ S →ₐ[S] S)
-- Mathlib/Order/Bounds/Basic.lean
theorem isGLB_iff_le_iff : IsGLB s a ↔ ∀ b, b ≤ a ↔ b ∈ lowerBounds s
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
private theorem mul_assoc' [NonUnitalSemiring R] (x y z : HahnSeries Γ R) :
    x * y * z = x * (y * z)
-- Mathlib/Data/List/Basic.lean
theorem singleton_inj {a b : α} : [a] = [b] ↔ a = b
-- Mathlib/FieldTheory/Extension.lean
theorem exists_algHom_of_adjoin_splits' (hS : adjoin L S = ⊤) :
    ∃ φ : E →ₐ[F] K, φ.comp (IsScalarTower.toAlgHom F L E) = f
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma card_stabilizer [IsGalois k K] :
    Nat.card (Stab w) = if IsUnramified k w then 1 else 2
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
lemma of_id_snd : IsPullback f (𝟙 _) (𝟙 _) f
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem UniformInducing.isComplete_range [CompleteSpace α] {f : α → β} (hf : UniformInducing f) :
    IsComplete (range f)
-- Mathlib/Order/Bounds/Basic.lean
/-- A set `s` is not bounded above if and only if for each `x` there exists `y ∈ s` such that `x`
is not greater than or equal to `y`. This version only assumes `Preorder` structure and uses
`¬(y ≤ x)`. A version for linear orders is called `not_bddAbove_iff`. -/
theorem not_bddAbove_iff' : ¬BddAbove s ↔ ∀ x, ∃ y ∈ s, ¬y ≤ x
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
/-- In a Turán-maximal graph, non-adjacency is transitive. -/
lemma not_adj_trans (h : G.IsTuranMaximal r) (hts : ¬G.Adj t s) (hsu : ¬G.Adj s u) :
    ¬G.Adj t u
-- Mathlib/Data/Finsupp/Defs.lean
theorem card_support_eq_one {f : α →₀ M} :
    card f.support = 1 ↔ ∃ a, f a ≠ 0 ∧ f = single a (f a)
-- Mathlib/RingTheory/OrzechProperty.lean
theorem injective_of_surjective_endomorphism
    (f : M →ₗ[R] M) (hf : Surjective f) : Injective f
-- Mathlib/GroupTheory/Complement.lean
theorem IsComplement'.index_eq_card (h : IsComplement' H K) : K.index = Nat.card H
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem countP_eq_countP_filter_add (l : List α) (p q : α → Bool) :
    l.countP p = (l.filter q).countP p + (l.filter fun a => !q a).countP p
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem closure_union (s t : Set M) : closure (s ∪ t) = closure s ⊔ closure t
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderGeneralization_empty : StableUnderGeneralization (∅ : Set X)
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem disjoint_iUnion_left {ι : Sort*} {s : ι → Set α} :
    Disjoint (⋃ i, s i) t ↔ ∀ i, Disjoint (s i) t
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_comp (g f : R → R) (a : A)
    (hg : ContinuousOn g (f '' σₙ R a) := by cfc_cont_tac) (hg0 : g 0 = 0 := by cfc_zero_tac)
    (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac) (hf0 : f 0 = 0 := by cfc_zero_tac)
    (ha : p a := by cfc_tac) :
    cfcₙ (g ∘ f) a = cfcₙ g (cfcₙ f a)
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_of_im_nonneg_of_ne_zero {z : ℂ} (h₁ : 0 ≤ z.im) (h₂ : z ≠ 0) :
    arg z = Real.arccos (z.re / abs z)
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem chromaticNumber_le_iff_colorable {n : ℕ} : G.chromaticNumber ≤ n ↔ G.Colorable n
-- Mathlib/Probability/Martingale/Upcrossing.lean
@[simp]
theorem upcrossingsBefore_bot [Preorder ι] [OrderBot ι] [InfSet ι] {a b : ℝ} {f : ι → Ω → ℝ}
    {ω : Ω} : upcrossingsBefore a b f ⊥ ω = ⊥
-- Mathlib/Analysis/Convex/Side.lean
theorem SSameSide.not_sOppSide {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    ¬s.SOppSide x y
-- Mathlib/Data/PNat/Factors.lean
/-- The number of occurrences of p in the factor multiset of m
 is the same as the p-adic valuation of m. -/
theorem count_factorMultiset (m : ℕ+) (p : Nat.Primes) (k : ℕ) :
    (p : ℕ+) ^ k ∣ m ↔ k ≤ m.factorMultiset.count p
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_reverse' (since := "2024-06-12")]
theorem get?_reverse' {l : List α} (i j) (h : i + j + 1 = length l) : get? l.reverse i = get? l j
-- Mathlib/Data/Seq/WSeq.lean
theorem head_terminates_of_get?_terminates {s : WSeq α} {n} :
    Terminates (get? s n) → Terminates (head s)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive comap_norm_nhdsWithin_Ioi_zero]
lemma comap_norm_nhdsWithin_Ioi_zero' : comap norm (𝓝[>] 0) = 𝓝[≠] (1 : E)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_zero_left [NormalizedGCDMonoid α] (a : α) : gcd 0 a = normalize a
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem symm_of [IsSymm α r] {a b : α} : a ≺ b → b ≺ a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem ContDiffOn.arctan (h : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => arctan (f x)) s
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
/-- A function is interval integrable with respect to a given measure `μ` on `a..b` if and
  only if it is integrable on `uIoc a b` with respect to `μ`. This is an equivalent
  definition of `IntervalIntegrable`. -/
theorem intervalIntegrable_iff : IntervalIntegrable f μ a b ↔ IntegrableOn f (Ι a b) μ
-- Mathlib/RingTheory/GradedAlgebra/Radical.lean
theorem Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem {I : Ideal A} (hI : I.IsHomogeneous 𝒜)
    (I_ne_top : I ≠ ⊤)
    (homogeneous_mem_or_mem :
      ∀ {x y : A}, Homogeneous 𝒜 x → Homogeneous 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I) :
    Ideal.IsPrime I
-- Mathlib/Algebra/Module/Basic.lean
/-- If `E` is a vector space over a division semiring `R` and has a monoid action by `α`, then that
action commutes by scalar multiplication of inverses of natural numbers in `R`. -/
theorem inv_natCast_smul_comm {α E : Type*} (R : Type*) [AddCommMonoid E] [DivisionSemiring R]
    [Monoid α] [Module R E] [DistribMulAction α E] (n : ℕ) (s : α) (x : E) :
    (n⁻¹ : R) • s • x = s • (n⁻¹ : R) • x
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem nodal_eq (s : Finset ι) (v : ι → R) : nodal s v = ∏ i ∈ s, (X - C (v i))
-- Mathlib/Data/List/GetD.lean
theorem getI_append (l l' : List α) (n : ℕ) (h : n < l.length) :
    (l ++ l').getI n = l.getI n
-- Mathlib/Topology/Separation.lean
/-- If two continuous maps are equal on `s`, then they are equal on the closure of `s`. See also
`Set.EqOn.of_subset_closure` for a more general version. -/
protected theorem Set.EqOn.closure [T2Space X] {s : Set Y} {f g : Y → X} (h : EqOn f g s)
    (hf : Continuous f) (hg : Continuous g) : EqOn f g (closure s)
-- Mathlib/RingTheory/Adjoin/Tower.lean
theorem exists_subalgebra_of_fg (hAC : (⊤ : Subalgebra A C).FG) (hBC : (⊤ : Submodule B C).FG) :
    ∃ B₀ : Subalgebra A B, B₀.FG ∧ (⊤ : Submodule B₀ C).FG
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl) The natural transformation used to define the new cocone -/
@[simps]
def γ : D ⋙ T.forget ⟶ D ⋙ T.forget ⋙ ↑T
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measure_Ioc_lt_top : μ (Ioc a b) < ∞
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
@[simp]
theorem id_hom' (M : Bimod A B) : (𝟙 M : Hom M M).hom = 𝟙 M.X
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- Continuously polynomial everywhere implies continuous -/
theorem CPolynomialOn.continuous {f : E → F} (fa : CPolynomialOn 𝕜 f univ) : Continuous f
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_bound {x : ℂ} (hx : abs x ≤ 1) {n : ℕ} (hn : 0 < n) :
    abs (exp x - ∑ m ∈ range n, x ^ m / m.factorial) ≤
      abs x ^ n * ((n.succ : ℝ) * (n.factorial * n : ℝ)⁻¹)
-- Mathlib/ModelTheory/FinitelyGenerated.lean
/-- An equivalent expression of `Structure.FG` in terms of `Set.Finite` instead of `Finset`. -/
theorem fg_iff : FG L M ↔ ∃ S : Set M, S.Finite ∧ closure L S = (⊤ : L.Substructure M)
-- Mathlib/Analysis/Complex/Basic.lean
theorem restrictScalars_one_smulRight (x : ℂ) :
    ContinuousLinearMap.restrictScalars ℝ ((1 : ℂ →L[ℂ] ℂ).smulRight x : ℂ →L[ℂ] ℂ) =
    x • (1 : ℂ →L[ℝ] ℂ)
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive (attr := simp)]
lemma smul_eq_mul (α : Type*) [Mul α] {a a' : α} : a • a' = a * a'
-- Mathlib/GroupTheory/Schreier.lean
theorem closure_mul_image_mul_eq_top
    (hR : R ∈ rightTransversals (H : Set G)) (hR1 : (1 : G) ∈ R) (hS : closure S = ⊤) :
    (closure ((R * S).image fun g => g * (toFun hR g : G)⁻¹)) * R = ⊤
-- Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean
theorem pushoutInl_eq_pushout_inr (F : WalkingParallelPair ⥤ C) :
    pushoutInl F = pushout.inr _ _
-- Mathlib/Topology/Homotopy/Basic.lean
@[ext]
theorem ext {F G : HomotopyWith f₀ f₁ P} (h : ∀ x, F x = G x) : F = G
-- Mathlib/Data/NNReal/Basic.lean
theorem coe_sub_def {r p : ℝ≥0} : ↑(r - p) = max (r - p : ℝ) 0
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem coe_copy (S : IntermediateField K L) (s : Set L) (hs : s = ↑S) :
    (S.copy s hs : Set L) = s
-- Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean
/-- A slight variant of `hasFDerivAt_of_tendstoLocallyUniformlyOn` with the assumption stated
in terms of `DifferentiableOn` rather than `HasFDerivAt`. This makes a few proofs nicer in
complex analysis where holomorphicity is assumed but the derivative is not known a priori. -/
theorem hasFDerivAt_of_tendsto_locally_uniformly_on' [NeBot l] {s : Set E} (hs : IsOpen s)
    (hf' : TendstoLocallyUniformlyOn (fderiv 𝕜 ∘ f) g' l s) (hf : ∀ n, DifferentiableOn 𝕜 (f n) s)
    (hfg : ∀ x ∈ s, Tendsto (fun n => f n x) l (𝓝 (g x))) (hx : x ∈ s) :
    HasFDerivAt g (g' x) x
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem map_id (s : AffineSubspace k P₁) : s.map (AffineMap.id k P₁) = s
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
@[simp] theorem sub_eval (l₁ l₂ : LinearCombo) (v : Coeffs) :
    (l₁ - l₂).eval v = l₁.eval v - l₂.eval v
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_lt_rpow_of_exponent_neg {x y z : ℝ} (hy : 0 < y) (hxy : y < x) (hz : z < 0) :
    x ^ z < y ^ z
-- Mathlib/Algebra/Algebra/Tower.lean
theorem of_compHom : letI := MulAction.compHom M (algebraMap R A : R →* A); IsScalarTower R A M
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] protected theorem div_self {a : Int} (H : a ≠ 0) : a.div a = 1
-- Mathlib/Data/Int/GCD.lean
theorem gcd_mul_left (i j k : ℤ) : gcd (i * j) (i * k) = natAbs i * gcd j k
-- Mathlib/CategoryTheory/EpiMono.lean
/-- A split epi which is mono is an iso. -/
theorem isIso_of_mono_of_isSplitEpi {X Y : C} (f : X ⟶ Y) [Mono f] [IsSplitEpi f] : IsIso f
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem leadingCoeff_map' (hf : Injective f) (p : R[X]) :
    leadingCoeff (p.map f) = f (leadingCoeff p)
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMonoOn.image_Ico_subset (h : StrictMonoOn f (Icc a b)) :
    f '' Ico a b ⊆ Ico (f a) (f b)
-- Mathlib/MeasureTheory/Measure/Dirac.lean
theorem restrict_dirac [MeasurableSingletonClass α] [Decidable (a ∈ s)] :
    (Measure.dirac a).restrict s = if a ∈ s then Measure.dirac a else 0
-- Mathlib/CategoryTheory/Generator.lean
theorem isSeparator_sigma {β : Type w} (f : β → C) [HasCoproduct f] :
    IsSeparator (∐ f) ↔ IsSeparating (Set.range f)
-- .lake/packages/batteries/Batteries/Data/Array/Monadic.lean
theorem size_modifyM [Monad m] [LawfulMonad m] (a : Array α) (i : Nat) (f : α → m α) :
    SatisfiesM (·.size = a.size) (a.modifyM i f)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_smul {E} [NormedAddCommGroup E] [NormedField 𝕜] [NormedSpace 𝕜 E]
    [NormedSpace ℝ E] [NormedSpace 𝕜 F] (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) {f : α →ₛ E} (hf : Integrable f μ) :
    setToSimpleFunc T (c • f) = c • setToSimpleFunc T f
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem card [Fintype G] : Fintype.card (vectorsProdEqOne G n) = Fintype.card G ^ (n - 1)
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Define a morphism between left extensions by cancelling the whiskered identities. -/
@[simps! right]
def whiskerIdCancel
    (s : LeftExtension f (g ≫ 𝟙 c)) {t : LeftExtension f g} (τ : s ⟶ t.whisker (𝟙 c)) :
    s.ofCompId ⟶ t
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
theorem derivativeFun_one : derivativeFun (1 : R⟦X⟧) = 0
-- Mathlib/RingTheory/Localization/AsSubring.lean
theorem mem_range_mapToFractionRing_iff_ofField (B : Type*) [CommRing B] [Algebra A B]
    [IsLocalization S B] (x : K) :
    x ∈ (mapToFractionRing K S B hS).range ↔
      ∃ (a s : A) (_ : s ∈ S), x = algebraMap A K a * (algebraMap A K s)⁻¹
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_add : (p + q).support ⊆ p.support ∪ q.support
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem compl_union_self (s : Set α) : sᶜ ∪ s = univ
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toDualBotEquiv_symm_coe [LE α] (a : α) :
    WithTop.toDualBotEquiv.symm (toDual (a : WithBot α)) = ↑(toDual a)
-- Mathlib/MeasureTheory/Group/MeasurableEquiv.lean
@[simp]
theorem coe_mulRight₀ {g : G₀} (hg : g ≠ 0) : ⇑(mulRight₀ g hg) = fun x => x * g
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem untrop_prod [AddCommMonoid R] (s : Finset S) (f : S → Tropical R) :
    untrop (∏ i ∈ s, f i) = ∑ i ∈ s, untrop (f i)
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp] theorem IsOrtho.inr_inl {Q₁ : QuadraticMap R M₁ P} {Q₂ : QuadraticMap R M₂ P}
    (m₁ : M₁) (m₂ : M₂) :
    (Q₁.prod Q₂).IsOrtho (0, m₂) (m₁, 0)
-- Mathlib/Data/Int/Defs.lean
protected theorem neg_eq_neg {a b : ℤ} (h : -a = -b) : a = b
-- Mathlib/CategoryTheory/Abelian/RightDerived.lean
@[reassoc]
lemma toRightDerivedZero'_naturality {X Y : C} (f : X ⟶ Y)
    (P : InjectiveResolution X) (Q : InjectiveResolution Y)
    (φ : P.cocomplex ⟶ Q.cocomplex) (comm : P.ι.f 0 ≫ φ.f 0 = f ≫ Q.ι.f 0)
    (F : C ⥤ D) [F.Additive] :
    F.map f ≫ Q.toRightDerivedZero' F =
      P.toRightDerivedZero' F ≫
        HomologicalComplex.cyclesMap ((F.mapHomologicalComplex _).map φ) 0
-- Mathlib/Data/Nat/Digits.lean
/-- **Divisibility by 3 Rule** -/
theorem three_dvd_iff (n : ℕ) : 3 ∣ n ↔ 3 ∣ (digits 10 n).sum
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma coe_sub (z₁ z₂ : Cocycle F G n) :
    (↑(z₁ - z₂) : Cochain F G n) = (z₁ : Cochain F G n) - (z₂ : Cochain F G n)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_comp (g : InfHom βᵒᵈ γᵒᵈ) (f : InfHom αᵒᵈ βᵒᵈ) :
    SupHom.dual.symm (g.comp f) =
      (SupHom.dual.symm g).comp (SupHom.dual.symm f)
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem mk_div (a b : G) : ((a / b : G) : Q) = a / b
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem spectralRadius_le_nnnorm [NormOneClass A] (a : A) : spectralRadius 𝕜 a ≤ ‖a‖₊
-- Mathlib/Data/List/Basic.lean
@[simp] theorem head!_cons [Inhabited α] (a : α) (l : List α) : head! (a :: l) = a
-- Mathlib/Algebra/BigOperators/Group/List.lean
lemma prod_int_mod (l : List ℤ) (n : ℤ) : l.prod % n = (l.map (· % n)).prod % n
-- Mathlib/Algebra/Order/Sub/Defs.lean
protected theorem le_tsub_of_add_le_right (hb : AddLECancellable b) (h : a + b ≤ c) : a ≤ c - b
-- Mathlib/Data/Fintype/Card.lean
theorem set_fintype_card_le_univ [Fintype α] (s : Set α) [Fintype s] :
    Fintype.card s ≤ Fintype.card α
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem valuation_one : valuation (1 : ℤ_[p]) = 0