ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
/-- **Lebesgue dominated convergence theorem**: sufficient conditions under which almost
  everywhere convergence of a sequence of functions implies the convergence of their image by
  `condexpL1`. -/
theorem tendsto_condexpL1_of_dominated_convergence (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    {fs : ℕ → α → F'} {f : α → F'} (bound_fs : α → ℝ)
    (hfs_meas : ∀ n, AEStronglyMeasurable (fs n) μ) (h_int_bound_fs : Integrable bound_fs μ)
    (hfs_bound : ∀ n, ∀ᵐ x ∂μ, ‖fs n x‖ ≤ bound_fs x)
    (hfs : ∀ᵐ x ∂μ, Tendsto (fun n => fs n x) atTop (𝓝 (f x))) :
    Tendsto (fun n => condexpL1 hm μ (fs n)) atTop (𝓝 (condexpL1 hm μ f))
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
@[simp]
theorem U_one : U R 1 = 2 * X
-- Mathlib/CategoryTheory/Limits/FullSubcategory.lean
theorem hasLimit_of_closedUnderLimits (h : ClosedUnderLimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasLimit (F ⋙ fullSubcategoryInclusion P)] : HasLimit F
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_le_one_of_le_one (h : a ≤ 1) : ⌊a⌋₊ ≤ 1
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem quotTorsionOfEquivSpanSingleton_apply_mk (x : M) (a : R) :
    quotTorsionOfEquivSpanSingleton R M x (Submodule.Quotient.mk a) =
      a • ⟨x, Submodule.mem_span_singleton_self x⟩
-- Mathlib/Algebra/Group/Conj.lean
@[simp]
theorem conj_mul {a b c : α} : b * a * b⁻¹ * (b * c * b⁻¹) = b * (a * c) * b⁻¹
-- Mathlib/CategoryTheory/Iso.lean
/-- An isomorphism (a.k.a. an invertible morphism) between two objects of a category.
The inverse morphism is bundled.

See also `CategoryTheory.Core` for the category with the same objects and isomorphisms playing
the role of morphisms.

See <https://stacks.math.columbia.edu/tag/0017>.
-/
structure Iso {C : Type u} [Category.{v} C] (X Y : C) where
  /-- The forward direction of an isomorphism. -/
  hom : X ⟶ Y
  /-- The backwards direction of an isomorphism. -/
  inv : Y ⟶ X
  /-- Composition of the two directions of an isomorphism is the identity on the source. -/
  hom_inv_id : hom ≫ inv = 𝟙 X := by aesop_cat
  /-- Composition of the two directions of an isomorphism in reverse order
  is the identity on the target. -/
  inv_hom_id : inv ≫ hom = 𝟙 Y := by aesop_cat
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive (attr := simp)]
theorem iterate_map_pow {M F : Type*} [Monoid M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) (k : ℕ) :
    f^[n] (x ^ k) = f^[n] x ^ k
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
/--
An affine open cover of `X` consists of a family of open immersions into `X` from
spectra of rings.
-/
structure AffineOpenCover (X : Scheme.{u}) where
  /-- index set of an affine open cover of a scheme `X` -/
  J : Type v
  /-- the ring associated to a component of an affine open cover -/
  obj : J → CommRingCat.{u}
  /-- the embedding of subschemes to `X` -/
  map : ∀ j : J, Spec (obj j) ⟶ X
  /-- given a point of `x : X`, `f x` is the index of the subscheme which contains `x`  -/
  f : X → J
  /-- the subschemes covers `X` -/
  covers : ∀ x, x ∈ Set.range (map (f x)).1.base
  /-- the embedding of subschemes are open immersions -/
  IsOpen : ∀ x, IsOpenImmersion (map x) := by infer_instance
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem colorable_of_chromaticNumber_ne_top (h : G.chromaticNumber ≠ ⊤) :
    G.Colorable (ENat.toNat G.chromaticNumber)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem insert_sdiff_insert (s t : Finset α) (x : α) : insert x s \ insert x t = s \ insert x t
