ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Category/LightProfinite/Limits.lean
lemma finiteCoproduct.ι_desc_apply {B : LightProfinite} {π : (a : α) → X a ⟶ B} (a : α) :
    ∀ x, finiteCoproduct.desc X π (finiteCoproduct.ι X a x) = π a x
-- Mathlib/Topology/Homotopy/Basic.lean
/-- Casting a `HomotopyWith f₀ f₁ P` to a `HomotopyWith g₀ g₁ P` where `f₀ = g₀` and `f₁ = g₁`.
-/
@[simps!]
def cast {f₀ f₁ g₀ g₁ : C(X, Y)} (F : HomotopyWith f₀ f₁ P) (h₀ : f₀ = g₀) (h₁ : f₁ = g₁) :
    HomotopyWith g₀ g₁ P
-- Mathlib/Data/List/Destutter.lean
theorem destutter_cons' : (a :: l).destutter R = destutter' R a l
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem mk_self : mk f f = 0
-- Mathlib/RingTheory/Ideal/Over.lean
theorem exists_coeff_ne_zero_mem_comap_of_root_mem [IsDomain S] {r : S} (r_ne_zero : r ≠ 0)
    (hr : r ∈ I) {p : R[X]} :
    p ≠ 0 → p.eval₂ f r = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ I.comap f
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[simp, measurability]
theorem measurableSet_Ico : MeasurableSet (Ico a b)
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
/-- Weak version of the main theorem on differentiation of measures: given a Vitali family `v`
for a locally finite measure `μ`, and another locally finite measure `ρ`, then for `μ`-almost
every `x` the ratio `ρ a / μ a` converges, when `a` shrinks to `x` along the Vitali family,
towards the Radon-Nikodym derivative of `ρ` with respect to `μ`.

This version assumes that `ρ` is absolutely continuous with respect to `μ`. The general version
without this superfluous assumption is `VitaliFamily.ae_tendsto_rnDeriv`.
-/
theorem ae_tendsto_rnDeriv_of_absolutelyContinuous :
    ∀ᵐ x ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (ρ.rnDeriv μ x))
-- Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean
theorem of_eq :
    of V = (Quiver.Symmetrify.of ⋙q Paths.of).comp
      (Quotient.functor <| @redStep V _).toPrefunctor
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem comap_top (f : α → β) : comap f ⊤ = ⊤
-- Mathlib/Data/Nat/Defs.lean
protected lemma div_le_of_le_mul' (h : m ≤ k * n) : m / k ≤ n
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
lemma tendsto_riemannZeta_sub_one_div_Gammaℝ :
    Tendsto (fun s ↦ riemannZeta s - 1 / Gammaℝ s / (s - 1)) (𝓝[≠] 1)
    (𝓝 ((γ - Complex.log (4 * ↑π)) / 2))
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_one_add (a b : Ordinal) : a ^ (1 + b) = a * a ^ b
-- Mathlib/RingTheory/Localization/Submodule.lean
@[simp]
theorem coeSubmodule_top : coeSubmodule S (⊤ : Ideal R) = 1
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem isCycle_cycleOf (f : Perm α) [DecidableRel f.SameCycle] (hx : f x ≠ x) :
    IsCycle (cycleOf f x)
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem extendScalars_toSubfield : (extendScalars h).toSubfield = E
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
/-- A dependent version of `NonUnitalAlgebra.adjoin_induction`. -/
theorem adjoin_induction' {s : Set A} {p : ∀ x, x ∈ adjoin R s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_adjoin R h))
    (add : ∀ x hx y hy, p x hx → p y hy → p (x + y) (add_mem ‹_› ‹_›))
    (zero : p 0 (zero_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem ‹_› ‹_›))
    (smul : ∀ (r : R) (x hx), p x hx → p (r • x) (SMulMemClass.smul_mem _ ‹_›))
    {a} (ha : a ∈ adjoin R s) : p a ha
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem coe_zero_linearMap : ↑(0 : Derivation R A M) = (0 : A →ₗ[R] M)
-- Mathlib/Data/PNat/Find.lean
@[simp]
theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m
-- Mathlib/NumberTheory/ModularForms/SlashActions.lean
private theorem zero_slash (k : ℤ) (A : GL(2, ℝ)⁺) : (0 : ℍ → ℂ) ∣[k]A = 0
-- Mathlib/Algebra/PUnitInstances/Algebra.lean
@[to_additive (attr := simp)]
theorem div_eq {x y : PUnit} : x / y = unit
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
lemma associated_sq : associated (R := R) sq = mul R R
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem ofInt_num : (ofInt n : Rat).num = n
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_eq_tprod_of_ne_one_bij {g : γ → α} (i : mulSupport g → β) (hi : Injective i)
    (hf : mulSupport f ⊆ Set.range i) (hfg : ∀ x, f (i x) = g x) : ∏' x, f x = ∏' y, g y
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
/-- A graph embedding induces an embedding of neighbor sets. -/
@[simps]
def mapNeighborSet (v : V) : G.neighborSet v ↪ G'.neighborSet (f v)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDerivWithin_zero_eq_comp :
    iteratedFDerivWithin 𝕜 0 f s = (continuousMultilinearCurryFin0 𝕜 E F).symm ∘ f
