ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Heyting/Boundary.lean
theorem boundary_sup_sup_boundary_inf (a b : α) : ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) = ∂ a ⊔ ∂ b
-- Mathlib/Analysis/Calculus/Deriv/Prod.lean
nonrec theorem HasDerivAt.prod (hf₁ : HasDerivAt f₁ f₁' x) (hf₂ : HasDerivAt f₂ f₂' x) :
    HasDerivAt (fun x => (f₁ x, f₂ x)) (f₁', f₂') x
-- Mathlib/Order/Interval/Set/Image.lean
lemma AntitoneOn.image_Icc_subset (h : AntitoneOn f (Icc a b)) : f '' Icc a b ⊆ Icc (f b) (f a)
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
@[deprecated measure_iUnion_null_iff (since := "2024-05-14")]
theorem iUnion_null_iff {ι : Sort*} [Countable ι] (m : OuterMeasure α) {s : ι → Set α} :
    m (⋃ i, s i) = 0 ↔ ∀ i, m (s i) = 0
-- Mathlib/Data/Set/Image.lean
/-- If the image of a set is nontrivial, the set is nontrivial. -/
theorem nontrivial_of_image (f : α → β) (s : Set α) (hs : (f '' s).Nontrivial) : s.Nontrivial
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem sinh_nonpos_iff : sinh x ≤ 0 ↔ x ≤ 0
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem outer_trim : f.outer.trim = f.outer
-- Mathlib/Order/Interval/Multiset.lean
theorem card_Ico_eq_card_Icc_sub_one (a b : α) : card (Ico a b) = card (Icc a b) - 1
-- Mathlib/Algebra/Group/Action/Option.lean
@[to_additive (attr := simp)]
theorem smul_some : a • some b = some (a • b)
-- Mathlib/Order/WithBot.lean
@[simp]
theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤
-- Mathlib/Computability/DFA.lean
@[simp]
theorem eval_nil : M.eval [] = M.start
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
/-- A finite group of order dividing a prime is cyclic. -/
@[to_additive "A finite group of order dividing a prime is cyclic."]
theorem isCyclic_of_card_dvd_prime {α : Type u} [Group α] {p : ℕ} [hp : Fact p.Prime]
    (h : Nat.card α ∣ p) : IsCyclic α
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem index_map (f : G →* G') :
    (H.map f).index = (H ⊔ f.ker).index * f.range.index
-- Mathlib/Data/Finsupp/Fin.lean
@[simp]
theorem cons_zero : cons y s 0 = y
-- Mathlib/FieldTheory/SplittingField/Construction.lean
theorem adjoin_rootSet (n : ℕ) :
    ∀ {K : Type u} [Field K],
      ∀ (f : K[X]) (_hfn : f.natDegree = n),
        Algebra.adjoin K (f.rootSet (SplittingFieldAux n f)) = ⊤
-- Mathlib/Algebra/Field/Subfield.lean
theorem mem_carrier {s : Subfield K} {x : K} : x ∈ s.carrier ↔ x ∈ s
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma map_preNormEDS' (n : ℕ) : f (preNormEDS' b c d n) = preNormEDS' (f b) (f c) (f d) n
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem IsSuffix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
    l₁.filter p <:+ l₂.filter p
-- Mathlib/GroupTheory/PushoutI.lean
theorem Reduced.exists_normalWord_prod_eq (d : Transversal φ) {w : Word G} (hw : Reduced φ w) :
    ∃ w' : NormalWord d, w'.prod = ofCoprodI w.prod ∧
      w'.toList.map Sigma.fst = w.toList.map Sigma.fst
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem degree_of_d_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) (hd : P.d = 0) :
    P.toPoly.degree = ⊥
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
theorem inf_mem_closed_subalgebra (A : Subalgebra ℝ C(X, ℝ)) (h : IsClosed (A : Set C(X, ℝ)))
    (f g : A) : (f : C(X, ℝ)) ⊓ (g : C(X, ℝ)) ∈ A
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Ico : (some : α → WithTop α) ⁻¹' Ico a b = Ico a b
-- Mathlib/Data/List/Basic.lean
theorem concat_eq_reverse_cons (a : α) (l : List α) : concat l a = reverse (a :: reverse l)
-- Mathlib/Order/Filter/EventuallyConst.lean
@[to_additive]
theorem mulIndicator_const (h : EventuallyConst s l) (c : β) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma growsPolynomially_pow (p : ℕ) : GrowsPolynomially fun x => x ^ p
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_le_pow_iff_le_valuation (x : ℤ_[p]) (hx : x ≠ 0) (n : ℕ) :
    ‖x‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ ↑n ≤ x.valuation
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.right_of_add_measure {f : α → β} (h : HasFiniteIntegral f (μ + ν)) :
    HasFiniteIntegral f ν
