ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem Submartingale.sum_sub_upcrossingStrat_mul [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
    (a b : ℝ) (N : ℕ) : Submartingale (fun n : ℕ =>
      ∑ k ∈ Finset.range n, (1 - upcrossingStrat a b f N k) * (f (k + 1) - f k)) ℱ μ
-- Mathlib/NumberTheory/NumberField/Discriminant.lean
/-- **Hermite Theorem**. Let `N` be an integer. There are only finitely many number fields
(in some fixed extension of `ℚ`) of discriminant bounded by `N`. -/
theorem _root_.NumberField.finite_of_discr_bdd :
    {K : { F : IntermediateField ℚ A // FiniteDimensional ℚ F} |
      haveI :  NumberField K := @NumberField.mk _ _ inferInstance K.prop
      |discr K| ≤ N }.Finite
-- Mathlib/Data/Real/GoldenRatio.lean
/-- The geometric sequence `fun n ↦ φ^n` is a solution of `fibRec`. -/
theorem geom_gold_isSol_fibRec : fibRec.IsSolution (φ ^ ·)
-- Mathlib/Order/Filter/Cocardinal.lean
theorem eventually_cocardinal_nmem_of_card_lt  {s : Set α} (hs : #s < c) :
    ∀ᶠ x in cocardinal α hreg, x ∉ s
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_sSup {x : ℝ*} (hni : ¬Infinite x) : IsSt x (sSup { y : ℝ | (y : ℝ*) < x })
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp]
theorem measureUnivNNReal_zero : measureUnivNNReal (0 : Measure α) = 0
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem coe_inv (A : symplecticGroup l R) : (↑A⁻¹ : Matrix _ _ _) = (-J l R) * (↑A)ᵀ * J l R
-- Mathlib/MeasureTheory/Measure/Dirac.lean
/-- The assignment `x ↦ dirac x` is injective, assuming the measurable space separates points. -/
lemma injective_dirac [SeparatesPoints α] :
    Function.Injective (fun (x : α) ↦ dirac x)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem ord_le {c o} : ord c ≤ o ↔ c ≤ o.card
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem mk_zpow (f : α → γ) (hf) (n : ℤ) :
    (mk f hf : α →ₘ[μ] γ) ^ n = mk (f ^ n) ((continuous_zpow n).comp_aestronglyMeasurable hf)
-- Mathlib/Order/LiminfLimsup.lean
theorem HasBasis.limsup_eq_sInf_iUnion_iInter {ι ι' : Type*} {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) :
    limsup f v = sInf (⋃ (j : Subtype p), ⋂ (i : s j), Ici (f i))
-- Mathlib/Topology/Bornology/Constructions.lean
theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem decide_eq_false {b : Bool} [Decidable (b = false)] : decide (b = false) = !b
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem iSup_mem_measurableLE' (f : ℕ → α → ℝ≥0∞) (hf : ∀ n, f n ∈ measurableLE μ ν) (n : ℕ) :
    (⨆ (k) (_ : k ≤ n), f k) ∈ measurableLE μ ν
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousWithinAt_union {f : α → β} {s t : Set α} {x : α} :
    ContinuousWithinAt f (s ∪ t) x ↔ ContinuousWithinAt f s x ∧ ContinuousWithinAt f t x
-- Mathlib/CategoryTheory/Shift/ShiftSequence.lean
@[reassoc (attr := simp 1100)]
lemma shiftIso_hom_naturality {X Y : C} (n a a' : M) (ha' : n + a = a') (f : X ⟶ Y) :
    (shift F a).map (f⟦n⟧') ≫ (shiftIso F n a a' ha').hom.app Y =
      (shiftIso F n a a' ha').hom.app X ≫ (shift F a').map f
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp, fun_prop]
theorem DifferentiableAt.prod (hf₁ : DifferentiableAt 𝕜 f₁ x) (hf₂ : DifferentiableAt 𝕜 f₂ x) :
    DifferentiableAt 𝕜 (fun x : E => (f₁ x, f₂ x)) x
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biprod.map_snd {W X Y Z : C} [HasBinaryBiproduct W X] [HasBinaryBiproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : biprod.map f g ≫ biprod.snd = biprod.snd ≫ g
-- Mathlib/Data/List/ProdSigma.lean
@[simp]
theorem sigma_nil : ∀ l : List α, (l.sigma fun a => @nil (σ a)) = []
-- Mathlib/Data/Set/Lattice.lean
theorem not_mem_of_not_mem_sUnion {x : α} {t : Set α} {S : Set (Set α)} (hx : x ∉ ⋃₀S)
    (ht : t ∈ S) : x ∉ t
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `t n` is a monotone sequence of sets in `𝔖`
such that each `s ∈ 𝔖` is included in some `t n`
and `V n` is an antitone basis of entourages of `β`,
then `UniformOnFun.gen 𝔖 (t n) (V n)` is an antitone basis of entourages of `α →ᵤ[𝔖] β`. -/
protected theorem hasAntitoneBasis_uniformity {ι : Type*} [Preorder ι] [IsDirected ι (· ≤ ·)]
    {t : ι → Set α} {V : ι → Set (β × β)}
    (ht : ∀ n, t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n)
    (hb : HasAntitoneBasis (𝓤 β) V) :
    (𝓤 (α →ᵤ[𝔖] β)).HasAntitoneBasis fun n ↦ UniformOnFun.gen 𝔖 (t n) (V n)
-- Mathlib/Data/Multiset/Basic.lean
theorem inter_add_distrib (s t u : Multiset α) : s ∩ t + u = (s + u) ∩ (t + u)
-- Mathlib/Data/Real/Irrational.lean
theorem of_int_sub (m : ℤ) (h : Irrational (m - x)) : Irrational x
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrix_transpose_apply' (f : M₁ →ₗ[R] M₂) (j : n) :
    (LinearMap.toMatrix v₁ v₂ f)ᵀ j = v₂.repr (f (v₁ j))
-- Mathlib/Data/Complex/BigOperators.lean
@[simp, norm_cast]
theorem ofReal_sum (f : α → ℝ) : ((∑ i ∈ s, f i : ℝ) : ℂ) = ∑ i ∈ s, (f i : ℂ)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_zero_right (x : F) : ⟪x, 0⟫ = 0
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem proj_eq_self {x : I → Bool} (h : ∀ i, x i ≠ false → J i) : Proj J x = x
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma inv_rnDeriv' [SigmaFinite μ] [SigmaFinite ν] (hμν : μ ≪ ν) :
    (ν.rnDeriv μ)⁻¹ =ᵐ[μ] μ.rnDeriv ν
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
protected theorem add {β} [AddMonoid β] {f g : α →ₛ β} (hf : f.FinMeasSupp μ)
    (hg : g.FinMeasSupp μ) : (f + g).FinMeasSupp μ
-- Mathlib/Data/Nat/Factorization/Root.lean
@[simp] lemma ceilRoot_eq_zero : ceilRoot n a = 0 ↔ n = 0 ∨ a = 0
-- Mathlib/Data/Rel.lean
theorem preimage_univ : r.preimage Set.univ = r.dom
-- Mathlib/Data/Multiset/Dedup.lean
theorem le_dedup_self {s : Multiset α} : s ≤ dedup s ↔ Nodup s
-- Mathlib/CategoryTheory/Extensive.lean
theorem FinitaryExtensive.vanKampen [FinitaryExtensive C] {F : Discrete WalkingPair ⥤ C}
    (c : Cocone F) (hc : IsColimit c) : IsVanKampenColimit c
-- Mathlib/Order/LiminfLimsup.lean
theorem bliminf_congr' {f : Filter β} {p q : β → Prop} {u : β → α}
    (h : ∀ᶠ x in f, u x ≠ ⊤ → (p x ↔ q x)) : bliminf u f p = bliminf u f q
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The angle between a vector and the negation of another vector. -/
theorem angle_neg_right (x y : V) : angle x (-y) = π - angle x y
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem enum_cons : (a::as).enum = (0, a) :: as.enumFrom 1
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffOn.sum {ι : Type*} {f : ι → E → F} {s : Finset ι} {t : Set E}
    (h : ∀ i ∈ s, ContDiffOn 𝕜 n (fun x => f i x) t) :
    ContDiffOn 𝕜 n (fun x => ∑ i ∈ s, f i x) t
-- Mathlib/RingTheory/SimpleModule.lean
theorem _root_.LinearMap.isSemisimpleModule_iff_of_bijective (hl : Function.Bijective l) :
    IsSemisimpleModule R M ↔ IsSemisimpleModule S N
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_finset_inf (f : ι → Opens α) (s : Finset ι) : (↑(s.inf f) : Set α) = s.inf ((↑) ∘ f)
-- Mathlib/Data/Finset/Sups.lean
theorem subset_sups {s t : Set α} :
    ↑u ⊆ s ⊻ t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' ⊻ t'
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem eLpNorm'_le_eLpNorm'_mul_rpow_measure_univ {p q : ℝ} (hp0_lt : 0 < p) (hpq : p ≤ q)
    (hf : AEStronglyMeasurable f μ) :
    eLpNorm' f p μ ≤ eLpNorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The (open) thickening of the empty set is empty. -/
@[simp]
theorem thickening_empty (δ : ℝ) : thickening δ (∅ : Set α) = ∅
-- Mathlib/Data/Int/Interval.lean
theorem Ioc_eq_finset_map :
    Ioc a b =
      (Finset.range (b - a).toNat).map (Nat.castEmbedding.trans <| addLeftEmbedding (a + 1))
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp] -- Should be replaced with `SemilinearIsometryClass.nnorm_map` when `lean4#3107` is fixed.
theorem nnnorm_map (x : E) : ‖e x‖₊ = ‖x‖₊
-- Mathlib/Topology/Instances/EReal.lean
lemma limsup_le_iff {b : EReal} : limsup u f ≤ b ↔ ∀ c : ℝ, b < c → ∀ᶠ a : α in f, u a ≤ c
-- Mathlib/GroupTheory/Perm/ClosureSwap.lean
/-- A transitive permutation group generated by transpositions must be the whole symmetric group -/
theorem surjective_of_isSwap_of_isPretransitive [Finite α] (S : Set G)
    (hS1 : ∀ σ ∈ S, Perm.IsSwap (MulAction.toPermHom G α σ)) (hS2 : Subgroup.closure S = ⊤)
    [h : MulAction.IsPretransitive G α] : Function.Surjective (MulAction.toPermHom G α)
-- Mathlib/Order/Monotone/Basic.lean
@[simp] theorem strictAntiOn_univ : StrictAntiOn f Set.univ ↔ StrictAnti f
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem add_mul_limit {a b c : Ordinal} (ba : b + a = a) (l : IsLimit c) : (a + b) * c = a * c
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiff.snd {f : N → M × M'} (hf : ContMDiff J (I.prod I') n f) :
    ContMDiff J I' n fun x => (f x).2
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
lemma restrictionApp_comp (M : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) :
    restrictionApp (f ≫ g) M =
      restrictionApp f M ≫
        (ModuleCat.restrictScalars (R.map f)).map (restrictionApp g M) ≫
        (ModuleCat.restrictScalarsComp' _ _ _ (R.map_comp f g)).inv.app (M.obj Z)
-- Mathlib/Data/ENat/Basic.lean
@[simp]
theorem toNat_ofNat (n : ℕ) [n.AtLeastTwo] : toNat (no_index (OfNat.ofNat n)) = n
-- Mathlib/Data/Nat/ModEq.lean
protected theorem mul_left_cancel_iff' {a b c m : ℕ} (hc : c ≠ 0) :
    c * a ≡ c * b [MOD c * m] ↔ a ≡ b [MOD m]
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma eq_nil_of_isRegular_on_artinian [IsArtinian R M] :
    {rs : List R} → IsRegular M rs → rs = []
-- Mathlib/Order/Heyting/Basic.lean
theorem disjoint_compl_left : Disjoint aᶜ a
-- Mathlib/NumberTheory/SmoothNumbers.lean
lemma mem_primesBelow {k n : ℕ} :
    n ∈ primesBelow k ↔ n < k ∧ n.Prime
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMaxOn.sub (hf : IsLocalMaxOn f s a) (hg : IsLocalMinOn g s a) :
    IsLocalMaxOn (fun x => f x - g x) s a
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_sup {κ : ι → Type*} (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    (s.inf fun i => (t i).sup (f i)) =
      (s.pi t).sup fun g => s.attach.inf fun i => f _ <| g _ i.2
-- Mathlib/Data/Seq/WSeq.lean
theorem eq_or_mem_iff_mem {s : WSeq α} {a a' s'} :
    some (a', s') ∈ destruct s → (a ∈ s ↔ a = a' ∨ a ∈ s')
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem union_mem_iff : s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem ceil_lt_mul {x : ℝ} (hx : 50 / 19 ≤ x) : (⌈x⌉₊ : ℝ) < 1.38 * x
-- Mathlib/Geometry/Manifold/MFDeriv/Defs.lean
/-- Being differentiable in the model space is a local property, invariant under smooth maps.
Therefore, it will lift nicely to manifolds. -/
theorem differentiable_within_at_localInvariantProp :
    (contDiffGroupoid ⊤ I).LocalInvariantProp (contDiffGroupoid ⊤ I')
      (DifferentiableWithinAtProp I I')
-- Mathlib/Algebra/Ring/Invertible.lean
@[simp]
theorem invOf_two_add_invOf_two [NonAssocSemiring α] [Invertible (2 : α)] :
    (⅟ 2 : α) + (⅟ 2 : α) = 1
-- Mathlib/Algebra/Module/Opposites.lean
theorem opLinearEquiv_symm_toAddEquiv :
    (opLinearEquiv R : M ≃ₗ[R] Mᵐᵒᵖ).symm.toAddEquiv = opAddEquiv.symm
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem comp_id (f : C(α, β)) : f.comp (ContinuousMap.id _) = f
-- Mathlib/Algebra/GroupWithZero/WithZero.lean
@[norm_cast] lemma coe_div (a b : α) : ↑(a / b : α) = (a / b : WithZero α)
-- Mathlib/Data/Set/Image.lean
/-- A common special case of `image_congr` -/
theorem image_congr' {f g : α → β} {s : Set α} (h : ∀ x : α, f x = g x) : f '' s = g '' s
-- Mathlib/Data/Set/Card.lean
theorem finite_of_ncard_ne_zero (hs : s.ncard ≠ 0) : s.Finite
-- Mathlib/Order/Minimal.lean
theorem maximals_union : maximals r (s ∪ t) ⊆ maximals r s ∪ maximals r t
-- Mathlib/Logic/Equiv/Basic.lean
theorem subtypeEquivCodomain_symm_apply_eq (f : { x' // x' ≠ x } → Y) (y : Y) :
    ((subtypeEquivCodomain f).symm y : X → Y) x = y
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_cubic (ha : a ≠ 0) : degree (C a * X ^ 3 + C b * X ^ 2 + C c * X + C d) = 3
-- Mathlib/Data/List/Infix.lean
theorem tails_cons (a : α) (l : List α) : tails (a :: l) = (a :: l) :: l.tails
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma sInf_iUnion_Ici (f : ι → α) : sInf (⋃ (i : ι), Ici (f i)) = ⨅ i, f i
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_eq_one {o} : card o = 1 ↔ o = 1
-- Mathlib/Topology/Constructions.lean
theorem nhds_inr (y : Y) : 𝓝 (inr y : X ⊕ Y) = map inr (𝓝 y)
-- Mathlib/NumberTheory/KummerDedekind.lean
theorem conductor_subset_adjoin : (conductor R x : Set S) ⊆ R<x>
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem Monic.coeff_natDegree {p : R[X]} (hp : p.Monic) : p.coeff p.natDegree = 1
-- Mathlib/CategoryTheory/ComposableArrows.lean
/-- Constructor for isomorphisms in `ComposableArrows C 4`. -/
@[simps]
def isoMk₄ {f g : ComposableArrows C 4}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (app₃ : f.obj' 3 ≅ g.obj' 3) (app₄ : f.obj' 4 ≅ g.obj' 4)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4) :
    f ≅ g
-- Mathlib/Algebra/Algebra/Equiv.lean
/-- An equivalence of algebras is an equivalence of rings commuting with the actions of scalars. -/
structure AlgEquiv (R : Type u) (A : Type v) (B : Type w) [CommSemiring R] [Semiring A] [Semiring B]
  [Algebra R A] [Algebra R B] extends A ≃ B, A ≃* B, A ≃+ B, A ≃+* B where
  /-- An equivalence of algebras commutes with the action of scalars. -/
  protected commutes' : ∀ r : R, toFun (algebraMap R A r) = algebraMap R B r
-- Mathlib/LinearAlgebra/Basis.lean
protected theorem injective [Nontrivial R] : Injective b
-- Mathlib/Data/List/Nodup.lean
protected theorem Nodup.sublist : l₁ <+ l₂ → Nodup l₂ → Nodup l₁
-- Mathlib/Data/Finset/Preimage.lean
theorem image_preimage [DecidableEq β] (f : α → β) (s : Finset β) [∀ x, Decidable (x ∈ Set.range f)]
    (hf : Set.InjOn f (f ⁻¹' ↑s)) : image f (preimage s f hf) = s.filter fun x => x ∈ Set.range f
-- Mathlib/Data/Nat/Nth.lean
theorem nth_strictMono (hf : (setOf p).Infinite) : StrictMono (nth p)
-- Mathlib/LinearAlgebra/TensorPower.lean
theorem algebraMap₀_mul {n} (r : R) (a : ⨂[R]^n M) :
    cast R M (zero_add _) (algebraMap₀ r ₜ* a) = r • a
-- Mathlib/Algebra/Category/CoalgebraCat/Basic.lean
@[simp] theorem toCoalgEquiv_refl : toCoalgEquiv (.refl X) = .refl _ _
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem coprime_add_mul_right_left (m n k : ℕ) : Coprime (m + k * n) n ↔ Coprime m n
-- .lake/packages/lean4/src/lean/Init/GetElem.lean
theorem outOfBounds_eq_default [Inhabited α] : (outOfBounds : α) = default
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem subtype_mk (hf : LipschitzWith K f) {p : β → Prop} (hp : ∀ x, p (f x)) :
    LipschitzWith K (fun x => ⟨f x, hp x⟩ : α → { y // p y })
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem cauchy_nhds {a : α} : Cauchy (𝓝 a)
-- Mathlib/Analysis/Oscillation.lean
/-- If `oscillationWithin f D x < ε` at every `x` in a compact set `K`, then there exists `δ > 0`
such that the oscillation of `f` on `ball x δ ∩ D` is less than `ε` for every `x` in `K`. -/
theorem uniform_oscillationWithin (hK : ∀ x ∈ K, oscillationWithin f D x < ε) :
    ∃ δ > 0, ∀ x ∈ K, diam (f '' (ball x (ENNReal.ofReal δ) ∩ D)) ≤ ε
-- Mathlib/Analysis/Normed/Operator/Banach.lean
lemma closed_range_of_antilipschitz {f : E →SL[σ] F} {c : ℝ≥0} (hf : AntilipschitzWith c f) :
    (LinearMap.range f).topologicalClosure = LinearMap.range f
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- If a vector space (or module) has a finite basis, then its dimension (or rank) is equal to the
cardinality of the basis. -/
theorem finrank_eq_card_basis {ι : Type w} [Fintype ι] (h : Basis ι R M) :
    finrank R M = Fintype.card ι
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
/--
An object `J` is injective iff every morphism into `J` can be obtained by extending a monomorphism.
-/
class Injective (J : C) : Prop where
  factors : ∀ {X Y : C} (g : X ⟶ J) (f : X ⟶ Y) [Mono f], ∃ h : Y ⟶ J, f ≫ h = g
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_le_zero_iff : degree p ≤ 0 ↔ p = C (coeff p 0)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem map_orElse {x y : Option α} : (x <|> y).map f = (x.map f <|> y.map f)
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Dense.Ioi_eq_biUnion [DenselyOrdered α] {s : Set α} (hs : Dense s) (x : α) :
    Ioi x = ⋃ y ∈ s ∩ Ioi x, Ioi y
-- Mathlib/Analysis/Distribution/AEEqOfIntegralContDiff.lean
/-- If a locally integrable function `f` on a finite-dimensional real vector space has zero integral
when multiplied by any smooth compactly supported function, then `f` vanishes almost everywhere. -/
theorem ae_eq_zero_of_integral_contDiff_smul_eq_zero (hf : LocallyIntegrable f μ)
    (h : ∀ (g : E → ℝ), ContDiff ℝ ⊤ g → HasCompactSupport g → ∫ x, g x • f x ∂μ = 0) :
    ∀ᵐ x ∂μ, f x = 0
-- Mathlib/Algebra/Homology/HomologySequence.lean
/-- The natural transformation `K.opcyclesToCycles i j : K.opcycles i ⟶ K.cycles j` for all
`K : HomologicalComplex C c`. -/
@[simps]
noncomputable def natTransOpCyclesToCycles [CategoryWithHomology C] :
    opcyclesFunctor C c i ⟶ cyclesFunctor C c j
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem newton_seq_norm_tendsto_zero :
    Tendsto (fun i => ‖F.eval (newton_cau_seq hnorm i)‖) atTop (𝓝 0)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem iSup_continuous {ι : Sort*} {f : ι → α →o β} (h : ∀ i, Continuous (f i)) :
    Continuous (⨆ i, f i)
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem rOut_pos {c : E} (f : ContDiffBump c) : 0 < f.rOut
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem self_mem_range_succ (n : Nat) : n ∈ range (n + 1)
-- Mathlib/GroupTheory/Coxeter/Matrix.lean
theorem reindex_apply (i i' : B') : M.reindex e i i' = M (e.symm i) (e.symm i')
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem add_le_gt (a : Nat) {b c : Nat} (h : b > c) : (a + b ≤ c) = False
-- Mathlib/LinearAlgebra/Matrix/Circulant.lean
theorem map_circulant [Sub n] (v : n → α) (f : α → β) :
    (circulant v).map f = circulant fun i => f (v i)
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem eval_map (S : Type uᵒᵖ ⥤ Type u) (α β) (f : β ⟶ α) (s x) :
    eval S β (S.map f.op s) x = eval S α s (f x)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem comp_factorThruImage_eq_zero {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [HasImage g]
    (h : f ≫ g = 0) : f ≫ factorThruImage g = 0
-- Mathlib/Data/Int/GCD.lean
theorem exists_gcd_one {m n : ℤ} (H : 0 < gcd m n) :
    ∃ m' n' : ℤ, gcd m' n' = 1 ∧ m = m' * gcd m n ∧ n = n' * gcd m n
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
/-- Some ordinal approximation of the greatest fixed point is the greatest fixed point. -/
theorem gfp_mem_range_gfpApprox : gfp f ∈ Set.range (gfpApprox f ⊤)
-- Mathlib/Data/Finset/Lattice.lean
protected theorem Nonempty.inf_eq_bot_iff {α : Type*} [LinearOrder α] [BoundedOrder α]
    {s : Finset ι} {f : ι → α} (h : s.Nonempty) : s.inf f = ⊥ ↔ ∃ b ∈ s, f b = ⊥
-- Mathlib/Data/DFinsupp/Lex.lean
theorem _root_.Pi.lex_eq_dfinsupp_lex {r : ι → ι → Prop} {s : ∀ i, α i → α i → Prop}
    (a b : Π₀ i, α i) : Pi.Lex r (s _) (a : ∀ i, α i) b = DFinsupp.Lex r s a b
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxOn.on_subset (hf : IsMaxOn f t a) (h : s ⊆ t) : IsMaxOn f s a
-- Mathlib/Order/Interval/Set/Image.lean
lemma Monotone.image_Ici_subset (h : Monotone f) : f '' Ici a ⊆ Ici (f a)
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
private lemma aux (hm : m ≠ 0) (hkmn : m * k ≤ n) : k < (n + 1)
-- Mathlib/Algebra/Ring/Defs.lean
theorem boole_mul {α} [MulZeroOneClass α] (P : Prop) [Decidable P] (a : α) :
    (if P then 1 else 0) * a = if P then a else 0
-- Mathlib/Data/Fintype/Sum.lean
/-- Any injection from a finset `s` in a fintype `α` to a finset `t` of the same cardinality as `α`
can be extended to a bijection between `α` and `t`. -/
theorem Finset.exists_equiv_extend_of_card_eq [Fintype α] [DecidableEq β] {t : Finset β}
    (hαt : Fintype.card α = t.card) {s : Finset α} {f : α → β} (hfst : Finset.image f s ⊆ t)
    (hfs : Set.InjOn f s) : ∃ g : α ≃ t, ∀ i ∈ s, (g i : β) = f i
-- Mathlib/Data/Complex/Abs.lean
@[simp]
lemma abs_re_eq_abs {z : ℂ} : |z.re| = abs z ↔ z.im = 0
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem comap_comp (f : R →+* S) (g : S →+* P) (U : Opens (PrimeSpectrum.Top R))
    (V : Opens (PrimeSpectrum.Top S)) (W : Opens (PrimeSpectrum.Top P))
    (hUV : ∀ p ∈ V, PrimeSpectrum.comap f p ∈ U) (hVW : ∀ p ∈ W, PrimeSpectrum.comap g p ∈ V) :
    (comap (g.comp f) U W fun p hpW => hUV (PrimeSpectrum.comap g p) (hVW p hpW)) =
      (comap g V W hVW).comp (comap f U V hUV)
-- Mathlib/Topology/PartialHomeomorph.lean
theorem nhdsWithin_target_inter {x} (hx : x ∈ e.target) (s : Set Y) : 𝓝[e.target ∩ s] x = 𝓝[s] x
-- Mathlib/Analysis/Complex/Basic.lean
@[norm_cast]
theorem ofReal_tsum (f : α → ℝ) : (↑(∑' a, f a) : 𝕜) = ∑' a, (f a : 𝕜)
-- Mathlib/Topology/Instances/AddCircle.lean
theorem continuous_left_toIocMod : ContinuousWithinAt (toIocMod hp a) (Iic x) x
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem mk_list_eq_mk (α : Type u) [Infinite α] : #(List α) = #α
-- Mathlib/LinearAlgebra/Basis.lean
theorem repr_eq_iff {b : Basis ι R M} {f : M →ₗ[R] ι →₀ R} :
    ↑b.repr = f ↔ ∀ i, f (b i) = Finsupp.single i 1
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem coe_comp (g : β →ᵈ γ) (f : α →ᵈ β) : (g.comp f : α → γ) = g ∘ f
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem hasMFDerivAt_unique (h₀ : HasMFDerivAt I I' f x f₀') (h₁ : HasMFDerivAt I I' f x f₁') :
    f₀' = f₁'
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem Matrix.toBilin_symm : (Matrix.toBilin b).symm = BilinForm.toMatrix b
-- Mathlib/Analysis/LocallyConvex/Polar.lean
@[simp]
theorem polar_union {s t : Set E} : B.polar (s ∪ t) = B.polar s ∩ B.polar t
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem nonneg_mul_lem {x y : ℕ} {a : ℤ√d} (ha : Nonneg a) : Nonneg (⟨x, y⟩ * a)
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simp]
theorem leftUnitor_inv_apply {M : ModuleCat.{u} R} (m : M) :
    ((λ_ M).inv : M ⟶ 𝟙_ (ModuleCat.{u} R) ⊗ M) m = 1 ⊗ₜ[R] m
-- Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean
theorem hσ'_eq' {q n a : ℕ} (ha : n = a + q) :
    (hσ' q n (n + 1) rfl : X _[n] ⟶ X _[n + 1]) =
      (-1 : ℤ) ^ a • X.σ ⟨a, Nat.lt_succ_iff.mpr (Nat.le.intro (Eq.symm ha))⟩
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem toDual_iInf (f : ι → α) : toDual (⨅ i, f i) = ⨆ i, toDual (f i)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpL2_ae_eq_zero_of_ae_eq_zero (hs : MeasurableSet[m] s) (hμs : μ s ≠ ∞) {f : Lp ℝ 2 μ}
    (hf : f =ᵐ[μ.restrict s] 0) : condexpL2 ℝ ℝ hm f =ᵐ[μ.restrict s] (0 : α → ℝ)
-- Mathlib/MeasureTheory/PiSystem.lean
theorem IsPiSystem.comap {α β} {S : Set (Set β)} (h_pi : IsPiSystem S) (f : α → β) :
    IsPiSystem { s : Set α | ∃ t ∈ S, f ⁻¹' t = s }
-- Mathlib/Order/MinMax.lean
theorem max_lt_max_right_iff : max a b < max a c ↔ b < c ∧ a < c
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem lift_mk (g : R[X]) : lift i a h (mk f g) = g.eval₂ i a
-- Mathlib/Order/Lattice.lean
theorem min_min_min_comm : min (min a b) (min c d) = min (min a c) (min b d)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem cancel_left {g : sInfHom β γ} {f₁ f₂ : sInfHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/CategoryTheory/Shift/Opposite.lean
lemma oppositeShiftFunctorZero_inv_app (X : OppositeShift C A) :
    (shiftFunctorZero (OppositeShift C A) A).inv.app X =
      ((shiftFunctorZero C A).hom.app X.unop).op
-- Mathlib/RingTheory/Bialgebra/Basic.lean
lemma counit_mul (a b : A) : counit (R := R) (a * b) = counit a * counit b