ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma GrowsPolynomially.add {f g : ℝ → ℝ} (hf : GrowsPolynomially f)
    (hg : GrowsPolynomially g) (hf' : 0 ≤ᶠ[atTop] f) (hg' : 0 ≤ᶠ[atTop] g) :
    GrowsPolynomially fun x => f x + g x
-- Mathlib/Order/Filter/Basic.lean
@[trans]
theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h
-- Mathlib/GroupTheory/Perm/Basic.lean
@[norm_cast] lemma coe_pow (f : Perm α) (n : ℕ) : ⇑(f ^ n) = f^[n]
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem cos_arctan_pos (x : ℝ) : 0 < cos (arctan x)
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_multiset_sum (s : Multiset ℝ) : exp s.sum = (s.map exp).prod
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem fundamentalDomain_reindex {ι' : Type*} (e : ι ≃ ι') :
    fundamentalDomain (b.reindex e) = fundamentalDomain b
-- Mathlib/Order/Filter/ENNReal.lean
theorem limsup_add_le [CountableInterFilter f] (u v : α → ℝ≥0∞) :
    f.limsup (u + v) ≤ f.limsup u + f.limsup v
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem IsOpen.uniqueMDiffOn (hs : IsOpen s) : UniqueMDiffOn I s
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_pair_eq_one_or_two : ({a,b} : Finset α).card = 1 ∨ ({a,b} : Finset α).card = 2
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- If `k.right` is a monomorphism, then `k` is a monomorphism. In other words, `Under.forget X`
reflects epimorphisms.
The converse does not hold without additional assumptions on the underlying category, see
`CategoryTheory.Under.mono_right_of_mono`.
-/
theorem mono_of_mono_right {f g : Under X} (k : f ⟶ g) [hk : Mono k.right] : Mono k
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem _root_.integral_cexp_quadratic (hb : b.re < 0) (c d : ℂ) :
    ∫ x : ℝ, cexp (b * x ^ 2 + c * x + d) = (π / -b) ^ (1 / 2 : ℂ) * cexp (d - c^2 / (4 * b))
-- Mathlib/Topology/Inseparable.lean
lemma specializingMap_iff_isClosed_image_closure_singleton (hf : Continuous f) :
    SpecializingMap f ↔ ∀ x, IsClosed (f '' closure {x})
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
lemma in₀₂_iff' :
    (graph t).Adj (in₀ a) (in₂ c) ↔ ∃ x : α × β × γ, x ∈ t ∧ x.1 = a ∧ x.2.2 = c