-- Mathlib/Tactic/FunProp/ContDiff.lean
theorem contDiff_id' : ContDiff K n (fun x : E => x)
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
lemma StableUnderBaseChange.mk (P : AffineTargetMorphismProperty) [P.toProperty.RespectsIso]
    (H : ∀ ⦃X Y S : Scheme⦄ [IsAffine S] [IsAffine X] (f : X ⟶ S) (g : Y ⟶ S),
      P g → P (pullback.fst f g)) : P.StableUnderBaseChange
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.lintegral_tendsto_of_nat {φ : ℕ → Set α} (hφ : AECover μ atTop φ) {f : α → ℝ≥0∞}
    (hfm : AEMeasurable f μ) : Tendsto (∫⁻ x in φ ·, f x ∂μ) atTop (𝓝 <| ∫⁻ x, f x ∂μ)
-- Mathlib/Order/Filter/Basic.lean
lemma frequently_mem_iff_neBot {l : Filter α} {s : Set α} : (∃ᶠ x in l, x ∈ s) ↔ NeBot (l ⊓ 𝓟 s)
-- Mathlib/Data/Nat/PartENat.lean
nonrec theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem eventuallyEq_one : f =ᶠ[𝓝 c] 1
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_le_nnreal_smul_eLpNormEssSup_of_ae_le_mul {f : α → F} {g : α → G} {c : ℝ≥0}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) : eLpNormEssSup f μ ≤ c • eLpNormEssSup g μ
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem bind_map (p : PMF α) (f : α → β) (q : β → PMF γ) : (p.map f).bind q = p.bind (q ∘ f)
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.comp (hg : ConvexOn 𝕜 (f '' s) g) (hf : ConvexOn 𝕜 s f)
    (hg' : MonotoneOn g (f '' s)) : ConvexOn 𝕜 s (g ∘ f)
-- Mathlib/Algebra/Periodic.lean
theorem Periodic.map_vadd_multiples [AddCommMonoid α] (hf : Periodic f c)
    (a : AddSubmonoid.multiples c) (x : α) : f (a +ᵥ x) = f x
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- The ring equiv between the top element of `NonUnitalSubsemiring R` and `R`. -/
@[simps!]
def topEquiv : (⊤ : NonUnitalSubsemiring R) ≃+* R
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma IsWeaklyRegular.isWeaklyRegular_rTensor [Module.Flat R M₂]
    {rs : List R} (h : IsWeaklyRegular M rs) :
    IsWeaklyRegular (M ⊗[R] M₂) rs
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem norm_mod_lt (x : ℤ[i]) {y : ℤ[i]} (hy : y ≠ 0) : (x % y).norm < y.norm
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_add_supp (a : R) {s : R} (h : s ∈ supp v) : v (a + s) = v a
-- Mathlib/MeasureTheory/Function/SpecialFunctions/RCLike.lean
@[measurability]
theorem measurable_re : Measurable (re : 𝕜 → ℝ)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem toSignedMeasure_sub_apply {μ ν : Measure α} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    {i : Set α} (hi : MeasurableSet i) :
    (μ.toSignedMeasure - ν.toSignedMeasure) i = (μ i).toReal - (ν i).toReal
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_lt_mul_of_lt_of_le`. -/
@[to_additive Right.add_pos_of_pos_of_nonneg
"Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos_of_pos_of_nonneg`."]
theorem Right.one_lt_mul_of_lt_of_le [CovariantClass α α (swap (· * ·)) (· < ·)] {a b : α}
    (ha : 1 < a) (hb : 1 ≤ b) :
    1 < a * b
-- Mathlib/Topology/Separation.lean
theorem regularSpace_sInf {X} {T : Set (TopologicalSpace X)} (h : ∀ t ∈ T, @RegularSpace X t) :
    @RegularSpace X (sInf T)
-- Mathlib/Data/SetLike/Basic.lean
@[simp]
theorem coe_mem (x : p) : (x : B) ∈ p
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
lemma equicontinuous_restrict_iff (F : ι → X → α) {S : Set X} :
    Equicontinuous (S.restrict ∘ F) ↔ EquicontinuousOn F S
-- Mathlib/Data/Set/Prod.lean
theorem univ_pi_subset_univ_pi_iff :
    pi univ t₁ ⊆ pi univ t₂ ↔ (∀ i, t₁ i ⊆ t₂ i) ∨ ∃ i, t₁ i = ∅
-- Mathlib/Topology/Baire/Lemmas.lean
theorem dense_of_mem_residual {s : Set X} (hs : s ∈ residual X) : Dense s
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem cancel_right {g₁ g₂ f : CentroidHom α} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- Mathlib/Tactic/LinearCombination.lean
theorem sub_pf [Sub α] (p₁ : (a₁:α) = b₁) (p₂ : a₂ = b₂) : a₁ - a₂ = b₁ - b₂
-- Mathlib/Order/Bounded.lean
theorem bounded_lt_Ico [Preorder α] (a b : α) : Bounded (· < ·) (Ico a b)
-- Mathlib/Data/DFinsupp/Basic.lean
theorem sub_apply [∀ i, AddGroup (β i)] (g₁ g₂ : Π₀ i, β i) (i : ι) : (g₁ - g₂) i = g₁ i - g₂ i
-- Mathlib/Algebra/Category/MonCat/Basic.lean
@[to_additive (attr := simp)] theorem MonoidHom.id_monCat_comp
    {G : Type u} [Monoid G] {H : MonCat.{u}} (f : G →* H) : MonoidHom.comp (𝟙 H) f = f
-- Mathlib/Data/List/Lattice.lean
theorem inter_eq_nil_iff_disjoint : l₁ ∩ l₂ = [] ↔ Disjoint l₁ l₂
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem normSq_ne_zero (z : ℍ) : Complex.normSq (z : ℂ) ≠ 0
-- Mathlib/RingTheory/Localization/Module.lean
@[simp] lemma LinearMap.extendScalarsOfIsLocalization_apply' (f : M →ₗ[R] N) (x : M) :
    (f.extendScalarsOfIsLocalization S A) x = f x
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem symm_dual_id : sInfHom.dual.symm (sSupHom.id _) = sInfHom.id α
-- Mathlib/Algebra/Homology/Embedding/IsSupported.lean
/-- If `K : HomologicalComplex C c'`, then `K.IsStrictlySupported e` holds for
an embedding `e : c.Embedding c'` of complex shapes if `K.X i'` is zero
wheneverm `i'` is not of the form `e.f i` for some `i`.-/
class IsStrictlySupported : Prop where
  isZero (i' : ι') (hi' : ∀ i, e.f i ≠ i') : IsZero (K.X i')
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem ContDiffAt.cexp {n} (hf : ContDiffAt 𝕜 n f x) :
    ContDiffAt 𝕜 n (fun x => Complex.exp (f x)) x
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
/-- The `MonoidWithZero` version of `div_eq_div_iff_mul_eq_mul`. -/
protected lemma div_eq_div_iff (hbd : Commute b d) (hb : b ≠ 0) (hd : d ≠ 0) :
    a / b = c / d ↔ a * d = c * b
-- Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean
theorem contDiffOn_succ_of_fderiv_apply [FiniteDimensional 𝕜 E] {n : ℕ} {f : E → F} {s : Set E}
    (hf : DifferentiableOn 𝕜 f s) (h : ∀ y, ContDiffOn 𝕜 n (fun x => fderivWithin 𝕜 f s x y) s) :
    ContDiffOn 𝕜 (n + 1 : ℕ) f s
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem strictAntiOn_log : StrictAntiOn log (Set.Iio 0)
-- Mathlib/RingTheory/Smooth/Basic.lean
theorem of_equiv [FormallySmooth R A] (e : A ≃ₐ[R] B) : FormallySmooth R B
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
protected theorem continuous : Continuous f
-- Mathlib/Data/Vector/Snoc.lean
@[simp]
theorem map_snoc : map f (xs.snoc x) = (map f xs).snoc (f x)
-- Mathlib/Data/Finset/Lattice.lean
theorem min_le {a : α} {s : Finset α} (as : a ∈ s) : s.min ≤ a
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem iUnion_biUnion_partition (h : ∀ J ∈ π, (πi J).IsPartition) :
    (π.biUnion πi).iUnion = π.iUnion
-- Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean
/-- Shows the correctness of `compExactValue` in case the continued fraction
`GenContFract.of v` did not terminate at position `n`. That is, we obtain the
value `v` if we pass the two successive (auxiliary) continuants at positions `n` and `n + 1` as well
as the fractional part at `IntFractPair.stream n` to `compExactValue`.

The correctness might be seen more readily if one uses `convs'` to evaluate the continued
fraction. Here is an example to illustrate the idea:

Let `(v : ℚ) := 3.4`. We have
- `GenContFract.IntFractPair.stream v 0 = some ⟨3, 0.4⟩`, and
- `GenContFract.IntFractPair.stream v 1 = some ⟨2, 0.5⟩`.
Now `(GenContFract.of v).convs' 1 = 3 + 1/2`, and our fractional term at position `2` is `0.5`.
We hence have `v = 3 + 1/(2 + 0.5) = 3 + 1/2.5 = 3.4`.
This computation corresponds exactly to the one using the recurrence equation in `compExactValue`.
-/
theorem compExactValue_correctness_of_stream_eq_some :
    ∀ {ifp_n : IntFractPair K}, IntFractPair.stream v n = some ifp_n →
      v = compExactValue ((of v).contsAux n) ((of v).contsAux <| n + 1) ifp_n.fr
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive]
theorem pow_lt_one_iff {x : M} {n : ℕ} (hn : n ≠ 0) : x ^ n < 1 ↔ x < 1
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_bot_ae_eq (f : α → F') :
    μ[f|⊥] =ᵐ[μ] fun _ => (μ Set.univ).toReal⁻¹ • ∫ x, f x ∂μ
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Ico (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ico a b = Ico (a / c) (b / c)
-- Mathlib/GroupTheory/Perm/Finite.lean
theorem Disjoint.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
    {σ τ : Perm α} (h : Disjoint σ τ) : Disjoint (σ.extendDomain f) (τ.extendDomain f)
-- Mathlib/FieldTheory/Extension.lean
theorem nonempty_algHom_of_splits : Nonempty (E →ₐ[F] K)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem sinh_sub_id_strictMono : StrictMono fun x => sinh x - x
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_pow (p : R[X]) (n : ℕ) :
    derivative (p ^ n) = C (n : R) * p ^ (n - 1) * derivative p
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem setOf_eq_eq_singleton' {a : α} : { x | a = x } = {a}
-- Mathlib/NumberTheory/SumTwoSquares.lean
/-- If `n` is a squarefree natural number, then `-1` is a square modulo `n` if and only if
`n` is not divisible by a prime `q` such that `q % 4 = 3`. -/
theorem ZMod.isSquare_neg_one_iff {n : ℕ} (hn : Squarefree n) :
    IsSquare (-1 : ZMod n) ↔ ∀ {q : ℕ}, q.Prime → q ∣ n → q % 4 ≠ 3
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem disjoint_val : s.1.Disjoint t.1 ↔ Disjoint s t
-- Mathlib/Data/Real/EReal.lean
theorem coe_ennreal_strictMono : StrictMono ((↑) : ℝ≥0∞ → EReal)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem opNorm_mul : ‖mul 𝕜 𝕜'‖ = 1
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
/-- In a locally convex space, if `s`, `t` are disjoint convex sets, `s` is compact and `t` is
closed, then we can find open disjoint convex sets containing them. -/
theorem Disjoint.exists_open_convexes [LocallyConvexSpace 𝕜 E] {s t : Set E} (disj : Disjoint s t)
    (hs₁ : Convex 𝕜 s) (hs₂ : IsCompact s) (ht₁ : Convex 𝕜 t) (ht₂ : IsClosed t) :
    ∃ u v, IsOpen u ∧ IsOpen v ∧ Convex 𝕜 u ∧ Convex 𝕜 v ∧ s ⊆ u ∧ t ⊆ v ∧ Disjoint u v
-- Mathlib/Topology/UnitInterval.lean
@[simp]
theorem iccHomeoI_apply_coe (a b : 𝕜) (h : a < b) (x : Set.Icc a b) :
    ((iccHomeoI a b h) x : 𝕜) = (x - a) / (b - a)
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem monotone_iff_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [OrderedAddCommGroup H]
    [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
    Monotone f ↔ MonotoneOn f (Icc l (l + a))
-- Mathlib/CategoryTheory/Generator.lean
theorem IsDetecting.mono {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {ℋ : Set C} (h𝒢ℋ : 𝒢 ⊆ ℋ) :
    IsDetecting ℋ
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp)] lemma mul_inv_cancel_comm_assoc (a b : G) : a * (b * a⁻¹) = b
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F
-- Mathlib/SetTheory/ZFC/Ordinal.lean
theorem isTransitive_iff_subset_powerset : x.IsTransitive ↔ x ⊆ powerset x
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem Set.Finite.measurableSet {s : Set α} (hs : s.Finite) : MeasurableSet s
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_leftUnitor_hom_snd (X : C₁ × C₂) :
    ((λ_ X).hom : 𝟙_ _ ⊗ X ⟶ X).2 = (λ_ X.2).hom
-- .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean
protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
    eraseIdx l k <+: eraseIdx l' k
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem loop_eq {v : V} (p : G.Path v v) : p = Path.nil
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat :
    Tendsto (fun n : ℕ ↦ (n : ℝ≥0)⁻¹) atTop (𝓝 0)
-- Mathlib/Algebra/Lie/Submodule.lean
theorem disjoint_iff_coe_toSubmodule :
    Disjoint N N' ↔ Disjoint (N : Submodule R M) (N' : Submodule R M)
-- Mathlib/Algebra/Group/Equiv/TypeTags.lean
/-- Reinterpret `G ≃* H` as `Additive G ≃+ Additive H`. -/
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H)
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_symmDiff_cancel_left : a ∆ (a ∆ b) = b
-- Mathlib/GroupTheory/CoprodI.lean
theorem equivPair_symm (i) (p : Pair M i) : (equivPair i).symm p = rcons p
-- Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean
theorem strictConcaveOn_sqrt_mul_log_Ioi :
    StrictConcaveOn ℝ (Set.Ioi 1) fun x => √x * log x
-- Mathlib/Topology/Bases.lean
/-- If `β` is a first-countable space, then its induced topology via `f` on `α` is also
first-countable. -/
theorem firstCountableTopology_induced (α β : Type*) [t : TopologicalSpace β]
    [FirstCountableTopology β] (f : α → β) : @FirstCountableTopology α (t.induced f)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes left covariance.
The lemma assuming right covariance is `Right.one_lt_mul_of_lt_of_le`. -/
@[to_additive Left.add_pos_of_pos_of_nonneg
      "Assumes left covariance.
      The lemma assuming right covariance is `Right.add_pos_of_pos_of_nonneg`."]
theorem Left.one_lt_mul_of_lt_of_le [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (ha : 1 < a)
    (hb : 1 ≤ b) :
    1 < a * b
-- Mathlib/Data/Finset/Basic.lean
theorem insert_erase_subset (a : α) (s : Finset α) : s ⊆ insert a (erase s a)
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem coeff_iterate_derivative {k} (p : R[X]) (m : ℕ) :
    (derivative^[k] p).coeff m = (m + k).descFactorial k • p.coeff (m + k)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_mem_multiset [DecidableEq α] (m : Multiset α) (f : { x // x ∈ m } → β) (g : α → β)
    (hfg : ∀ x, f x = g x) : ∏ x : { x // x ∈ m }, f x = ∏ x ∈ m.toFinset, g x
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_zero : (0 : MvPolynomial σ R).eval₂ f g = 0
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem DifferentiableWithinAt.arsinh (h : DifferentiableWithinAt ℝ f s a) :
    DifferentiableWithinAt ℝ (fun x => arsinh (f x)) s a
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem isGLB_sInf (s : Set (WithTop α)) : IsGLB s (sInf s)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem isUnit_iff_norm_isUnit {d : ℤ} (z : ℤ√d) : IsUnit z ↔ IsUnit z.norm
-- Mathlib/SetTheory/Game/Impartial.lean
/-- This lemma doesn't require `H` to be impartial. -/
theorem equiv_iff_add_equiv_zero' (H : PGame) : (G ≈ H) ↔ (G + H ≈ 0)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toNat_sub {n} (x y : BitVec n) :
    (x - y).toNat = (((2^n - y.toNat) + x.toNat) % 2^n)
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem seq_destruct_think (s : WSeq α) : Seq.destruct (think s) = some (none, s)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem toSigmaCofork_π : K.toSigmaCofork.π = Sigma.desc K.π
-- Mathlib/Topology/Order/ProjIcc.lean
@[continuity]
theorem continuous_projIcc : Continuous (projIcc a b h)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.multiset_sum {s : Multiset A} (h : ∀ x ∈ s, IsIntegral R x) :
    IsIntegral R s.sum
-- Mathlib/Data/Real/EReal.lean
@[simp] lemma top_mul_top : (⊤ : EReal) * ⊤ = ⊤
-- Mathlib/Logic/Equiv/Basic.lean
theorem swap_apply_eq_iff {x y z w : α} : swap x y z = w ↔ z = swap x y w
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem pullback_obj_arrow (f : X ⟶ Y) (g : MonoOver Y) :
    ((pullback f).obj g).arrow = pullback.snd _ _
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem Measurable.comp_aemeasurable [MeasurableSpace δ] {f : α → δ} {g : δ → β} (hg : Measurable g)
    (hf : AEMeasurable f μ) : AEMeasurable (g ∘ f) μ
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem prev : ∀ {it}, ValidFor (c :: l) r it → ValidFor l (c :: r) it.prev
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
lemma disjoint_iSup_genEigenspace [NoZeroSMulDivisors R M]
    (f : End R M) {μ₁ μ₂ : R} (hμ : μ₁ ≠ μ₂) :
    Disjoint (⨆ k, f.genEigenspace μ₁ k) (⨆ k, f.genEigenspace μ₂ k)
-- Mathlib/RingTheory/AlgebraTower.lean
theorem Basis.algebraMapCoeffs_apply (i : ι) : b.algebraMapCoeffs A h i = b i
-- Mathlib/CategoryTheory/Limits/MonoCoprod.lean
theorem monoCoprod_of_preservesCoprod_of_reflectsMono [MonoCoprod D]
    [PreservesColimitsOfShape (Discrete WalkingPair) F]
    [ReflectsMonomorphisms F] : MonoCoprod C
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem partiallyWellOrderedOn_singleton (a : α) : PartiallyWellOrderedOn {a} r
-- Mathlib/LinearAlgebra/Projectivization/Independence.lean
/-- Independence is the negation of dependence. -/
theorem independent_iff_not_dependent : Independent f ↔ ¬Dependent f
-- Mathlib/Order/LiminfLimsup.lean
theorem isBoundedUnder_le_abs [LinearOrderedAddCommGroup α] {f : Filter β} {u : β → α} :
    (f.IsBoundedUnder (· ≤ ·) fun a => |u a|) ↔
      f.IsBoundedUnder (· ≤ ·) u ∧ f.IsBoundedUnder (· ≥ ·) u
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle as a ratio of sides, version subtracting
vectors. -/
theorem tan_angle_sub_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) :
    Real.tan (angle x (x - y)) = ‖y‖ / ‖x‖
-- Mathlib/Init/Data/List/Basic.lean
@[simp] theorem headI_nil [Inhabited α] : ([] : List α).headI = default
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_le_of_mul_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hle : d ≤ b) (a0 : 0 ≤ a) :
    a * d ≤ c
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- The canonical isomorphism `S.cycles ≅ kernel S.g`. -/
@[simps]
noncomputable def cyclesIsoKernel [HasKernel S.g] : S.cycles ≅ kernel S.g
-- Mathlib/Analysis/Seminorm.lean
theorem ball_smul (p : Seminorm 𝕜 E) {c : NNReal} (hc : 0 < c) (r : ℝ) (x : E) :
    (c • p).ball x r = p.ball x (r / c)
-- Mathlib/Algebra/Homology/TotalComplex.lean
/-- The functor which sends a bicomplex to its total complex. -/
@[simps]
noncomputable def totalFunctor :
    HomologicalComplex₂ C c₁ c₂ ⥤ HomologicalComplex C c₁₂
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem adjoint_eq_toCLM_adjoint (A : E →ₗ[𝕜] F) :
    haveI := FiniteDimensional.complete 𝕜 E
    haveI := FiniteDimensional.complete 𝕜 F
    LinearMap.adjoint A = ContinuousLinearMap.adjoint (LinearMap.toContinuousLinearMap A)
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
theorem subOneIntegralPowerBasis'_gen_prime [IsCyclotomicExtension {p} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑p) :
    Prime hζ.subOneIntegralPowerBasis'.gen
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem toTopologicalSpace_iInf {ι} (s : ι → GroupTopology α) :
    (⨅ i, s i).toTopologicalSpace = ⨅ i, (s i).toTopologicalSpace
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- If a set `t` is covered by a countable family of finite measure sets, then its measurable
superset `toMeasurable μ t` (which has the same measure as `t`) satisfies,
for any measurable set `s`, the equality `μ (toMeasurable μ t ∩ s) = μ (t ∩ s)`. -/
theorem measure_toMeasurable_inter_of_cover {s : Set α} (hs : MeasurableSet s) {t : Set α}
    {v : ℕ → Set α} (hv : t ⊆ ⋃ n, v n) (h'v : ∀ n, μ (t ∩ v n) ≠ ∞) :
    μ (toMeasurable μ t ∩ s) = μ (t ∩ s)
-- Mathlib/Logic/Relation.lean
theorem ReflTransGen.swap (h : ReflTransGen r b a) : ReflTransGen (swap r) a b
-- Mathlib/Data/Seq/WSeq.lean
theorem mem_rec_on {C : WSeq α → Prop} {a s} (M : a ∈ s) (h1 : ∀ b s', a = b ∨ C s' → C (cons b s'))
    (h2 : ∀ s, C s → C (think s)) : C s
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem le_dimH_of_hausdorffMeasure_eq_top {s : Set X} {d : ℝ≥0} (h : μH[d] s = ∞) :
    ↑d ≤ dimH s
-- Mathlib/Order/Filter/Basic.lean
theorem compl_not_mem {f : Filter α} {s : Set α} [NeBot f] (h : s ∈ f) : sᶜ ∉ f
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem locallyConvexSpace_iff_zero : LocallyConvexSpace 𝕜 E ↔
    (𝓝 0 : Filter E).HasBasis (fun s : Set E => s ∈ (𝓝 0 : Filter E) ∧ Convex 𝕜 s) id
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem support_map_of_injective (p : MvPolynomial σ R) {f : R →+* S₁} (hf : Injective f) :
    (map f p).support = p.support
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma toMvPolynomial_isHomogeneous (f : M₁ →ₗ[R] M₂) (i : ι₂) :
    (f.toMvPolynomial b₁ b₂ i).IsHomogeneous 1
-- Mathlib/Data/Int/Bitwise.lean
theorem shiftLeft_eq_mul_pow : ∀ (m : ℤ) (n : ℕ), m <<< (n : ℤ) = m * (2 ^ n : ℕ)