-- Mathlib/Topology/Basic.lean
/-- The set of cluster points of a filter is closed. In particular, the set of limit points
of a sequence is closed. -/
theorem isClosed_setOf_clusterPt {f : Filter X} : IsClosed { x | ClusterPt x f }
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
@[simp]
theorem ae_eq_empty : s =ᵐ[μ] (∅ : Set α) ↔ μ s = 0
-- Mathlib/Data/Int/Cast/Basic.lean
@[simp, norm_cast]
theorem cast_pred : ∀ {n}, 0 < n → ((n - 1 : ℕ) : R) = n - 1
-- Mathlib/Order/BoundedOrder.lean
theorem top_sup_eq (a : α) : ⊤ ⊔ a = ⊤
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_pow [Monoid M] (f : α → M) (n : ℕ) :
    (mulSupport fun x => f x ^ n) ⊆ mulSupport f
-- Mathlib/Algebra/Algebra/Operations.lean
protected theorem map_one {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    map f.toLinearMap (1 : Submodule R A) = 1
-- Mathlib/Data/List/Cycle.lean
theorem prev_next (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
    prev l (next l x hx) (next_mem _ _ _) = x
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
theorem invOneSubPow_inv_eq_one_sub_pow :
    (invOneSubPow d).inv = (1 - X : S⟦X⟧) ^ (d + 1)
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem map_mul' (f : α → β) (x y : FreeMagma α) : f <$> (x * y) = f <$> x * f <$> y
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- Typeclass for multiplicative actions by monoids. This generalizes group actions. -/
@[to_additive (attr := ext)]
class MulAction (α : Type*) (β : Type*) [Monoid α] extends SMul α β where
  /-- One is the neutral element for `•` -/
  protected one_smul : ∀ b : β, (1 : α) • b = b
  /-- Associativity of `•` and `*` -/
  mul_smul : ∀ (x y : α) (b : β), (x * y) • b = x • y • b
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem tensorUnit_mul : (𝟙_ (Mon_ C)).mul = (λ_ (𝟙_ C)).hom
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem isBridge_iff_adj_and_forall_cycle_not_mem {v w : V} : G.IsBridge s(v, w) ↔
    G.Adj v w ∧ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → s(v, w) ∉ p.edges
-- Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
/-- The usual sheaf condition can be obtained from the sheaf condition
in terms of unique gluings.
-/
theorem isSheaf_of_isSheafUniqueGluing_types (Fsh : F.IsSheafUniqueGluing) : F.IsSheaf
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
/-- If `f (g y) = y` for `y` in some neighborhood of `a`, `g` is continuous at `a`, and `f` has an
invertible derivative `f'` at `g a`, then `g` has the derivative `f'⁻¹` at `a`.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. -/
theorem HasFDerivAt.of_local_left_inverse {f : E → F} {f' : E ≃L[𝕜] F} {g : F → E} {a : F}
    (hg : ContinuousAt g a) (hf : HasFDerivAt f (f' : E →L[𝕜] F) (g a))
    (hfg : ∀ᶠ y in 𝓝 a, f (g y) = y) : HasFDerivAt g (f'.symm : F →L[𝕜] E) a
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finAddFlip_apply_mk_left {k : ℕ} (h : k < m) (hk : k < m + n := Nat.lt_add_right n h)
    (hnk : n + k < n + m := Nat.add_lt_add_left h n) :
    finAddFlip (⟨k, hk⟩ : Fin (m + n)) = ⟨n + k, hnk⟩
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigOWith_pure {x} : IsBigOWith c (pure x) f g ↔ ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
@[simp]
theorem trace_zero : trace (0 : Matrix n n R) = 0
-- Mathlib/Algebra/Quaternion.lean
@[norm_cast, simp]
theorem coe_div (x y : R) : ((x / y : R) : ℍ[R]) = x / y
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fib_succ_eq_sum_choose :
    ∀ n : ℕ, fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, choose p.1 p.2
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda_inv_comp_π [HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda F A).inv ≫ (coyoneda.map (colimit.ι F i).op).app A
      = limit.π (F.op ⋙ yoneda.obj A) ⟨i⟩
-- Mathlib/Data/Nat/Cast/Basic.lean
theorem Sum.elim_natCast_natCast {α β γ : Type*} [NatCast γ] (n : ℕ) :
    Sum.elim (n : α → γ) (n : β → γ) = n
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.epi_f' (hS : S.Exact) (h : LeftHomologyData S) : Epi h.f'
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
/-- **Fermat's Theorem**: the derivative of a function at a local extremum equals zero. -/
theorem IsLocalExtr.hasFDerivAt_eq_zero (h : IsLocalExtr f a) : HasFDerivAt f f' a → f' = 0
-- Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean
theorem congr_reverse_comp {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :
    Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p.reverse ≫ p) =
      Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 Y)
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_mono_measure {f : α → β} (hμν : ν ≪ μ) : essSup f ν ≤ essSup f μ
-- Mathlib/Topology/Algebra/Constructions.lean
@[to_additive]
theorem continuous_val : Continuous ((↑) : Mˣ → M)
-- Mathlib/Algebra/Order/Ring/Cast.lean
@[simp] lemma toLex_intCast [IntCast R] (n : ℤ) : toLex (n : R) = n
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- Any cocone morphism between colimit cocones is an isomorphism. -/
theorem hom_isIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) (f : s ⟶ t) : IsIso f
-- Mathlib/Data/Nat/Defs.lean
@[simp]
lemma leRec_succ {n} {motive : (m : ℕ) → n ≤ m → Sort*}
    (refl : motive n le_rfl)
    (le_succ_of_le : ∀ ⦃k⦄ (h : n ≤ k), motive k h → motive (k + 1) (le_succ_of_le h))
    (h1 : n ≤ m) {h2 : n ≤ m + 1} :
    (leRec (motive := motive) refl le_succ_of_le h2) =
      le_succ_of_le h1 (leRec (motive := motive) refl le_succ_of_le h1)
-- Mathlib/CategoryTheory/Sites/Plus.lean
@[simp]
theorem isoToPlus_hom (hP : Presheaf.IsSheaf J P) : (J.isoToPlus P hP).hom = J.toPlus P
-- Mathlib/Data/Finsupp/Order.lean
@[simp]
theorem inf_apply [SemilatticeInf α] {i : ι} {f g : ι →₀ α} : (f ⊓ g) i = f i ⊓ g i
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem QuotientGroup.continuous_smul₁ (x : G ⧸ Γ) : Continuous fun g : G => g • x
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_of_measurable_on_compl_finite [MeasurableSingletonClass α] {f : α → β}
    (s : Set α) (hs : s.Finite) (hf : Measurable (sᶜ.restrict f)) : Measurable f
-- Mathlib/Analysis/Convex/Body.lean
@[ext]
protected theorem ext {K L : ConvexBody V} (h : (K : Set V) = L) : K = L
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTransposeAddEquiv_symm [AddMonoid α] [StarAddMonoid α] :
    (conjTransposeAddEquiv m n α).symm = conjTransposeAddEquiv n m α
-- Mathlib/NumberTheory/Cyclotomic/Discriminant.lean
/-- If `p` is a prime and `IsCyclotomicExtension {p ^ (k + 1)} K L`, then the discriminant of
`hζ.powerBasis K` is `(-1) ^ ((p ^ (k + 1).totient) / 2) * p ^ (p ^ k * ((p - 1) * (k + 1) - 1))`
if `Irreducible (cyclotomic (p ^ (k + 1)) K))`, and `p ^ (k + 1) ≠ 2`. -/
theorem discr_prime_pow_ne_two [IsCyclotomicExtension {p ^ (k + 1)} K L] [hp : Fact (p : ℕ).Prime]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))) (hirr : Irreducible (cyclotomic (↑(p ^ (k + 1)) : ℕ) K))
    (hk : p ^ (k + 1) ≠ 2) : discr K (hζ.powerBasis K).basis =
      (-1) ^ ((p ^ (k + 1) : ℕ).totient / 2) * p ^ ((p : ℕ) ^ k * ((p - 1) * (k + 1) - 1))
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- The function `cosKernel a - 1` has exponential decay at `+∞`, for any `a`. -/
lemma isBigO_atTop_cosKernel_sub (a : UnitAddCircle) :
    ∃ p, 0 < p ∧ IsBigO atTop (cosKernel a · - 1) (fun x ↦ Real.exp (-p * x))
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_le_map_iff_of_injective (p q : Submodule R M) : p.map f ≤ q.map f ↔ p ≤ q
-- Mathlib/Topology/Instances/Discrete.lean
theorem discreteTopology_iff_orderTopology_of_pred_succ' [PartialOrder α] [PredOrder α]
    [SuccOrder α] [NoMinOrder α] [NoMaxOrder α] : DiscreteTopology α ↔ OrderTopology α
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
theorem pullback_map_diagonal_isPullback :
    IsPullback (pullback.fst _ _ ≫ f)
      (pullback.map f g (f ≫ i) (g ≫ i) _ _ i (Category.id_comp _).symm (Category.id_comp _).symm)
      (diagonal i)
      (pullback.map (f ≫ i) (g ≫ i) i i f g (𝟙 _) (Category.comp_id _) (Category.comp_id _))
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem lift_single (F : Multiplicative G →* A) (a b) :
    lift k G A F (single a b) = b • F (Multiplicative.ofAdd a)
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem add_bind : (s + t).bind f = s.bind f + t.bind f
-- Mathlib/Analysis/Complex/HalfPlane.lean
/-- An open left half-plane (with boundary real part given by an `EReal`) is an open set
in the complex plane. -/
lemma isOpen_re_lt_EReal (x : EReal) : IsOpen {z : ℂ | z.re < x}
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem abs_tendsto_atTop_iff : Tendsto (fun x => abs <| eval x P) atTop atTop ↔ 0 < P.degree
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem le_of_lt_succFn (j i : ι) (hij : j < succFn i) : j ≤ i
-- Mathlib/Analysis/Complex/Schwarz.lean
/-- Equality case in the **Schwarz Lemma**: in the setup of `norm_dslope_le_div_of_mapsTo_ball`, if
`‖dslope f c z₀‖ = R₂ / R₁` holds at a point in the ball then the map `f` is affine. -/
theorem affine_of_mapsTo_ball_of_exists_norm_dslope_eq_div [CompleteSpace E] [StrictConvexSpace ℝ E]
    (hd : DifferentiableOn ℂ f (ball c R₁)) (h_maps : Set.MapsTo f (ball c R₁) (ball (f c) R₂))
    (h_z₀ : z₀ ∈ ball c R₁) (h_eq : ‖dslope f c z₀‖ = R₂ / R₁) :
    Set.EqOn f (fun z => f c + (z - c) • dslope f c z₀) (ball c R₁)
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem top_eq_true : ⊤ = true
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- The function `x ^ (-y)` tends to `0` at `+∞` for any positive real `y`. -/
theorem tendsto_rpow_neg_atTop {y : ℝ} (hy : 0 < y) : Tendsto (fun x : ℝ => x ^ (-y)) atTop (𝓝 0)
-- Mathlib/Order/Max.lean
/-- Order without minimal elements. Sometimes called coinitial or dense. -/
class NoMinOrder (α : Type*) [LT α] : Prop where
  /-- For each term `a`, there is some strictly smaller `b`. -/
  exists_lt (a : α) : ∃ b, b < a
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma changeLevel_trans {m d : ℕ} (hm : n ∣ m) (hd : m ∣ d) :
    changeLevel (dvd_trans hm hd) χ = changeLevel hd (changeLevel hm χ)
-- Mathlib/Data/List/EditDistance/Defs.lean
theorem suffixLevenshtein_cons₁_aux {x y : {r : List δ // 0 < r.length}}
    (w₀ : x.1[0]'x.2 = y.1[0]'y.2) (w : x.1.tail = y.1.tail) : x = y
-- Mathlib/LinearAlgebra/Prod.lean
@[simp] theorem snd_comp_inr : snd R M M₂ ∘ₗ inr R M M₂ = id
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arccos_of_one_le {x : ℝ} (hx : 1 ≤ x) : arccos x = 0
-- Mathlib/Topology/Connected/Clopen.lean
@[simp]
theorem range_coe : range (mk : α → ConnectedComponents α) = univ
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem iterate_derivative_intCast_mul {n : ℤ} {k : ℕ} {f : R[X]} :
    derivative^[k] ((n : R[X]) * f) = n * derivative^[k] f
-- Mathlib/Topology/MetricSpace/CauSeqFilter.lean
/-- In a normed field, `CauSeq` coincides with the usual notion of Cauchy sequences. -/
theorem isCauSeq_iff_cauchySeq {α : Type u} [NormedField α] {u : ℕ → α} :
    IsCauSeq norm u ↔ CauchySeq u
-- Mathlib/Logic/Function/Basic.lean
protected theorem Surjective.forall₃ (hf : Surjective f) {p : β → β → β → Prop} :
    (∀ y₁ y₂ y₃, p y₁ y₂ y₃) ↔ ∀ x₁ x₂ x₃, p (f x₁) (f x₂) (f x₃)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- A non-unital subsemiring `S` includes `closure s` if and only if it includes `s`. -/
@[simp]
theorem closure_le {s : Set R} {t : NonUnitalSubsemiring R} : closure s ≤ t ↔ s ⊆ t
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem not_nontrivial_empty : ¬ (∅ : Finset α).Nontrivial
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothOn_coordChangeL :
    SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun b : B => (e.coordChangeL 𝕜 e' b : F →L[𝕜] F))
      (e.baseSet ∩ e'.baseSet)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- Multiplicative inverse of a rational function. -/
protected irreducible_def inv : RatFunc K → RatFunc K
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, norm_cast]
lemma ofReal_nonpos {x : ℝ} : (x : K) ≤ 0 ↔ x ≤ 0
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem Multipliable.vanishing (hf : Multipliable f) ⦃e : Set G⦄ (he : e ∈ 𝓝 (1 : G)) :
    ∃ s : Finset α, ∀ t, Disjoint t s → (∏ k ∈ t, f k) ∈ e
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
@[simp]
theorem totalDegree_neg (a : MvPolynomial σ R) : (-a).totalDegree = a.totalDegree
-- Mathlib/Data/List/Rotate.lean
theorem rotate_eq_self_iff_eq_replicate [hα : Nonempty α] :
    ∀ {l : List α}, (∀ n, l.rotate n = l) ↔ ∃ a, l = replicate l.length a
-- Mathlib/Order/Iterate.lean
theorem iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
    (hx : f x < g x) {n} (hn : 0 < n) : f^[n] x < g^[n] x
-- Mathlib/Order/Closure.lean
theorem le_closure_iff : x ≤ c y ↔ c x ≤ c y
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
theorem summable_of_isBigO_nat' {E F : Type*} [NormedAddCommGroup E] [CompleteSpace E]
    [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] {f : ℕ → E} {g : ℕ → F}
    (hg : Summable g) (h : f =O[atTop] g) : Summable f
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
lemma nonempty_linearIndependent_set : Nonempty {s : Set M // LinearIndependent R ((↑) : s → M)}
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive (attr := ext)]
theorem Group.ext {G : Type*} ⦃g₁ g₂ : Group G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂
-- Mathlib/Data/ENNReal/Inv.lean
theorem le_of_forall_nnreal_lt {x y : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r < x → ↑r ≤ y) : x ≤ y
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_equiv {f g : PadicSeq p} (hfg : f ≈ g) : f.norm = g.norm
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
@[simp] theorem coprime_self (n : Nat) : Coprime n n ↔ n = 1
-- Mathlib/GroupTheory/Commutator.lean
theorem commutator_eq_bot_iff_le_centralizer : ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ centralizer H₂
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem map_self (h : IsAdjoinRoot S f) : h.map f = 0
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem seminormAux_add_le (k n : ℕ) (f g : 𝓢(E, F)) :
    (f + g).seminormAux k n ≤ f.seminormAux k n + g.seminormAux k n
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- A cocone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr₂_mapAccumr₂_left_left (f₁ : γ → α → σ₁ → σ₁ × φ) (f₂ : α → β → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ (mapAccumr₂ f₂ xs ys s₂).snd xs s₁)
    = let m := mapAccumr₂ (fun x y (s₁, s₂) =>
                let r₂ := f₂ x y s₂
                let r₁ := f₁ r₂.snd x s₁
                ((r₁.fst, r₂.fst), r₁.snd)
              )
            xs ys (s₁, s₂)
    (m.fst.fst, m.snd)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.mono (h : f =o[l'] g) (hl : l ≤ l') : f =o[l] g
-- .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean
@[simp] theorem join_data {l : Array (Array α)} : l.join.data = (l.data.map data).join
-- Mathlib/Topology/GDelta.lean
lemma isGδ_iff_eq_iInter_nat {s : Set X} :
    IsGδ s ↔ ∃ (f : ℕ → Set X), (∀ n, IsOpen (f n)) ∧ s = ⋂ n, f n
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma toFiniteAux_zero : Measure.toFiniteAux (0 : Measure α) = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem replace_of_not_mem {l : List α} (h : !l.elem a) : l.replace a b = l
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_one_sub_smoothingFn_gt_const_real (c : ℝ) (hc : c < 1) :
    ∀ᶠ (x : ℝ) in atTop, c < 1 - ε x
-- Mathlib/Data/Fin/Fin2.lean
theorem rev_involutive {n} : Function.Involutive (@rev n)
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem mul_mem_left : b ∈ I → a * b ∈ I
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_C_mul_X_pow (x : R) (k n : ℕ) :
    coeff R n (C R x * X ^ k : R⟦X⟧) = if n = k then x else 0
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem power_zero {a : Cardinal} : a ^ (0 : Cardinal) = 1
-- Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean
theorem le_maxIdeal : spanEval k ≤ maxIdeal k
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive]
theorem CommMonoid.toMonoid_injective {M : Type u} :
    Function.Injective (@CommMonoid.toMonoid M)
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem powerBasisAux'_repr_symm_apply (hg : g.Monic) (c : Fin g.natDegree →₀ R) :
    (powerBasisAux' hg).repr.symm c = mk g (∑ i : Fin _, monomial i (c i))
-- Mathlib/Topology/VectorBundle/Hom.lean
@[simp]
theorem Trivialization.baseSet_continuousLinearMap :
    (e₁.continuousLinearMap σ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_diff (h : s₂ ⊆ s₁) (h₂ : MeasurableSet s₂) (h_fin : μ s₂ ≠ ∞) :
    μ (s₁ \ s₂) = μ s₁ - μ s₂
-- Mathlib/Algebra/CharP/Algebra.lean
theorem Algebra.ringChar_eq : ringChar K = ringChar L
-- Mathlib/Analysis/Analytic/CPolynomial.lean
protected theorem CPolynomialOn.continuousOn {s : Set E} (hf : CPolynomialOn 𝕜 f s) :
    ContinuousOn f s
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem filter_add [DecidablePred p] {v v' : α →₀ M} :
    (v + v').filter p = v.filter p + v'.filter p
-- Mathlib/Data/List/Perm.lean
theorem Perm.dedup {l₁ l₂ : List α} (p : l₁ ~ l₂) : dedup l₁ ~ dedup l₂
-- Mathlib/Topology/Algebra/Nonarchimedean/Basic.lean
/-- An open neighborhood of the identity in the cartesian product of two nonarchimedean groups
contains the cartesian product of an open neighborhood in each group. -/
@[to_additive NonarchimedeanAddGroup.prod_subset "An open neighborhood of the identity in
the cartesian product of two nonarchimedean groups contains the cartesian product of
an open neighborhood in each group."]
theorem prod_subset {U} (hU : U ∈ 𝓝 (1 : G × K)) :
    ∃ (V : OpenSubgroup G) (W : OpenSubgroup K), (V : Set G) ×ˢ (W : Set K) ⊆ U
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
/-- The complex cosine function is everywhere strictly differentiable, with the derivative
`-sin x`. -/
theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem ediam_range (hf : Isometry f) : EMetric.diam (range f) = EMetric.diam (univ : Set α)
-- Mathlib/Probability/Kernel/Disintegration/Unique.lean
/-- Auxiliary lemma for `eq_condKernel_of_measure_eq_compProd`.
Uniqueness of the disintegration kernel on ℝ. -/
lemma eq_condKernel_of_measure_eq_compProd_real {ρ : Measure (α × ℝ)} [IsFiniteMeasure ρ]
    (κ : Kernel α ℝ) [IsFiniteKernel κ] (hκ : ρ = ρ.fst ⊗ₘ κ) :
    ∀ᵐ x ∂ρ.fst, κ x = ρ.condKernel x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem mul_mod_mul_right (z x y : Nat) : (x * z) % (y * z) = (x % y) * z
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean
/-- The increment partition has energy greater than the original one by a known fixed amount. -/
theorem energy_increment (hP : P.IsEquipartition) (hP₇ : 7 ≤ P.parts.card)
    (hPε : 100 ≤ 4 ^ P.parts.card * ε ^ 5) (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPG : ¬P.IsUniform G ε) (hε₀ : 0 ≤ ε) (hε₁ : ε ≤ 1) :
    ↑(P.energy G) + ε ^ 5 / 4 ≤ (increment hP G ε).energy G
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem isInternal_ne_bot_iff {A : ι → Submodule R M} :
    IsInternal (fun i : {i // A i ≠ ⊥} ↦ A i) ↔ IsInternal A
-- Mathlib/Data/Matroid/Basic.lean
theorem eq_of_indep_iff_indep_forall {M₁ M₂ : Matroid α} (hE : M₁.E = M₂.E)
    (h : ∀ I, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)) : M₁ = M₂