-- Mathlib/Data/Set/Image.lean
theorem preimage_coe_nonempty {s t : Set α} :
    (((↑) : s → α) ⁻¹' t).Nonempty ↔ (s ∩ t).Nonempty
-- Mathlib/Data/Nat/Choose/Bounds.lean
theorem choose_le_pow (r n : ℕ) : (n.choose r : α) ≤ (n ^ r : α) / r !
-- Mathlib/RepresentationTheory/Rep.lean
theorem trivial_def {V : Type u} [AddCommGroup V] [Module k V] (g : G) (v : V) :
    (trivial k G V).ρ g v = v
-- Mathlib/Computability/Primrec.lean
theorem swap' {f} (hf : Nat.Primrec (unpaired f)) : Nat.Primrec (unpaired (swap f))
-- Mathlib/Algebra/Algebra/Operations.lean
theorem prod_span_singleton {ι : Type*} (s : Finset ι) (x : ι → A) :
    (∏ i ∈ s, span R ({x i} : Set A)) = span R {∏ i ∈ s, x i}
-- Mathlib/Data/Multiset/Nodup.lean
@[simp]
theorem count_eq_one_of_mem [DecidableEq α] {a : α} {s : Multiset α} (d : Nodup s) (h : a ∈ s) :
    count a s = 1
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_extend : UniformContinuous (pkg.extend f)
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem mem_sSup_of_mem {S : Set (Submodule R M)} {s : Submodule R M} (hs : s ∈ S) :
    ∀ {x : M}, x ∈ s → x ∈ sSup S
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem infinite_pigeonhole_set {β α : Type u} {s : Set β} (f : s → α) (θ : Cardinal)
    (hθ : θ ≤ #s) (h₁ : ℵ₀ ≤ θ) (h₂ : #α < θ.ord.cof) :
    ∃ (a : α) (t : Set β) (h : t ⊆ s), θ ≤ #t ∧ ∀ ⦃x⦄ (hx : x ∈ t), f ⟨x, h hx⟩ = a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem mem_Lp_of_ae_bound [IsFiniteMeasure μ] {f : α →ₘ[μ] E} (C : ℝ) (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    f ∈ Lp E p μ
-- Mathlib/Topology/Homotopy/Path.lean
@[refl]
theorem refl (p : Path x₀ x₁) : p.Homotopic p
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
@[simp] lemma to_WithLowerSet_symm_eq : (@toLowerSet α).symm = ofLowerSet
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Expressing locally uniform convergence on a set using `edist`. -/
theorem tendstoLocallyUniformlyOn_iff {ι : Type*} [TopologicalSpace β] {F : ι → β → α} {f : β → α}
    {p : Filter ι} {s : Set β} :
    TendstoLocallyUniformlyOn F f p s ↔
      ∀ ε > 0, ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ n in p, ∀ y ∈ t, edist (f y) (F n y) < ε
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma GrowsPolynomially.zpow (p : ℤ) (hf : GrowsPolynomially f)
    (hf_nonneg : ∀ᶠ x in atTop, 0 ≤ f x) : GrowsPolynomially fun x => (f x) ^ p
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem _root_.Finset.nullMeasurableSet_biInter {f : ι → Set α} (s : Finset ι)
    (h : ∀ b ∈ s, NullMeasurableSet (f b) μ) : NullMeasurableSet (⋂ b ∈ s, f b) μ
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem dvd_rfl : ∀ {a : α}, a ∣ a
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
@[simp]
theorem ordConnectedComponent_empty : ordConnectedComponent ∅ x = ∅
-- Mathlib/Topology/Maps/Basic.lean
theorem isOpenMap_iff (hg : OpenEmbedding g) :
    IsOpenMap f ↔ IsOpenMap (g ∘ f)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma eq_zero_of_zpow_eq_zero {n : ℤ} : a ^ n = 0 → a = 0
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.card_eq_card_of_base (hB₁ : M.Base B₁) (hB₂ : M.Base B₂) :
    B₁.encard = B₂.encard
-- Mathlib/Topology/Basic.lean
theorem closure_image_closure (h : Continuous f) :
    closure (f '' closure s) = closure (f '' s)
-- Mathlib/Topology/MetricSpace/Ultra/Basic.lean
lemma ball_eq_of_mem {x y : X} {r : ℝ} (h : y ∈ ball x r) : ball x r = ball y r
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem isLimit_iff (c : Cone F) :
    Nonempty (IsLimit c) ↔ ∀ s ∈ F.sections, ∃! x : c.pt, ∀ j, c.π.app j x = s j
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- Monotone convergence for a supremum over a directed family and indexed by a countable type. -/
theorem lintegral_iSup_directed [Countable β] {f : β → α → ℝ≥0∞} (hf : ∀ b, AEMeasurable (f b) μ)
    (h_directed : Directed (· ≤ ·) f) : ∫⁻ a, ⨆ b, f b a ∂μ = ⨆ b, ∫⁻ a, f b a ∂μ
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_pos_lt_iff_one_lt_mul' (ha : 0 < a) : a⁻¹ < b ↔ 1 < a * b
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
theorem seminormFromConst_def (x : R) :
    seminormFromConst hf1 hc hpm x = seminormFromConst' hf1 hc hpm x
-- Mathlib/MeasureTheory/Integral/CircleTransform.lean
theorem integral_circleTransform (f : ℂ → E) :
    (∫ θ : ℝ in (0)..2 * π, circleTransform R z w f θ) =
      (2 * ↑π * I)⁻¹ • ∮ z in C(z, R), (z - w)⁻¹ • f z
-- Mathlib/Data/Fin/Basic.lean
theorem le_rev_iff {i j : Fin n} : i ≤ rev j ↔ j ≤ rev i
-- Mathlib/Data/Int/GCD.lean
theorem gcd_pos_of_ne_zero_left {i : ℤ} (j : ℤ) (hi : i ≠ 0) : 0 < gcd i j
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem iUnion_spanningSets (μ : Measure α) [SigmaFinite μ] : ⋃ i : ℕ, spanningSets μ i = univ
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
private theorem add_csize_pos : 0 < i + Char.utf8Size c
-- Mathlib/Order/Filter/Basic.lean
theorem comap_neBot {f : Filter β} {m : α → β} (hm : ∀ t ∈ f, ∃ a, m a ∈ t) : NeBot (comap m f)
-- Mathlib/Topology/Bases.lean
/-- In a separable space, a family of nonempty disjoint open sets is countable. -/
theorem _root_.Set.PairwiseDisjoint.countable_of_isOpen [SeparableSpace α] {ι : Type*}
    {s : ι → Set α} {a : Set ι} (h : a.PairwiseDisjoint s) (ho : ∀ i ∈ a, IsOpen (s i))
    (hne : ∀ i ∈ a, (s i).Nonempty) : a.Countable
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem divInt_num_den (z : d ≠ 0) (h : n /. d = ⟨n', d', z', c⟩) :
    ∃ m, m ≠ 0 ∧ n = n' * m ∧ d = d' * m
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem range_mfderiv_eq_univ {x : M} (hx : x ∈ e.source) : range (mfderiv I I' e x) = univ
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem Injective.of_comp_iff (hf : Injective f) (g : γ → α) :
    Injective (f ∘ g) ↔ Injective g
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
protected theorem rename (hφ : φ.IsSymmetric) (e : σ ≃ τ) : (rename e φ).IsSymmetric
-- Mathlib/RingTheory/Multiplicity.lean
theorem finite_nat_iff {a b : ℕ} : Finite a b ↔ a ≠ 1 ∧ 0 < b
-- Mathlib/Order/Interval/Set/Basic.lean
theorem mem_Ioc_of_Ioo (h : x ∈ Ioo a b) : x ∈ Ioc a b
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp]
theorem map_map {M : DMatrix m n α} {β : m → n → Type w} {γ : m → n → Type z}
    {f : ∀ ⦃i j⦄, α i j → β i j} {g : ∀ ⦃i j⦄, β i j → γ i j} :
    (M.map f).map g = M.map fun i j x => g (f x)
-- Mathlib/Order/Filter/Cofinite.lean
/-- If `α` is a preorder with no maximal element, then `atTop ≤ cofinite`. -/
theorem atTop_le_cofinite [Preorder α] [NoMaxOrder α] : (atTop : Filter α) ≤ cofinite
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwise_iff_exists_forall [Nonempty ι] (s : Set α) (f : α → ι) {r : ι → ι → Prop}
    [IsEquiv ι r] : s.Pairwise (r on f) ↔ ∃ z, ∀ x ∈ s, r (f x) z
-- Mathlib/Data/Rat/Lemmas.lean
theorem pnatDen_eq_iff_den_eq {x : ℚ} {n : ℕ+} : x.pnatDen = n ↔ x.den = ↑n
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `vectorSpan` of two points is the span of their difference. -/
theorem vectorSpan_pair (p₁ p₂ : P) : vectorSpan k ({p₁, p₂} : Set P) = k ∙ p₁ -ᵥ p₂
-- Mathlib/Combinatorics/SetFamily/FourFunctions.lean
/-- The **Holley Inequality**. -/
lemma holley (hμ₀ : 0 ≤ μ) (hf : 0 ≤ f) (hg : 0 ≤ g) (hμ : Monotone μ)
    (hfg : ∑ a, f a = ∑ a, g a) (h : ∀ a b, f a * g b ≤ f (a ⊓ b) * g (a ⊔ b)) :
    ∑ a, μ a * f a ≤ ∑ a, μ a * g a
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem limit.lift_pre (c : Cone F) :
    limit.lift F c ≫ limit.pre F E = limit.lift (E ⋙ F) (c.whisker E)
-- Mathlib/Algebra/Polynomial/Roots.lean
lemma eq_zero_of_natDegree_lt_card_of_eval_eq_zero {R} [CommRing R] [IsDomain R]
    (p : R[X]) {ι} [Fintype ι] {f : ι → R} (hf : Function.Injective f)
    (heval : ∀ i, p.eval (f i) = 0) (hcard : natDegree p < Fintype.card ι) : p = 0
-- Mathlib/Topology/VectorBundle/Hom.lean
theorem continuousLinearMapCoordChange_apply (b : B)
    (hb : b ∈ e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet)) (L : F₁ →SL[σ] F₂) :
    continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂' b L =
      (continuousLinearMap σ e₁' e₂' ⟨b, (continuousLinearMap σ e₁ e₂).symm b L⟩).2
-- Mathlib/Data/Bool/Count.lean
theorem length_div_two_le_count_bool (hl : Chain' (· ≠ ·) l) (b : Bool) :
    length l / 2 ≤ count b l
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem add_left_aux4' (y z : E) :
    (‖2 • z + y‖ * ‖2 • z + y‖ - ‖y - 2 • z‖ * ‖y - 2 • z‖) / 2 =
    ‖y + z‖ * ‖y + z‖ - ‖y - z‖ * ‖y - z‖
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem someExistsOneDivLT_measurableSet : MeasurableSet (someExistsOneDivLT s i)
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem constantCoeff_one : constantCoeff R 1 = 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_iSup (f : ι → G.Subgraph) (v : V) :
    (⨆ i, f i).neighborSet v = ⋃ i, (f i).neighborSet v
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_congr_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s)
    (f : α → E) : setToFun μ T hT f = setToFun μ T' hT' f
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem RingHom.comp_id_commSemiringCat
    {G : CommSemiRingCat.{u}} {H : Type u} [CommSemiring H] (f : G →+* H) : f.comp (𝟙 G) = f
-- Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean
lemma distinguished_cocone_triangle {X Y : HomotopyCategory C (ComplexShape.up ℤ)} (f : X ⟶ Y) :
    ∃ (Z : HomotopyCategory C (ComplexShape.up ℤ)) (g : Y ⟶ Z) (h : Z ⟶ X⟦1⟧),
      Triangle.mk f g h ∈ distinguishedTriangles C
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_restrict' (ht : MeasurableSet t) :
    (μ.restrict t).restrict s = μ.restrict (s ∩ t)
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] lemma obj_carrier (M : FGModuleCat R) : M.obj.carrier = M.carrier
-- Mathlib/Data/NNRat/Lemmas.lean
@[simp]
lemma num_div_den (q : ℚ≥0) : (q.num : ℚ≥0) / q.den = q
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem differentiableWithinAt_arccos_Iic {x : ℝ} :
    DifferentiableWithinAt ℝ arccos (Iic x) x ↔ x ≠ 1
-- Mathlib/Algebra/Algebra/Bilinear.lean
@[simp]
theorem mulLeft_zero_eq_zero : mulLeft R (0 : A) = 0
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem deleteVerts_adj {u v : V} :
    (G'.deleteVerts s).Adj u v ↔ u ∈ G'.verts ∧ ¬u ∈ s ∧ v ∈ G'.verts ∧ ¬v ∈ s ∧ G'.Adj u v
-- Mathlib/Tactic/Sat/FromLRAT.lean
/-- `v.satisfies_fmla f` asserts that formula `f` is satisfied by the valuation.
A formula is satisfied if all clauses in it are satisfied. -/
structure Valuation.satisfies_fmla (v : Valuation) (f : Fmla) : Prop where
  prop : ∀ c, c ∈ f → v.satisfies c
-- Mathlib/Data/Seq/Parallel.lean
theorem parallel_congr_left {S T : WSeq (Computation α)} {a} (h1 : ∀ s ∈ S, s ~> a)
    (H : S.LiftRel Equiv T) : parallel S ~ parallel T
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[reassoc]
theorem coevaluation_comp_rightAdjointMate {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) :
    η_ Y (Yᘁ) ≫ _ ◁ (fᘁ) = η_ _ _ ≫ f ▷ _
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_inf_sup' (f : ι → α) (g : κ → α) :
    s.sup' hs f ⊓ t.sup' ht g = (s ×ˢ t).sup' (hs.product ht) fun i => f i.1 ⊓ g i.2
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_iff_Iio_subset : IsLowerSet s ↔ ∀ ⦃a⦄, a ∈ s → Iio a ⊆ s
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem add_def (α β : Type u) : #α + #β = #(α ⊕ β)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem L1.norm_of_fun_eq_integral_norm {f : α → H} (hf : Integrable f μ) :
    ‖hf.toL1 f‖ = ∫ a, ‖f a‖ ∂μ
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
@[simp]
theorem dist_toBCF_eq_dist {f g : C₀(α, β)} : dist f.toBCF g.toBCF = dist f g
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem hasStrictDerivAt_neg : HasStrictDerivAt Neg.neg (-1) x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negAddY_eq' {P Q : Fin 3 → R} : W'.negAddY P Q * (P z * Q z) ^ 3 =
    (P y * Q z ^ 3 - Q y * P z ^ 3) * (W'.addX P Q * (P z * Q z) ^ 2 - P x * Q z ^ 2 * addZ P Q ^ 2)
      + P y * Q z ^ 3 * addZ P Q ^ 3
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c
-- Mathlib/Data/PNat/Interval.lean
theorem card_fintype_uIcc : Fintype.card (Set.uIcc a b) = (b - a : ℤ).natAbs + 1
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[simp]
theorem subgraphOfAdj_connected {v w : V} (hvw : G.Adj v w) : (G.subgraphOfAdj hvw).Connected
-- Mathlib/Analysis/Convex/Star.lean
/-- The translation of a star-convex set is also star-convex. -/
theorem StarConvex.preimage_add_right (hs : StarConvex 𝕜 (z + x) s) :
    StarConvex 𝕜 x ((fun x => z + x) ⁻¹' s)
-- Mathlib/Data/DFinsupp/Basic.lean
theorem support_single_subset {i : ι} {b : β i} : (single i b).support ⊆ {i}
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem coeff_X_mul_zero (p : R[X]) : coeff (X * p) 0 = 0
-- Mathlib/Topology/List.lean
theorem tendsto_nhds {β : Type*} {f : List α → β} {r : List α → Filter β}
    (h_nil : Tendsto f (pure []) (r []))
    (h_cons :
      ∀ l a,
        Tendsto f (𝓝 l) (r l) →
          Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a::l))) :
    ∀ l, Tendsto f (𝓝 l) (r l)
-- Mathlib/Order/Filter/Pi.lean
theorem le_pi {g : Filter (∀ i, α i)} : g ≤ pi f ↔ ∀ i, Tendsto (eval i) g (f i)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- Given a fork over `∏ᶜ I.left ⇉ ∏ᶜ I.right`, we may obtain a multifork. -/
@[simps pt]
noncomputable def ofPiFork (c : Fork I.fstPiMap I.sndPiMap) : Multifork I
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma isEllSequence_id : IsEllSequence id
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem smul_apply (f : M [⋀^ι]→L[A] N) (c : R') (v : ι → M) : (c • f) v = c • f v
-- Mathlib/CategoryTheory/Sites/Localization.lean
lemma W_toSheafify (P : Cᵒᵖ ⥤ A) : J.W (toSheafify J P)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem modifyNthTail_id : ∀ n (l : List α), l.modifyNthTail id n = l
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem lt_length (i : Fin c.length) : (i : ℕ) + 1 < c.boundaries.card
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@[deprecated (since := "2024-04-14")]
theorem coe_zero : ⇑(0 : BilinForm R M) = 0
-- Mathlib/Probability/ProbabilityMassFunction/Binomial.lean
/-- The binomial distribution on one coin is the bernoully distribution. -/
theorem binomial_one_eq_bernoulli (p : ℝ≥0∞) (h : p ≤ 1) :
    binomial p h 1 = (bernoulli p h).map (cond · 1 0)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem nnnorm_eq [NumberField K] (x : K) :
    ‖canonicalEmbedding K x‖₊ = Finset.univ.sup (fun φ : K →+* ℂ => ‖φ x‖₊)
-- Mathlib/Data/Set/Image.lean
@[deprecated forall_mem_image (since := "2024-02-21")]
theorem mem_image_elim_on {f : α → β} {s : Set α} {C : β → Prop} {y : β} (h_y : y ∈ f '' s)
    (h : ∀ x : α, x ∈ s → C (f x)) : C y
-- Mathlib/MeasureTheory/Measure/EverywherePos.lean
lemma everywherePosSubset_subset (μ : Measure α) (s : Set α) : μ.everywherePosSubset s ⊆ s
-- Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean
theorem isIntegral_algebraMap {x : R} : IsIntegral R (algebraMap R A x)
-- Mathlib/LinearAlgebra/QuadraticForm/Dual.lean
theorem separatingLeft_dualProd :
    (dualProd R M).SeparatingLeft ↔ Function.Injective (Module.Dual.eval R M)
-- Mathlib/Algebra/Group/Opposite.lean
@[simp] lemma unop_zpow (x : αᵐᵒᵖ) (z : ℤ) : unop (x ^ z) = unop x ^ z
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem prod_map_id {α β : TypeVec n} : (@TypeVec.id _ α ⊗' @TypeVec.id _ β) = id
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem eq_of_comp_left_eq {f g : X ⟶ Y} (w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h) :
    f = g
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem BilinForm.mul_toMatrix'_mul (B : BilinForm R₂ (n → R₂)) (M : Matrix o n R₂)
    (N : Matrix n o R₂) : M * BilinForm.toMatrix' B * N =
      BilinForm.toMatrix' (B.comp (Matrix.toLin' Mᵀ) (Matrix.toLin' N))
-- Mathlib/Data/Fintype/Basic.lean
@[simp, norm_cast]
theorem coe_univ : ↑(univ : Finset α) = (Set.univ : Set α)
-- Mathlib/Logic/Small/Basic.lean
/-- This can be seen as a version of `small_of_surjective` in which the function `f` doesn't
    actually land in `β` but in some larger type `γ` related to `β` via an injective function `g`.
    -/
theorem small_of_injective_of_exists {α : Type v} {β : Type w} {γ : Type v'} [Small.{u} α]
    (f : α → γ) {g : β → γ} (hg : Function.Injective g) (h : ∀ b : β, ∃ a : α, f a = g b) :
    Small.{u} β
-- Mathlib/Order/Lattice.lean
@[simp]
theorem inf_lt_right : a ⊓ b < b ↔ ¬b ≤ a
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem toIterator : ∀ {s}, ValidFor l m r s → s.toIterator.ValidFor l.reverse (m ++ r)
-- Mathlib/Data/Int/GCD.lean
theorem gcd_div_gcd_div_gcd {i j : ℤ} (H : 0 < gcd i j) : gcd (i / gcd i j) (j / gcd i j) = 1
-- Mathlib/Data/Finset/Basic.lean
@[norm_cast]
theorem coe_pair {a b : α} : (({a, b} : Finset α) : Set α) = {a, b}
-- Mathlib/Order/Heyting/Regular.lean
@[simp, norm_cast]
theorem coe_toRegular (a : α) : (toRegular a : α) = aᶜᶜ
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- Induction principle for the algebra generated by a set `s`: show that `p x y` holds for any
`x y ∈ adjoin R s` given that it holds for `x y ∈ s` and that it satisfies a number of
natural properties. -/
@[elab_as_elim]
theorem adjoin_induction₂ {p : A → A → Prop} {a b : A} (ha : a ∈ adjoin R s) (hb : b ∈ adjoin R s)
    (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (Halg : ∀ r₁ r₂, p (algebraMap R A r₁) (algebraMap R A r₂))
    (Halg_left : ∀ (r), ∀ x ∈ s, p (algebraMap R A r) x)
    (Halg_right : ∀ (r), ∀ x ∈ s, p x (algebraMap R A r))
    (Hadd_left : ∀ x₁ x₂ y, p x₁ y → p x₂ y → p (x₁ + x₂) y)
    (Hadd_right : ∀ x y₁ y₂, p x y₁ → p x y₂ → p x (y₁ + y₂))
    (Hmul_left : ∀ x₁ x₂ y, p x₁ y → p x₂ y → p (x₁ * x₂) y)
    (Hmul_right : ∀ x y₁ y₂, p x y₁ → p x y₂ → p x (y₁ * y₂)) : p a b
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesAt.neg (hf : HasFiniteFPowerSeriesAt f pf x n) :
    HasFiniteFPowerSeriesAt (-f) (-pf) x n
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Minkowski inequality**: the `L_p` seminorm of the infinite sum of two vectors is less than or
equal to the infinite sum of the `L_p`-seminorms of the summands, if these infinite sums both
exist. A version for `NNReal`-valued functions. For an alternative version, convenient if the
infinite sums are already expressed as `p`-th powers, see `Lp_add_le_hasSum_of_nonneg`. -/
theorem Lp_add_le_tsum {f g : ι → ℝ≥0} {p : ℝ} (hp : 1 ≤ p) (hf : Summable fun i => f i ^ p)
    (hg : Summable fun i => g i ^ p) :
    (Summable fun i => (f i + g i) ^ p) ∧
      (∑' i, (f i + g i) ^ p) ^ (1 / p) ≤
        (∑' i, f i ^ p) ^ (1 / p) + (∑' i, g i ^ p) ^ (1 / p)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- The additive map forgetting that a bounded continuous function is bounded. -/
@[simps]
def toContinuousMapAddHom : (α →ᵇ β) →+ C(α, β)
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_insert_update {x : α} {t : Finset α} (f : α → Set β) {s : Set β} (hx : x ∉ t) :
    ⋃ i ∈ insert x t, @update _ _ _ f x s i = s ∪ ⋃ i ∈ t, f i
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
@[fun_prop]
theorem continuousAt_rpow_const (x : ℝ) (q : ℝ) (h : x ≠ 0 ∨ 0 ≤ q) :
    ContinuousAt (fun x : ℝ => x ^ q) x
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp]
theorem leibniz : X (f * f') = f • X f' + f' • X f
-- Mathlib/LinearAlgebra/PerfectPairing.lean
theorem reflexive_right : IsReflexive R N
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_add_cancel_of_le (h : a ≤ b) : b - a + a = b
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
@[norm_cast, simp]
theorem coe_zero : ((0 : P →ᴬ[R] W) : P → W) = 0
-- Mathlib/Topology/Specialization.lean
@[simp] lemma isOpen_toEquiv_preimage [AlexandrovDiscrete α] {s : Set (Specialization α)} :
  IsOpen (toEquiv ⁻¹' s) ↔ IsUpperSet s
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
protected theorem MeasurableSet.pi {s : Set δ} {t : ∀ i : δ, Set (π i)} (hs : s.Countable)
    (ht : ∀ i ∈ s, MeasurableSet (t i)) : MeasurableSet (s.pi t)
-- Mathlib/Algebra/Associated/Basic.lean
theorem pow_injective_of_not_unit [CancelCommMonoidWithZero α] {q : α} (hq : ¬IsUnit q)
    (hq' : q ≠ 0) : Function.Injective fun n : ℕ => q ^ n
-- Mathlib/Data/Finset/Pointwise.lean
theorem mul_zero_subset (s : Finset α) : s * 0 ⊆ 0
-- Mathlib/Data/Int/NatPrime.lean
theorem not_prime_of_int_mul {a b : ℤ} {c : ℕ} (ha : a.natAbs ≠ 1) (hb : b.natAbs ≠ 1)
    (hc : a * b = (c : ℤ)) : ¬Nat.Prime c
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem toLinearMap_symm_comp_eq (f : M₃ →ₛₗ[σ₃₁] M₁) (g : M₃ →ₛₗ[σ₃₂] M₂) :
    e₁₂.symm.toLinearMap.comp g = f ↔ g = e₁₂.toLinearMap.comp f
-- Mathlib/RingTheory/TensorProduct/MvPolynomial.lean
@[simp]
lemma algebraTensorAlgEquiv_symm_monomial (m : σ →₀ ℕ) (a : A) :
    (algebraTensorAlgEquiv R A).symm (monomial m a) = a ⊗ₜ monomial m 1
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem rotate_length (l : List α) : rotate l l.length = l
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_mono_measure' {α : Type*} {β : Type*} {_ : MeasurableSpace α}
    {μ ν : MeasureTheory.Measure α} [CompleteLattice β] {f : α → β} (hμν : ν ≤ μ) :
    essSup f ν ≤ essSup f μ
-- Mathlib/CategoryTheory/Abelian/Basic.lean
@[reassoc (attr := simp)]
theorem comp_epiDesc [Epi f] {T : C} (g : X ⟶ T) (hg : kernel.ι f ≫ g = 0) :
    f ≫ epiDesc f g hg = g
-- Mathlib/Analysis/NormedSpace/Extend.lean
theorem extendTo𝕜'_apply (fr : F →L[ℝ] ℝ) (x : F) :
    fr.extendTo𝕜' x = (fr x : 𝕜) - (I : 𝕜) * (fr ((I : 𝕜) • x) : 𝕜)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
theorem mop_injective : Function.Injective (mop : C → Cᴹᵒᵖ)
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem map_pure' {α β} : ∀ (f : α → β) (a), f <$> pure a = pure (f a)