ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_prod_Icc (a₁ a₂ : α) (b₁ b₂ : β) : Icc a₁ a₂ ×ˢ Icc b₁ b₂ = Icc (a₁, b₁) (a₂, b₂)
-- Mathlib/RingTheory/Polynomial/Dickson.lean
theorem map_dickson (f : R →+* S) : ∀ n : ℕ, map f (dickson k a n) = dickson k (f a) n
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- If `f` is a collection of linear maps, then the construction `MultilinearMap.compLinearMap`
sending a multilinear map `g` to `g (f₁ ⬝ , ..., fₙ ⬝ )` is linear in `g`. -/
@[simps] def compLinearMapₗ (f : Π (i : ι), M₁ i →ₗ[R] M₁' i) :
    (MultilinearMap R M₁' M₂) →ₗ[R] MultilinearMap R M₁ M₂
-- Mathlib/Order/Disjoint.lean
@[symm]
theorem Disjoint.symm ⦃a b : α⦄ : Disjoint a b → Disjoint b a
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma cast_ne_one : (n : α) ≠ 1 ↔ n ≠ 1
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem of_iff_true    (h : a ↔ True) : a
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem inl.inj_iff : (inl a : α ⊕ β) = inl b ↔ a = b
-- Mathlib/Probability/Cdf.lean
/-- The cdf tends to 1 at +∞. -/
lemma tendsto_cdf_atTop : Tendsto (cdf μ) atTop (𝓝 1)
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
lemma isCompatible_map_smul : ((r₀.smul m₀).map (whiskerRight φ (forget _))).Compatible
-- Mathlib/Data/Finset/Sort.lean
/-- The bijection `orderEmbOfFin s h` sends `k-1` to the maximum of `s`. -/
theorem orderEmbOfFin_last {s : Finset α} {k : ℕ} (h : s.card = k) (hz : 0 < k) :
    orderEmbOfFin s h ⟨k - 1, Nat.sub_lt hz (Nat.succ_pos 0)⟩ =
      s.max' (card_pos.mp (h.symm ▸ hz))
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem ramificationIdx_eq_find (h : ∃ n, ∀ k, map f p ≤ P ^ k → k ≤ n) :
    ramificationIdx f p P = Nat.find h
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem dist_set_exists : ∃ C, 0 ≤ C ∧ ∀ x : α, dist (f x) (g x) ≤ C
-- Mathlib/Data/Finsupp/Order.lean
@[simp, norm_cast] lemma coe_tsub (f g : ι →₀ α) : ⇑(f - g) = f - g
-- Mathlib/Probability/Kernel/Composition.lean
theorem map_apply (κ : Kernel α β) (hf : Measurable f) (a : α) : map κ f hf a = (κ a).map f
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.isBoundedUnder_le_iff (h : f' =Θ[l] g') :
    IsBoundedUnder (· ≤ ·) l (norm ∘ f') ↔ IsBoundedUnder (· ≤ ·) l (norm ∘ g')
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem AntitoneOn.quasilinearOn (hf : AntitoneOn f s) (hs : Convex 𝕜 s) : QuasilinearOn 𝕜 s f
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_add_zsmul [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (x : G) : ∀ n : ℤ, f (x + n • a) = f x + n • b
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem length_take (n : ℕ) (s : Stream' α) : (take n s).length = n
-- Mathlib/Topology/Inseparable.lean
lemma closure_singleton_eq_Iic (x : X) : closure {x} = Iic x
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- If `K / E / F` is a ring extension tower, `L` is a submonoid of `K / F` which is generated by
`S` as an `F`-module, then `E[L]` is generated by `S` as an `E`-module. -/
theorem Submonoid.adjoin_eq_span_of_eq_span [Semiring F] [Module F K] [IsScalarTower F E K]
    (L : Submonoid K) {S : Set K} (h : (L : Set K) = span F S) :
    toSubmodule (adjoin E (L : Set K)) = span E S
-- Mathlib/Order/ModularLattice.lean
theorem sup_lt_sup_of_lt_of_inf_le_inf (hxy : x < y) (hinf : y ⊓ z ≤ x ⊓ z) : x ⊔ z < y ⊔ z
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_mk (f : SupHom α β) (hf) : ⇑(mk f hf) = f
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
theorem factorial_smul (n : ℕ) :
    n ! • p n (fun _ ↦ y) = iteratedFDeriv 𝕜 n f x (fun _ ↦ y)
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
theorem localization_localization_surj [IsLocalization N T] (x : T) :
    ∃ y : R × localizationLocalizationSubmodule M N,
        x * algebraMap R T y.2 = algebraMap R T y.1
-- Mathlib/ModelTheory/Substructures.lean
theorem map_le_range {f : M →[L] N} {p : L.Substructure M} : map f p ≤ range f
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem ae_eq_of_forall_setIntegral_eq_of_sigmaFinite [SigmaFinite μ] {f g : α → E}
    (hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
    (hg_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn g s μ)
    (hfg_eq : ∀ s : Set α, MeasurableSet s → μ s < ∞ → ∫ x in s, f x ∂μ = ∫ x in s, g x ∂μ) :
    f =ᵐ[μ] g
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- A product over `powerset s` is equal to the double product over sets of subsets of `s` with
`card s = k`, for `k = 1, ..., card s`. -/
@[to_additive "A sum over `powerset s` is equal to the double sum over sets of subsets of `s` with
  `card s = k`, for `k = 1, ..., card s`"]
lemma prod_powerset (s : Finset α) (f : Finset α → β) :
    ∏ t ∈ powerset s, f t = ∏ j ∈ range (card s + 1), ∏ t ∈ powersetCard j s, f t
-- Mathlib/CategoryTheory/Generator.lean
theorem isCoseparator_def (G : C) :
    IsCoseparator G ↔ ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : Y ⟶ G, f ≫ h = g ≫ h) → f = g
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem dot_mod_gcd_left (xs ys : IntList) : dot xs ys % xs.gcd = 0
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
@[reassoc]
theorem uncurry_natural_left (f : X ⟶ X') (g : X' ⟶ A ⟹ Y) :
    uncurry (f ≫ g) = Limits.prod.map (𝟙 _) f ≫ uncurry g
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem rootSet_X_pow [CommRing S] [IsDomain S] [Algebra R S] {n : ℕ} (hn : n ≠ 0) :
    (X ^ n : R[X]).rootSet S = {0}
-- Mathlib/Algebra/GroupWithZero/Defs.lean
theorem mul_left_cancel₀ (ha : a ≠ 0) (h : a * b = a * c) : b = c
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_of_lt [Preorder α] {x y} (hx : x ∈ s) (hy : y ∈ s) (hxy : x < y) :
    s.Nontrivial
-- Mathlib/Topology/Sheaves/PUnit.lean
theorem isSheaf_of_isTerminal_of_indiscrete {X : TopCat.{w}} (hind : X.str = ⊤) (F : Presheaf C X)
    (it : IsTerminal <| F.obj <| op ⊥) : F.IsSheaf
-- Mathlib/Geometry/Manifold/InteriorBoundary.lean
/-- If `M` is boundaryless, `∂(M×N) = M × ∂N`. -/
lemma boundary_of_boundaryless_left [I.Boundaryless] :
    (I.prod J).boundary (M × N) = Set.prod (univ : Set M) (J.boundary N)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma IsEllSequence.smul (h : IsEllSequence W) (x : R) : IsEllSequence (x • W)
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- As a binary function, `Fin.cons` is injective. -/
theorem cons_injective2 : Function.Injective2 (@cons n α)
-- Mathlib/NumberTheory/DiophantineApproximation.lean
private theorem aux₂ : 0 < u - ⌊ξ⌋ * v ∧ u - ⌊ξ⌋ * v < v
-- Mathlib/Data/Nat/Cast/Basic.lean
lemma multiplesHom_symm_apply (f : ℕ →+ β) : (multiplesHom β).symm f = f 1
-- Mathlib/Data/Matrix/Basic.lean
theorem dotProduct_one (v : n → α) : v ⬝ᵥ 1 = ∑ i, v i
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Reflection is its own inverse. -/
@[simp]
theorem reflection_inv : (reflection K)⁻¹ = reflection K
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem integralBasis_repr_apply [NumberField K] (x : K) (i : Free.ChooseBasisIndex ℤ (𝓞 K)) :
    (latticeBasis K).repr (canonicalEmbedding K x) i = (integralBasis K).repr x i
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.bInter {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    {u : Set ι} (h : ∃ n ∈ u, IndepSets (s n) s' μ) :
    IndepSets (⋂ n ∈ u, s n) s' μ
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- The range of a surjective non-unital ring homomorphism is the whole of the codomain. -/
@[simp]
theorem srange_top_of_surjective (f : F) (hf : Function.Surjective (f : R → S)) :
    srange f = (⊤ : NonUnitalSubsemiring S)
-- Mathlib/Algebra/Field/IsField.lean
/-- For each field, and for each nonzero element of said field, there is a unique inverse.
Since `IsField` doesn't remember the data of an `inv` function and as such,
a lemma that there is a unique inverse could be useful.
-/
theorem uniq_inv_of_isField (R : Type u) [Ring R] (hf : IsField R) :
    ∀ x : R, x ≠ 0 → ∃! y : R, x * y = 1
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arcsin`. -/
theorem oangle_add_left_eq_arcsin_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle (x + y) y = Real.arcsin (‖x‖ / ‖x + y‖)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Composing on the right by a function preserves uniform convergence on a filter -/
theorem TendstoUniformlyOnFilter.comp (h : TendstoUniformlyOnFilter F f p p') (g : γ → α) :
    TendstoUniformlyOnFilter (fun n => F n ∘ g) (f ∘ g) p (p'.comap g)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasStrictDerivAt.csinh (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.sinh (f x)) (Complex.cosh (f x) * f') x
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem map_id : map (.id S A) (.id R C) = .id S _
-- Mathlib/Data/List/Nodup.lean
protected theorem Nodup.insert [DecidableEq α] (h : l.Nodup) : (l.insert a).Nodup
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion₂_prod_const {s : ∀ i, κ i → Set α} {t : Set β} :
    (⋃ (i) (j), s i j) ×ˢ t = ⋃ (i) (j), s i j ×ˢ t
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_sum {ι : Type u} (f : ι → Cardinal.{v}) :
    Cardinal.lift.{w} (Cardinal.sum f) = Cardinal.sum fun i => Cardinal.lift.{w} (f i)
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem translate_sat : {c : Constraint} → {v : Int} → sat c v → sat (c.translate t) (v + t)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- Changing coordinates between two elements of the maximal atlas gives rise to an element
of the structure groupoid. -/
theorem StructureGroupoid.compatible_of_mem_maximalAtlas {e e' : PartialHomeomorph M H}
    (he : e ∈ G.maximalAtlas M) (he' : e' ∈ G.maximalAtlas M) : e.symm ≫ₕ e' ∈ G
-- Mathlib/Data/Finset/Sym.lean
@[simp]
theorem sym_empty (n : ℕ) : (∅ : Finset α).sym (n + 1) = ∅
-- Mathlib/Computability/TMToPartrec.lean
theorem trNormal_respects (c k v s) :
    ∃ b₂,
      TrCfg (stepNormal c k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          ⟨some (trNormal c (trCont k)), s, K'.elim (trList v) [] [] (trContStack k)⟩ b₂
-- Mathlib/Data/DFinsupp/Order.lean
theorem sup_apply [∀ i, SemilatticeSup (α i)] (f g : Π₀ i, α i) (i : ι) : (f ⊔ g) i = f i ⊔ g i
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem Prime.eq_two_or_odd {p : ℕ} (hp : Prime p) : p = 2 ∨ p % 2 = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_neg_of_neg_of_neg_pi_lt {x : ℝ} (hx0 : x < 0) (hpx : -π < x) : sin x < 0
-- Mathlib/Probability/Process/Stopping.lean
/-- Given stopping times `τ` and `η` which are bounded below, `Set.piecewise s τ η` is also
a stopping time with respect to the same filtration. -/
theorem IsStoppingTime.piecewise_of_le (hτ_st : IsStoppingTime 𝒢 τ) (hη_st : IsStoppingTime 𝒢 η)
    (hτ : ∀ ω, i ≤ τ ω) (hη : ∀ ω, i ≤ η ω) (hs : MeasurableSet[𝒢 i] s) :
    IsStoppingTime 𝒢 (s.piecewise τ η)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_le_tsub_iff_left (ha : AddLECancellable a) (hc : AddLECancellable c)
    (h : c ≤ a) : a - b ≤ a - c ↔ c ≤ b
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_ge_eq_iInf_nat_add (u : ℕ → α) (n : ℕ) : ⨅ i ≥ n, u i = ⨅ i, u (i + n)
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem le_add_caratheodory (m₁ m₂ : OuterMeasure α) :
    m₁.caratheodory ⊓ m₂.caratheodory ≤ (m₁ + m₂ : OuterMeasure α).caratheodory
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem connectedComponentEquiv_trans (φ : G ≃g G') (φ' : G' ≃g G'') :
    connectedComponentEquiv (φ.trans φ') =
    φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem coeff_monomial_same (n : σ →₀ ℕ) (a : R) : coeff R n (monomial R n a) = a
-- Mathlib/Control/LawfulFix.lean
theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f)
-- Mathlib/Topology/Order/Basic.lean
theorem nhdsWithin_Iic_eq'' [TopologicalSpace α] [Preorder α] [OrderTopology α] (a : α) :
    𝓝[≤] a = (⨅ l < a, 𝓟 (Ioi l)) ⊓ 𝓟 (Iic a)
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem nodalWeight_ne_zero (hvs : Set.InjOn v s) (hi : i ∈ s) : nodalWeight s v i ≠ 0
-- Mathlib/Algebra/Star/Prod.lean
theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
    Units.embedProduct R (star u) = star (Units.embedProduct R u)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem add_zero : ∀ a : Int, a + 0 = a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt_add_one_of_lt (h : a < b) : a < b + 1
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofAdd_toAdd (x : Multiplicative α) : ofAdd (toAdd x) = x
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
@[reassoc (attr := simp)]
theorem underlyingIso_inv_top_arrow {B : C} :
    (underlyingIso _).inv ≫ (⊤ : Subobject B).arrow = 𝟙 B
-- Mathlib/Topology/Instances/ENNReal.lean
theorem nhds_zero : 𝓝 (0 : ℝ≥0∞) = ⨅ (a) (_ : a ≠ 0), 𝓟 (Iio a)
-- Mathlib/Order/Bounded.lean
theorem unbounded_lt_inter_lt [LinearOrder α] [NoMaxOrder α] (a : α) :
    Unbounded (· < ·) (s ∩ { b | a < b }) ↔ Unbounded (· < ·) s
-- Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean
/-- `annIdealGenerator 𝕜 a` is indeed a generator. -/
@[simp]
theorem span_singleton_annIdealGenerator (a : A) :
    Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Subtracting the first vector passed to `oangle` from the second vector negates the sign of
the angle. -/
theorem oangle_sign_sub_left_eq_neg (x y : V) :
    (o.oangle (y - x) y).sign = -(o.oangle x y).sign
-- Mathlib/FieldTheory/IntermediateField.lean
protected theorem zsmul_mem {x : L} (hx : x ∈ S) (n : ℤ) : n • x ∈ S
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
theorem measure_preimage_equiv {f : α ≃ᵐ β} (hf : MeasurePreserving f μa μb) (s : Set β) :
    μa (f ⁻¹' s) = μb s
-- Mathlib/RepresentationTheory/Rep.lean
theorem Action_ρ_eq_ρ {A : Rep k G} : Action.ρ A = A.ρ
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
lemma UniformEquicontinuous.uniformEquicontinuousOn {F : ι → β → α} (H : UniformEquicontinuous F)
    (S : Set β) : UniformEquicontinuousOn F S
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem lipschitz_compContinuous {δ : Type*} [TopologicalSpace δ] (g : C(δ, α)) :
    LipschitzWith 1 fun f : α →ᵇ β => f.compContinuous g
-- Mathlib/Analysis/Seminorm.lean
theorem ball_smul_closedBall (p : Seminorm 𝕜 E) (r₁ : ℝ) {r₂ : ℝ} (hr₂ : r₂ ≠ 0) :
    Metric.ball (0 : 𝕜) r₁ • p.closedBall 0 r₂ ⊆ p.ball 0 (r₁ * r₂)
-- Mathlib/Algebra/Periodic.lean
protected theorem Antiperiodic.neg [AddGroup α] [InvolutiveNeg β] (h : Antiperiodic f c) :
    Antiperiodic f (-c)
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem sub_zero {X Y : C} (a : X ⟶ Y) : a - 0 = a
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
/-- A *strictly convex space* is a normed space where the closed balls are strictly convex. We only
require balls of positive radius with center at the origin to be strictly convex in the definition,
then prove that any closed ball is strictly convex in `strictConvex_closedBall` below.

See also `StrictConvexSpace.of_strictConvex_closed_unit_ball`. -/
class StrictConvexSpace (𝕜 E : Type*) [NormedLinearOrderedField 𝕜] [NormedAddCommGroup E]
  [NormedSpace 𝕜 E] : Prop where
  strictConvex_closedBall : ∀ r : ℝ, 0 < r → StrictConvex 𝕜 (closedBall (0 : E) r)
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem sub_toSimpleFunc (f g : Lp.simpleFunc E p μ) :
    toSimpleFunc (f - g) =ᵐ[μ] toSimpleFunc f - toSimpleFunc g
-- Mathlib/Algebra/Order/Monovary.lean
lemma MonovaryOn.mul_left₀ (hf₁ : ∀ i ∈ s, 0 ≤ f₁ i) (hf₂ : ∀ i ∈ s, 0 ≤ f₂ i)
    (h₁ : MonovaryOn f₁ g s) (h₂ : MonovaryOn f₂ g s) : MonovaryOn (f₁ * f₂) g s
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
lemma booleanGenerators : BooleanGenerators {I : LieIdeal R L | IsAtom I}
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem Filter.Tendsto.congr_dist {f₁ f₂ : ι → α} {p : Filter ι} {a : α}
    (h₁ : Tendsto f₁ p (𝓝 a)) (h : Tendsto (fun x => dist (f₁ x) (f₂ x)) p (𝓝 0)) :
    Tendsto f₂ p (𝓝 a)
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp, reassoc]
lemma homOfLE_op_comp_eqToHom {a b c : X} (hab : b ≤ a) (hbc : op b = op c) :
    (homOfLE hab).op ≫ eqToHom hbc = (homOfLE ((le_of_eq (op_injective hbc.symm)).trans hab)).op
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
@[deprecated get_toList (since := "2024-05-08")]
theorem nthLe_toList (n : ℕ) (hn : n < length (toList p x)) :
    (toList p x).nthLe n hn = (p ^ n) x
-- Mathlib/Algebra/Lie/Quotient.lean
/-- `LieSubmodule.Quotient.mk` as a `LieModuleHom`. -/
@[simps]
def mk' : M →ₗ⁅R,L⁆ M ⧸ N
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Change of variables. If `f` has continuous derivative `f'` on `[a, b]`,
and `g` is continuous on `f '' [a, b]`, then we can substitute `u = f x` to get
`∫ x in a..b, f' x • (g ∘ f) x = ∫ u in f a..f b, g u`.
Compared to `intervalIntegral.integral_comp_smul_deriv` we only require that `g` is continuous on
`f '' [a, b]`.
-/
theorem integral_comp_smul_deriv' {f f' : ℝ → ℝ} {g : ℝ → G}
    (h : ∀ x ∈ uIcc a b, HasDerivAt f (f' x) x) (h' : ContinuousOn f' (uIcc a b))
    (hg : ContinuousOn g (f '' [[a, b]])) :
    (∫ x in a..b, f' x • (g ∘ f) x) = ∫ x in f a..f b, g x
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem X_sub_C_mul_divByMonic_eq_sub_modByMonic {K : Type*} [Field K] (f : K[X]) (a : K) :
    (X - C a) * (f /ₘ (X - C a)) = f - f %ₘ (X - C a)
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem compl_eq_empty_iff (s : Finset α) : sᶜ = ∅ ↔ s = univ
-- Mathlib/Data/Fin/Basic.lean
theorem rev_involutive : Involutive (rev : Fin n → Fin n)
-- Mathlib/FieldTheory/Extension.lean
theorem exists_algHom_of_splits : ∃ φ : E →ₐ[F] K, φ.comp L.val = f
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem WalkingPair.equivBool_apply_right : WalkingPair.equivBool right = false
-- Mathlib/Algebra/Algebra/Hom.lean
/-- Each element of the monoid defines an algebra homomorphism.

This is a stronger version of `MulSemiringAction.toRingHom` and
`DistribMulAction.toLinearMap`. -/
@[simps]
def toAlgHom (m : M) : A →ₐ[R] A
-- Mathlib/Analysis/Normed/Ring/Units.lean
theorem inverse_one_sub_nth_order (n : ℕ) :
    ∀ᶠ t in 𝓝 0, inverse ((1 : R) - t) = (∑ i ∈ range n, t ^ i) + t ^ n * inverse (1 - t)
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.subperm {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁ <+~ l₂
-- Mathlib/Data/NNReal/Basic.lean
theorem mul_finset_sup {α} (r : ℝ≥0) (s : Finset α) (f : α → ℝ≥0) :
    r * s.sup f = s.sup fun a => r * f a
-- Mathlib/Data/Set/Subsingleton.lean
theorem Nontrivial.not_subset_empty (hs : s.Nontrivial) : ¬s ⊆ ∅
-- Mathlib/Data/Rat/Defs.lean
lemma pow_eq_mkRat (q : ℚ) (n : ℕ) : q ^ n = mkRat (q.num ^ n) (q.den ^ n)
-- Mathlib/Order/WellFoundedSet.lean
theorem partiallyWellOrderedOn_sup (s : Finset ι) {f : ι → Set α} :
    (s.sup f).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
theorem adjoin_primitive_root_eq_top {n : ℕ+} [IsDomain B] [h : IsCyclotomicExtension {n} A B]
    {ζ : B} (hζ : IsPrimitiveRoot ζ n) : adjoin A ({ζ} : Set B) = ⊤
-- Mathlib/RingTheory/Discriminant.lean
/-- If `b` is not linear independent, then `Algebra.discr A b = 0`. -/
theorem discr_zero_of_not_linearIndependent [IsDomain A] {b : ι → B}
    (hli : ¬LinearIndependent A b) : discr A b = 0
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
theorem hasLimit_iff_hasTerminal_cone (F : J ⥤ C) : HasLimit F ↔ HasTerminal (Cone F)
-- Mathlib/Order/RelClasses.lean
lemma WellFounded.prod_lex {ra : α → α → Prop} {rb : β → β → Prop} (ha : WellFounded ra)
    (hb : WellFounded rb) : WellFounded (Prod.Lex ra rb)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem toDualTopEquiv_coe [LE α] (a : α) :
    WithBot.toDualTopEquiv ↑(toDual a) = toDual (a : WithTop α)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
/-- Definition of `IsLittleO` in terms of filters. -/
theorem isLittleO_iff : f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- Evaluation as an `AlgHom` -/
@[simps!]
def evalₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] (x : X) :
    LocallyConstant X Y →ₐ[R] Y
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
lemma isCoprime_col (A : SL(2, R)) (j : Fin 2) : IsCoprime (A 0 j) (A 1 j)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_nonneg_iff_left_nonneg_of_pos [PosMulStrictMono α] [MulPosStrictMono α]
    (hb : 0 < b) : 0 ≤ a * b ↔ 0 ≤ a
-- Mathlib/Topology/Covering.lean
protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :
    IsCoveringMapOn f Set.univ
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem coe_restrictScalars (V : Submodule R M) : (V.restrictScalars S : Set M) = V
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_comp_eq_preimage (g : β → M) (f : α → β) :
    mulSupport (g ∘ f) = f ⁻¹' mulSupport g
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp high)]
theorem singleton_smul_singleton : ({a} : Set α) • ({b} : Set β) = {a • b}
-- Mathlib/Data/Finset/Card.lean
theorem exists_ne_of_one_lt_card (hs : 1 < s.card) (a : α) : ∃ b, b ∈ s ∧ b ≠ a
-- Mathlib/Order/Synonym.lean
@[simp]
protected theorem «forall» {p : αᵒᵈ → Prop} : (∀ a, p a) ↔ ∀ a, p (toDual a)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getD_eq_getElem? (since := "2024-06-12")]
theorem getD_eq_get? : ∀ l n (a : α), getD l n a = (get? l n).getD a
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toSupBotHom (f : BoundedLatticeHom α β) : ⇑f.toSupBotHom = f
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem le_pi {m : ∀ i, OuterMeasure (α i)} {n : OuterMeasure (∀ i, α i)} :
    n ≤ OuterMeasure.pi m ↔
      ∀ s : ∀ i, Set (α i), (pi univ s).Nonempty → n (pi univ s) ≤ ∏ i, m i (s i)
-- Mathlib/Combinatorics/Enumerative/Partition.lean
/-- Given a multiset which sums to `n`, construct a partition of `n` with the same multiset, but
without the zeros.
-/
@[simps]
def ofSums (n : ℕ) (l : Multiset ℕ) (hl : l.sum = n) : Partition n
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousWithinAt_pi {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    {f : α → ∀ i, π i} {s : Set α} {x : α} :
    ContinuousWithinAt f s x ↔ ∀ i, ContinuousWithinAt (fun y => f y i) s x
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem trans_refl : e.trans (PartialEquiv.refl β) = e
-- Mathlib/RingTheory/Ideal/Quotient.lean
theorem exists_inv {I : Ideal R} [hI : I.IsMaximal] :
    ∀ {a : R ⧸ I}, a ≠ 0 → ∃ b : R ⧸ I, a * b = 1
-- Mathlib/LinearAlgebra/InvariantBasisNumber.lean
/-- We say that `R` satisfies the rank condition if `(Fin n → R) →ₗ[R] (Fin m → R)` surjective
    implies `m ≤ n`. -/
class RankCondition : Prop where
  /-- Any surjective linear map from `Rⁿ` to `Rᵐ` guarantees `m ≤ n`. -/
  le_of_fin_surjective : ∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Surjective f → m ≤ n
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem Fin.circulant_mul_comm [CommSemigroup α] [AddCommMonoid α] :
    ∀ {n} (v w : Fin n → α), circulant v * circulant w = circulant w * circulant v
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- Every coequalizer of `(f, f)` is an isomorphism. -/
theorem isIso_colimit_cocone_parallelPair_of_self {c : Cofork f f} (h : IsColimit c) : IsIso c.π
-- Mathlib/Algebra/Polynomial/Derivation.lean
/-- `Polynomial.derivative` as a derivation. -/
@[simps]
def derivative' : Derivation R R[X] R[X]
-- Mathlib/Algebra/Star/Pi.lean
@[simp]
theorem star_apply [∀ i, Star (f i)] (x : ∀ i, f i) (i : I) : star x i = star (x i)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ico_mem_nhdsWithin_Iic (H : b ∈ Ioo a c) : Ico a c ∈ 𝓝[≤] b
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolRing_top : toBoolRing (⊤ : α) = 1
-- Mathlib/Data/List/Infix.lean
theorem eq_of_suffix_of_length_eq (h : l₁ <:+ l₂) : l₁.length = l₂.length → l₁ = l₂
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A proper map is closed. -/
lemma IsProperMap.isClosedMap (h : IsProperMap f) : IsClosedMap f