-- Mathlib/CategoryTheory/Grothendieck.lean
/-- Auxiliary definition for `grothendieckTypeToCat`, to speed up elaboration. -/
@[simps!]
def grothendieckTypeToCatFunctor : Grothendieck (G ⋙ typeToCat) ⥤ G.Elements
-- Mathlib/Data/Set/Function.lean
theorem injOn_image (h : Semiconj f fa fb) (ha : InjOn fa s) (hf : InjOn f (fa '' s)) :
    InjOn fb (f '' s)
-- Mathlib/Data/Finsupp/Defs.lean
theorem ext_iff' {f g : α →₀ M} : f = g ↔ f.support = g.support ∧ ∀ x ∈ f.support, f x = g x
-- Mathlib/Algebra/Ring/Defs.lean
theorem mul_sub_one (a b : α) : a * (b - 1) = a * b - a
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Limits.lean
/-- The (limit) cone for `F : J ⥤ PresheafOfModules.{v} R` that is constructed for the limit
of `F ⋙ evaluation R X` for all `X`. -/
@[simps]
noncomputable def limitCone : Cone F
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem midpoint_vsub_midpoint (p₁ p₂ p₃ p₄ : P) :
    midpoint R p₁ p₂ -ᵥ midpoint R p₃ p₄ = midpoint R (p₁ -ᵥ p₃) (p₂ -ᵥ p₄)
-- Mathlib/Control/Basic.lean
/-- A `CommApplicative` functor `m` is a (lawful) applicative functor which behaves identically on
`α × β` and `β × α`, so computations can occur in either order. -/
class CommApplicative (m : Type u → Type v) [Applicative m] extends LawfulApplicative m : Prop where
  /-- Computations performed first on `a : α` and then on `b : β` are equal to those performed in
  the reverse order. -/
  commutative_prod : ∀ {α β} (a : m α) (b : m β),
    Prod.mk <$> a <*> b = (fun (b : β) a => (a, b)) <$> b <*> a
-- Mathlib/Order/Category/NonemptyFinLinOrd.lean
theorem nonemptyFinLinOrd_dual_comp_forget_to_linOrd :
    NonemptyFinLinOrd.dual ⋙ forget₂ NonemptyFinLinOrd LinOrd =
      forget₂ NonemptyFinLinOrd LinOrd ⋙ LinOrd.dual
-- Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean
/-- In degree `0`, the null homotopic map `Hσ` is zero. -/
theorem Hσ_eq_zero (q : ℕ) : (Hσ q : K[X] ⟶ K[X]).f 0 = 0
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := mono)]
theorem inv_subset_inv (h : s ⊆ t) : s⁻¹ ⊆ t⁻¹
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_add (x₁ x₂ : R) (y₁ y₂ : M) :
    mk' S (x₁ * y₂ + x₂ * y₁) (y₁ * y₂) = mk' S x₁ y₁ + mk' S x₂ y₂
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Raised.dist_le {n m} (H : Raised n m) : Nat.dist n m ≤ 1
-- Mathlib/Topology/Order.lean
theorem induced_const [t : TopologicalSpace α] {x : α} : (t.induced fun _ : β => x) = ⊤
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivWithinAt.finset_prod (hf : ∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) :
    HasDerivWithinAt (∏ i ∈ u, f i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) s x
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- The "evaluation of `F` at `X`" functor,
as a functor `C × (C ⥤ D) ⥤ D`.
-/
@[simps]
def evaluationUncurried : C × (C ⥤ D) ⥤ D
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negAddY_smul (P Q : Fin 3 → R) (u v : R) :
    W'.negAddY (u • P) (v • Q) = ((u * v) ^ 2) ^ 3 * W'.negAddY P Q
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem coe_finset_sum {_m : MeasurableSpace α} (I : Finset ι) (μ : ι → Measure α) :
    ⇑(∑ i ∈ I, μ i) = ∑ i ∈ I, ⇑(μ i)
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem out_nonempty_iff_ne_zero {o : Ordinal} : Nonempty o.out.α ↔ o ≠ 0
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem uniformInducing_coe : UniformInducing ((↑) : α → Completion α)
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem degree_pos_of_irreducible (hp : Irreducible p) : 0 < p.degree
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem isLeft_iff : x.isLeft ↔ ∃ y, x = Sum.inl y
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive (attr := simp)]
theorem coe_liftRight {f : M →* N} {g : M → Nˣ} (h : ∀ x, ↑(g x) = f x) (x) :
    (liftRight f g h x : N) = f x
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem sUnion_range (f : ι → Set β) : ⋃₀range f = ⋃ x, f x
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_rpow_of_exponent_gt {x : ℝ≥0∞} {y z : ℝ} (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) :
    x ^ y < x ^ z
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive, field_simps] -- The attributes are out of order on purpose
theorem mul_div_assoc' (a b c : G) : a * (b / c) = a * b / c
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem modelWithCorners_prod_coe (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H') :
    (I.prod I' : _ × _ → _ × _) = Prod.map I I'
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
theorem _root_.IsPrimitiveRoot.adjoin_isCyclotomicExtension {ζ : B} {n : ℕ+}
    (h : IsPrimitiveRoot ζ n) : IsCyclotomicExtension {n} A (adjoin A ({ζ} : Set B))
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
lemma mul_nonZeroDivisor_mem_finiteIntegralAdeles (a : FiniteAdeleRing R K) :
    ∃ (b : R⁰) (c : R_hat R K), a * ((b : R) : FiniteAdeleRing R K) = c
-- Mathlib/SetTheory/Cardinal/Basic.lean
lemma natCast_add_one_le_iff {n : ℕ} {c : Cardinal} : n + 1 ≤ c ↔ n < c
-- Mathlib/Data/Int/Defs.lean
/-- If `n > 0` then `m` is not divisible by `n` iff it is between `n * k` and `n * (k + 1)`
  for some `k`. -/
lemma exists_lt_and_lt_iff_not_dvd (m : ℤ) (hn : 0 < n) :
    (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m
-- Mathlib/Order/Synonym.lean
@[simp]
theorem toDual_symm_eq : (@toDual α).symm = ofDual
-- Mathlib/Data/List/MinMax.lean
lemma getD_maximum?_eq_unbot'_maximum (l : List α) (d : α) :
    l.maximum?.getD d = l.maximum.unbot' d
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrix'_mul [Fintype m] [DecidableEq m] (f g : (m → R) →ₗ[R] m → R) :
    LinearMap.toMatrix' (f * g) = LinearMap.toMatrix' f * LinearMap.toMatrix' g
-- Mathlib/RingTheory/Support.lean
lemma Module.support_subset_of_surjective (hf : Function.Surjective f) :
    Module.support R N ⊆ Module.support R M
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive vadd_filter.instNeBot]
lemma smul_filter.instNeBot [NeBot f] : NeBot (a • f)
-- Mathlib/FieldTheory/Separable.lean
/-- Transfer `Algebra.IsSeparable` across an `AlgEquiv`. -/
theorem AlgEquiv.isSeparable [Algebra.IsSeparable F K] : Algebra.IsSeparable F E
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- A right homology data for a short complex `S` consists of morphisms `p : S.X₂ ⟶ Q` and
`ι : H ⟶ Q` such that `p` identifies `Q` to the kernel of `f : S.X₁ ⟶ S.X₂`,
and that `ι` identifies `H` to the kernel of the induced map `g' : Q ⟶ S.X₃` -/
structure RightHomologyData where
  /-- a choice of cokernel of `S.f : S.X₁ ⟶ S.X₂`-/
  Q : C
  /-- a choice of kernel of the induced morphism `S.g' : S.Q ⟶ X₃`-/
  H : C
  /-- the projection from `S.X₂` -/
  p : S.X₂ ⟶ Q
  /-- the inclusion of the (right) homology in the chosen cokernel of `S.f` -/
  ι : H ⟶ Q
  /-- the cokernel condition for `p` -/
  wp : S.f ≫ p = 0
  /-- `p : S.X₂ ⟶ Q` is a cokernel of `S.f : S.X₁ ⟶ S.X₂` -/
  hp : IsColimit (CokernelCofork.ofπ p wp)
  /-- the kernel condition for `ι` -/
  wι : ι ≫ hp.desc (CokernelCofork.ofπ _ S.zero) = 0
  /-- `ι : H ⟶ Q` is a kernel of `S.g' : Q ⟶ S.X₃` -/
  hι : IsLimit (KernelFork.ofι ι wι)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem lift_mul (a b : Ordinal.{v}) : lift.{u} (a * b) = lift.{u} a * lift.{u} b
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem exists_pos_measure_of_cover [Countable ι] {U : ι → Set α} (hU : ⋃ i, U i = univ)
    (hμ : μ ≠ 0) : ∃ i, 0 < μ (U i)
-- Mathlib/Tactic/CC/Lemmas.lean
theorem eq_true_of_and_eq_true_left {a b : Prop} (h : (a ∧ b) = True) : a = True
-- Mathlib/Topology/PartialHomeomorph.lean
/-- A function is continuous if and only if its composition with a partial homeomorphism
on the left is continuous and its image is contained in the source. -/
theorem continuous_iff_continuous_comp_left {f : Z → X} (h : f ⁻¹' e.source = univ) :
    Continuous f ↔ Continuous (e ∘ f)
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
@[simp]
theorem support_neg (a : FreeAbelianGroup X) : support (-a) = support a
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[simp]
theorem L_apply : (𝑳 I g) h = g * h
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem expand_card {p : ℕ} [Fact p.Prime] (f : Polynomial (ZMod p)) :
    expand (ZMod p) p f = f ^ p
-- Mathlib/Data/PFun.lean
theorem fixInduction'_fwd {C : α → Sort*} {f : α →. β ⊕ α} {b : β} {a a' : α} (h : b ∈ f.fix a)
    (h' : b ∈ f.fix a') (fa : Sum.inr a' ∈ f a)
    (hbase : ∀ a_final : α, Sum.inl b ∈ f a_final → C a_final)
    (hind : ∀ a₀ a₁ : α, b ∈ f.fix a₁ → Sum.inr a₁ ∈ f a₀ → C a₁ → C a₀) :
    @fixInduction' _ _ C _ _ _ h hbase hind = hind a a' h' fa (fixInduction' h' hbase hind)
-- Mathlib/Deprecated/Group.lean
/-- Right multiplication in a ring is an additive monoid morphism. -/
theorem isAddMonoidHom_mul_right {γ : Type*} [NonUnitalNonAssocSemiring γ] (x : γ) :
    IsAddMonoidHom fun y : γ => y * x
-- Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean
lemma prod_ne_zero_iff : ∏ x ∈ s, f x ≠ 0 ↔ ∀ a ∈ s, f a ≠ 0
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem tendsto_pow_atTop_nhds_zero_of_abs_lt_one {r : ℝ} (h : |r| < 1) :
    Tendsto (fun n : ℕ ↦ r ^ n) atTop (𝓝 0)
-- Mathlib/Combinatorics/HalesJewett.lean
@[simp] lemma toSubspace_apply (l : Line (η → α) ι) (a ie) :
    ⇑l.toSubspace a ie = l a ie.1 ie.2
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- A point in a collinear set of points lies in the affine span of any two distinct points of
that set. -/
theorem Collinear.mem_affineSpan_of_mem_of_ne {s : Set P} (h : Collinear k s) {p₁ p₂ p₃ : P}
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₁p₂ : p₁ ≠ p₂) : p₃ ∈ line[k, p₁, p₂]
-- Mathlib/NumberTheory/LSeries/Linearity.lean
lemma LSeriesHasSum.sub {f g : ℕ → ℂ} {s a b : ℂ} (hf : LSeriesHasSum f s a)
    (hg : LSeriesHasSum g s b) :
    LSeriesHasSum (f - g) s (a - b)
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
lemma closure_upperClosure_comm_pi (hs : BddBelow s) :
    closure (upperClosure s : Set (ι → ℝ)) = upperClosure (closure s)
-- Mathlib/Topology/Basic.lean
theorem interior_union_isClosed_of_interior_empty (h₁ : IsClosed s)
    (h₂ : interior t = ∅) : interior (s ∪ t) = interior s
-- Mathlib/Data/Fintype/Perm.lean
theorem card_perms_of_finset : ∀ s : Finset α, (permsOfFinset s).card = s.card !
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem limMap_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (α : F ⟶ G) (j : J) :
    limMap α ≫ limit.π G j = limit.π F j ≫ α.app j
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem Integrable.integral_prod_left ⦃f : α × β → E⦄ (hf : Integrable f (μ.prod ν)) :
    Integrable (fun x => ∫ y, f (x, y) ∂ν) μ
-- Mathlib/CategoryTheory/Localization/Adjunction.lean
lemma ε_app (X₁ : C₁) :
    (ε adj L₁ W₁ L₂ G' F').app (L₁.obj X₁) =
      L₁.map (adj.unit.app X₁) ≫ (CatCommSq.iso F L₂ L₁ F').hom.app (G.obj X₁) ≫
        F'.map ((CatCommSq.iso G L₁ L₂ G').hom.app X₁)
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean
/-- `-2` is a square modulo an odd prime `p` iff `p` is congruent to `1` or `3` mod `8`. -/
theorem exists_sq_eq_neg_two_iff : IsSquare (-2 : ZMod p) ↔ p % 8 = 1 ∨ p % 8 = 3
-- Mathlib/CategoryTheory/Monoidal/Mod_.lean
/-- A module object for a monoid object, all internal to some monoidal category. -/
structure Mod_ (A : Mon_ C) where
  X : C
  act : A.X ⊗ X ⟶ X
  one_act : (A.one ▷ X) ≫ act = (λ_ X).hom := by aesop_cat
  assoc : (A.mul ▷ X) ≫ act = (α_ A.X A.X X).hom ≫ (A.X ◁ act) ≫ act := by aesop_cat
-- Mathlib/Data/Complex/Exponential.lean
theorem sinh_mul_I : sinh (x * I) = sin x * I
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
theorem cobounded_eq_aux :
    @cobounded _ (Bornology.induced <| addEquiv 𝕜 A) = cobounded (Unitization 𝕜 A)
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem HasDerivWithinAt.cexp (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.exp (f x)) (Complex.exp (f x) * f') s x
-- Mathlib/Order/Cover.lean
theorem WCovBy.Icc_eq (h : a ⩿ b) : Icc a b = {a, b}
-- Mathlib/MeasureTheory/Function/L2Space.lean
theorem inner_def (f g : α →₂[μ] E) : ⟪f, g⟫ = ∫ a : α, ⟪f a, g a⟫ ∂μ
-- Mathlib/Analysis/BoundedVariation.lean
theorem constant_on {f : α → E} {s : Set α} (hf : (f '' s).Subsingleton) :
    eVariationOn f s = 0
-- Mathlib/RingTheory/HahnSeries/PowerSeries.lean
theorem ofPowerSeries_apply (x : PowerSeries R) :
    ofPowerSeries Γ R x =
      HahnSeries.embDomain
        ⟨⟨((↑) : ℕ → Γ), Nat.strictMono_cast.injective⟩, by
          simp only [Function.Embedding.coeFn_mk]
          exact Nat.cast_le⟩
        (toPowerSeries.symm x)
-- Mathlib/Topology/Constructions.lean
theorem isClosedMap_ofDual : IsClosedMap (ofDual : Xᵒᵈ → X)
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[simp]
theorem length_join (L : List (List α)) : length (join L) = sum (map length L)
-- Mathlib/Data/Fintype/Sum.lean
/-- Any injection from a set `s` in a fintype `α` to a finset `t` of the same cardinality as `α`
can be extended to a bijection between `α` and `t`. -/
theorem Set.MapsTo.exists_equiv_extend_of_card_eq [Fintype α] {t : Finset β}
    (hαt : Fintype.card α = t.card) {s : Set α} {f : α → β} (hfst : s.MapsTo f t)
    (hfs : Set.InjOn f s) : ∃ g : α ≃ t, ∀ i ∈ s, (g i : β) = f i
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive add_prehaar_le_addIndex]
theorem prehaar_le_index (K₀ : PositiveCompacts G) {U : Set G} (K : Compacts G)
    (hU : (interior U).Nonempty) : prehaar (K₀ : Set G) U K ≤ index (K : Set G) K₀
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem eraseNone_image_some [DecidableEq (Option α)] (s : Finset α) :
    eraseNone (s.image some) = s
-- Mathlib/Data/PNat/Prime.lean
@[simp]
theorem coprime_one {n : ℕ+} : n.Coprime 1
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioi_union_left : Ioi a ∪ {a} = Ici a
-- Mathlib/Topology/Maps/Basic.lean
theorem setOf_isOpen (hf : Inducing f) :
    {s : Set X | IsOpen s} = preimage f '' {t | IsOpen t}
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem componentComplMk_eq_of_adj (G : SimpleGraph V) {v w : V} (vK : v ∉ K) (wK : w ∉ K)
    (a : G.Adj v w) : G.componentComplMk vK = G.componentComplMk wK
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProd_eq_tsum_compProd (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] (a : α) (hs : MeasurableSet s) :
    (κ ⊗ₖ η) a s = ∑' (n : ℕ) (m : ℕ), (seq κ n ⊗ₖ seq η m) a s
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem replace_nil [BEq α] : ([] : List α).replace a b = []
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
protected theorem isCountablySpanning (h : μ.FiniteSpanningSetsIn C) : IsCountablySpanning C
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
@[simp]
theorem DifferentiableAt.log (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    DifferentiableAt ℝ (fun x => log (f x)) x
-- Mathlib/Analysis/PSeries.lean
/-- **Divergence of the Harmonic Series** -/
theorem tendsto_sum_range_one_div_nat_succ_atTop :
    Tendsto (fun n => ∑ i ∈ Finset.range n, (1 / (i + 1) : ℝ)) atTop atTop
-- Mathlib/Analysis/Normed/Group/Bounded.lean
@[to_additive eventually_cobounded_le_norm]
lemma eventually_cobounded_le_norm' (a : ℝ) : ∀ᶠ x in cobounded E, a ≤ ‖x‖
-- Mathlib/CategoryTheory/Opposites.lean
/-- The isomorphism obtained from an isomorphism in the opposite category. -/
@[simps]
def unop {X Y : Cᵒᵖ} (f : X ≅ Y) : Y.unop ≅ X.unop
-- Mathlib/GroupTheory/Coset.lean
@[to_additive]
theorem eq' {a b : α} : (mk a : α ⧸ s) = mk b ↔ a⁻¹ * b ∈ s
-- Mathlib/ModelTheory/Basic.lean
theorem ext_iff {f g : M ≃[L] N} : f = g ↔ ∀ x, f x = g x
-- Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean
@[simp]
lemma rightUnitor_inv_app (F : J ⥤ C) (j : J) :
    (ρ_ F).inv.app j = (ρ_ (F.obj j)).inv
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eq_of_degree_sub_lt_of_eval_finset_eq (degree_fg_lt : (f - g).degree < s.card)
    (eval_fg : ∀ x ∈ s, f.eval x = g.eval x) : f = g
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem div_self (h0 : a ≠ 0) (hI : a ≠ ∞) : a / a = 1
-- Mathlib/Order/Concept.lean
@[simp]
theorem inf_snd (c d : Concept α β r) : (c ⊓ d).snd = intentClosure r (c.fst ∩ d.fst)
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem mulTSupport_extend_one_subset :
    mulTSupport (g.extend f 1) ⊆ g '' mulTSupport f
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem coe_codRestrict_apply (f : M₁ →SL[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ x, f x ∈ p) (x) :
    (f.codRestrict p h x : M₂) = f x
-- Mathlib/Order/Irreducible.lean
/-- In a cowell-founded lattice, any element is the infimum of finitely many inf-irreducible
elements. This is the order-theoretic analogue of prime factorisation. -/
theorem exists_infIrred_decomposition (a : α) :
    ∃ s : Finset α, s.inf id = a ∧ ∀ ⦃b⦄, b ∈ s → InfIrred b
-- Mathlib/Algebra/Order/Module/Defs.lean
/-- A constructor for `PosSMulReflectLT` requiring you to prove `a • b₁ < a • b₂ → b₁ < b₂` only
when `0 < a`-/
lemma PosSMulReflectLT.of_pos (h₀ : ∀ a : α, 0 < a → ∀ b₁ b₂ : β, a • b₁ < a • b₂ → b₁ < b₂) :
    PosSMulReflectLT α β
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
protected theorem Nat.le_refl (n : Nat) : LE.le n n
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem frontier_cthickening_disjoint (A : Set α) :
    Pairwise (Disjoint on fun r : ℝ≥0 => frontier (cthickening r A))
-- Mathlib/Topology/Separation.lean
/-- A topological space is said to be a *normal space* if any two disjoint closed sets
have disjoint open neighborhoods. -/
class NormalSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- Two disjoint sets in a normal space admit disjoint neighbourhoods. -/
  normal : ∀ s t : Set X, IsClosed s → IsClosed t → Disjoint s t → SeparatedNhds s t
-- Mathlib/Topology/Basic.lean
theorem mem_closure_iff_nhds_ne_bot : x ∈ closure s ↔ 𝓝 x ⊓ 𝓟 s ≠ ⊥
-- Mathlib/Dynamics/OmegaLimit.lean
/-- A set is eventually carried into any open neighbourhood of its ω-limit:
if `c` is a compact set such that `closure {ϕ t x | t ∈ v, x ∈ s} ⊆ c` for some `v ∈ f`
and `n` is an open neighbourhood of `ω f ϕ s`, then for some `u ∈ f` we have
`closure {ϕ t x | t ∈ u, x ∈ s} ⊆ n`. -/
theorem eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset' {c : Set β}
    (hc₁ : IsCompact c) (hc₂ : ∃ v ∈ f, closure (image2 ϕ v s) ⊆ c) {n : Set β} (hn₁ : IsOpen n)
    (hn₂ : ω f ϕ s ⊆ n) : ∃ u ∈ f, closure (image2 ϕ u s) ⊆ n
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
/-- A local diffeomorphism is a local homeomorphism. -/
theorem IsLocalDiffeomorph.isLocalHomeomorph (hf : IsLocalDiffeomorph I J n f) :
    IsLocalHomeomorph f
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_eq_setToSimpleFunc (T : Set α → E →L[ℝ] F) (f : α →₁ₛ[μ] E) :
    setToL1S T f = (toSimpleFunc f).setToSimpleFunc T
-- Mathlib/Data/Set/Finite.lean
theorem card_fintypeInsertOfNotMem {a : α} (s : Set α) [Fintype s] (h : a ∉ s) :
    @Fintype.card _ (fintypeInsertOfNotMem s h) = Fintype.card s + 1
-- Mathlib/RingTheory/Nilpotent/Basic.lean
theorem IsNilpotent.isUnit_one_sub [Ring R] {r : R} (hnil : IsNilpotent r) : IsUnit (1 - r)
-- Mathlib/Order/RelSeries.lean
lemma toList_injective : Function.Injective (RelSeries.toList (r := r))
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
@[simp]
lemma prodEquiv_apply_snd (x : (forget C).obj (X₁ ⨯ X₂)) :
    (prodEquiv X₁ X₂ x).snd = (Limits.prod.snd : X₁ ⨯ X₂ ⟶ X₂) x
-- Mathlib/Data/Subtype.lean
theorem coe_mk (a h) : (@mk α p a h : α) = a
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_le_iff_le_rpow_of_base_lt_one (hx : 0 < x) : logb b x ≤ y ↔ b ^ y ≤ x
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[deprecated DifferentiableAt.sub_iff_right (since := "2024-07-11")]
theorem differentiableAt_const_sub_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => c - f y) x ↔ DifferentiableAt 𝕜 f x
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[simp]
theorem map_formula (f : M ↪ₑ[L] N) {α : Type*} (φ : L.Formula α) (x : α → M) :
    φ.Realize (f ∘ x) ↔ φ.Realize x
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
nonrec theorem HasDerivAtFilter.isBigO_sub_rev (hf : HasDerivAtFilter f f' x L) (hf' : f' ≠ 0) :
    (fun x' => x' - x) =O[L] fun x' => f x' - f x