ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolAlg_add_add_mul (a b : α) : toBoolAlg (a + b + a * b) = toBoolAlg a ⊔ toBoolAlg b
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
theorem xgcd_val (x y : R) : xgcd x y = (gcdA x y, gcdB x y)
-- Mathlib/FieldTheory/Normal.lean
theorem isSolvable_of_isScalarTower [Normal F K₁] [h1 : IsSolvable (K₁ ≃ₐ[F] K₁)]
    [h2 : IsSolvable (E ≃ₐ[K₁] E)] : IsSolvable (E ≃ₐ[F] E)
-- Mathlib/Data/List/Basic.lean
theorem lookmap_none : ∀ l : List α, (l.lookmap fun _ => none) = l
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
@[continuity, fun_prop]
theorem continuous_rpow_const {y : ℝ} : Continuous fun a : ℝ≥0∞ => a ^ y
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
/-- There is never an `s-t` edge in `G.replaceVertex s t`. -/
lemma not_adj_replaceVertex_same : ¬(G.replaceVertex s t).Adj s t
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive]
theorem prod_comm (f : α →₀ M) (g : β →₀ M') (h : α → M → β → M' → N) :
    (f.prod fun x v => g.prod fun x' v' => h x v x' v') =
      g.prod fun x' v' => f.prod fun x v => h x v x' v'
-- Mathlib/Data/Set/Lattice.lean
theorem iInter₂_mono {s t : ∀ i, κ i → Set α} (h : ∀ i j, s i j ⊆ t i j) :
    ⋂ (i) (j), s i j ⊆ ⋂ (i) (j), t i j
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
theorem HasSum.star (h : HasSum f a) : HasSum (fun b ↦ star (f b)) (star a)
-- Mathlib/Algebra/Group/PNatPowAssoc.lean
theorem ppow_mul' (x : M) (m n : ℕ+) : x ^ (m * n) = (x ^ n) ^ m
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_mk (f : E →ₛₗ[σ₁₂] E₂) (hf) : ⇑(mk f hf) = f
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma smul_floorDiv_le (ha : 0 < a) : a • (b ⌊/⌋ a) ≤ b
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem _root_.Basis.coe_toOrthonormalBasis_repr_symm (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    ((v.toOrthonormalBasis hv).repr.symm : EuclideanSpace 𝕜 ι → E) = v.equivFun.symm
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.of_inf_left {f g : Filter X} (H : ClusterPt x <| f ⊓ g) : ClusterPt x f
-- Mathlib/Data/Matroid/Restrict.lean
theorem ofMatroid_lt_iff {M M' : Matroid α} :
    Matroidᵣ.ofMatroid M < Matroidᵣ.ofMatroid M' ↔ M <r M'
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem sInf_image_Icc_le (h : ContinuousOn f <| Icc a b) (hc : c ∈ Icc a b) :
    sInf (f '' Icc a b) ≤ f c
-- Mathlib/Probability/Distributions/Uniform.lean
theorem pdf_eq_zero_of_measure_eq_zero_or_top {X : Ω → E} {s : Set E}
    (hu : IsUniform X s ℙ μ) (hμs : μ s = 0 ∨ μ s = ∞) : pdf X ℙ μ =ᵐ[μ] 0
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
lemma uniformEquicontinuousOn_univ (F : ι → β → α) :
    UniformEquicontinuousOn F univ ↔ UniformEquicontinuous F
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc (attr := simp)]
theorem lift_comp_conePointUniqueUpToIso_hom {r s t : Cone F} (P : IsLimit s) (Q : IsLimit t) :
    P.lift r ≫ (conePointUniqueUpToIso P Q).hom = Q.lift r
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem inclusion_inclusion {S T U : NonUnitalStarSubalgebra R A} (hst : S ≤ T) (htu : T ≤ U)
    (x : S) : inclusion htu (inclusion hst x) = inclusion (le_trans hst htu) x
-- Mathlib/Data/NNRat/Defs.lean
@[ext]
theorem ext : (p : ℚ) = (q : ℚ) → p = q
-- Mathlib/Order/Monotone/Basic.lean
theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem circleMap_eq_center_iff {c : ℂ} {R : ℝ} {θ : ℝ} : circleMap c R θ = c ↔ R = 0
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
/-- An orthogonal basis with respect to a left-separating bilinear map has no self-orthogonal
elements. -/
theorem IsOrthoᵢ.not_isOrtho_basis_self_of_separatingLeft [Nontrivial R]
    {B : M →ₛₗ[I] M →ₛₗ[I'] M₁} {v : Basis n R M} (h : B.IsOrthoᵢ v) (hB : B.SeparatingLeft)
    (i : n) : ¬B.IsOrtho (v i) (v i)
-- Mathlib/CategoryTheory/Functor/Category.lean
@[ext]
theorem ext' {α β : F ⟶ G} (w : α.app = β.app) : α = β
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem cond_true (a b : α) : cond true a b = a
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma rightHomologyMap'_eq : rightHomologyMap' φ h₁ h₂ = γ.φH
-- Mathlib/Topology/Instances/NNReal.lean
/-- An antitone, bounded below sequence `f : ℕ → ℝ` has a finite limit. -/
theorem _root_.Real.tendsto_of_bddBelow_antitone {f : ℕ → ℝ} (h_bdd : BddBelow (Set.range f))
    (h_ant : Antitone f) : ∃ r : ℝ, Tendsto f atTop (𝓝 r)
-- Mathlib/Data/Num/Lemmas.lean
theorem cast_succ [AddMonoidWithOne α] (n) : (succ n : α) = n + 1
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem injective_of_map_injective (adj : F ⊣ G) [G.Full] [G.Faithful] (I : D)
    (hI : Injective (G.obj I)) : Injective I
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
theorem ker_eq_bot_iff_range_eq_top [FiniteDimensional K V] {f : V →ₗ[K] V} :
    LinearMap.ker f = ⊥ ↔ LinearMap.range f = ⊤
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem trichotomy (f : CauSeq α abs) : Pos f ∨ LimZero f ∨ Pos (-f)
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast]
theorem coe_zpow (r : ℝ≥0) (n : ℤ) : ((r ^ n : ℝ≥0) : ℝ) = (r : ℝ) ^ n
-- Mathlib/Algebra/Group/Pi/Basic.lean
/-- Abbreviation for `mulSingle_eq_of_ne h.symm`, for ease of use by `simp`. -/
@[to_additive (attr := simp)
  "Abbreviation for `single_eq_of_ne h.symm`, for ease of use by `simp`."]
theorem mulSingle_eq_of_ne' {i i' : I} (h : i ≠ i') (x : f i) : mulSingle i x i' = 1
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem ball_eq_preimage (x : E) (r : ℝ) :
    ball x r = toEuclidean ⁻¹' Metric.ball (toEuclidean x) r
-- Mathlib/Topology/DenseEmbedding.lean
/-- If `i : α → β` is a dense embedding with dense complement of the range, then any compact set in
`α` has empty interior. -/
theorem interior_compact_eq_empty [T2Space β] (di : DenseInducing i) (hd : Dense (range i)ᶜ)
    {s : Set α} (hs : IsCompact s) : interior s = ∅
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem ssubset_singleton_iff {s : Finset α} {a : α} : s ⊂ {a} ↔ s = ∅
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem monic_of_degree_le (n : ℕ) (H1 : degree p ≤ n) (H2 : coeff p n = 1) : Monic p
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma exists_mem_ofUnits_val_eq (S : Subgroup Mˣ) {x : M} (h : x ∈ S.ofUnits) :
    ∃ y ∈ S, y = x
-- Mathlib/Topology/Semicontinuous.lean
theorem ContinuousOn.upperSemicontinuousOn {f : α → γ} (h : ContinuousOn f s) :
    UpperSemicontinuousOn f s
-- Mathlib/Order/Cover.lean
lemma covBy_iff_exists_sdiff_singleton : s ⋖ t ↔ ∃ a ∈ t, t \ {a} = s
-- Mathlib/Topology/Category/CompactlyGenerated.lean
lemma continuous_from_compactlyGenerated {X : Type w} [TopologicalSpace X]
    {Y : Type*} [t : TopologicalSpace Y] (f : X → Y)
      (h : ∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) :
        Continuous[compactlyGenerated.{u} X, t] f
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem nndist_eq {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β] [FunLike F α β]
    [DilationClass F α β] (f : F) (x y : α) :
    nndist (f x) (f y) = ratio f * nndist x y
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem nonUnitalSubsemiringClosure_coe :
    (M.nonUnitalSubsemiringClosure : Set R) = AddSubmonoid.closure (M : Set R)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma ΨSq_two : W.ΨSq 2 = W.Ψ₂Sq
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
theorem volumeForm_apply_le (v : Fin n → E) : o.volumeForm v ≤ ∏ i : Fin n, ‖v i‖
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem extract_gcd (f : β → α) (hs : s.Nonempty) :
    ∃ g : β → α, (∀ b ∈ s, f b = s.gcd f * g b) ∧ s.gcd g = 1
-- Mathlib/Data/Multiset/Lattice.lean
@[simp]
theorem sup_singleton {a : α} : ({a} : Multiset α).sup = a
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the sign of the angle between three points is nonzero, the first two points are not
equal. -/
theorem left_ne_of_oangle_sign_ne_zero {p₁ p₂ p₃ : P} (h : (∡ p₁ p₂ p₃).sign ≠ 0) : p₁ ≠ p₂
-- Mathlib/Data/Nat/Factorization/Defs.lean
theorem eq_of_factorization_eq {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
    (h : ∀ p : ℕ, a.factorization p = b.factorization p) : a = b
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
/-- See also `Complex.pow_cpow_ofNat_inv` for a version that also works for `x * I`, `0 ≤ x`. -/
lemma sq_cpow_two_inv {x : ℂ} (hx : 0 < x.re) : (x ^ (2 : ℕ)) ^ (2⁻¹ : ℂ) = x
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem sbtw_zero_one_iff {x : R} : Sbtw R 0 x 1 ↔ x ∈ Set.Ioo (0 : R) 1
-- Mathlib/RingTheory/Localization/Basic.lean
theorem sec_fst_ne_zero [Nontrivial R] [NoZeroDivisors S] (hM : M ≤ nonZeroDivisors R) {x : S}
    (hx : x ≠ 0) : (sec M x).fst ≠ 0
-- Mathlib/CategoryTheory/Sites/Continuous.lean
lemma op_comp_isSheafOfTypes [Functor.IsContinuous.{t} F J K] (G : SheafOfTypes.{t} K) :
    Presieve.IsSheaf J (F.op ⋙ G.val)
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
theorem Trident.ι_ofι [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂) :
    (Trident.ofι ι w).ι = ι
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
/-- The restriction of scalars functor `PresheafOfModules R' ⥤ PresheafOfModules R`
induced by a morphism of presheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars (α : R ⟶ R') :
    PresheafOfModules.{v} R' ⥤ PresheafOfModules.{v} R
-- Mathlib/Data/Set/Card.lean
theorem ncard_le_one_iff (hs : s.Finite := by toFinite_tac) :
    s.ncard ≤ 1 ↔ ∀ {a b}, a ∈ s → b ∈ s → a = b
-- Mathlib/Data/Nat/Bitwise.lean
/-- The ith bit is the ith element of `n.bits`. -/
theorem testBit_eq_inth (n i : ℕ) : n.testBit i = n.bits.getI i
-- Mathlib/Topology/Bases.lean
/-- A second-countable space is one with a countable basis. -/
class _root_.SecondCountableTopology : Prop where
  /-- There exists a countable set of sets that generates the topology. -/
  is_open_generated_countable : ∃ b : Set (Set α), b.Countable ∧ t = TopologicalSpace.generateFrom b
-- Mathlib/Logic/Basic.lean
theorem not_and_not_right : ¬(a ∧ ¬b) ↔ a → b
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem or_self_left  : a ∨ (a ∨ b) ↔ a ∨ b
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem interior_smul₀ {c : G₀} (hc : c ≠ 0) (s : Set α) : interior (c • s) = c • interior s
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem superpolynomialDecay_iff_abs_isBoundedUnder (hk : Tendsto k l atTop) :
    SuperpolynomialDecay l k f ↔
    ∀ z : ℕ, IsBoundedUnder (· ≤ ·) l fun a : α => |k a ^ z * f a|
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFreeOn_empty : G.CliqueFreeOn ∅ n ↔ n ≠ 0
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem baseSet_at : Z.baseSet i = (Z.localTriv i).baseSet
-- Mathlib/Topology/Instances/ENNReal.lean
/-- Markov's inequality for `Finset.card` and `tsum` in `ℝ≥0∞`. -/
theorem finset_card_const_le_le_of_tsum_le {ι : Type*} {a : ι → ℝ≥0∞} {c : ℝ≥0∞} (c_ne_top : c ≠ ∞)
    (tsum_le_c : ∑' i, a i ≤ c) {ε : ℝ≥0∞} (ε_ne_zero : ε ≠ 0) :
    ∃ hf : { i : ι | ε ≤ a i }.Finite, ↑hf.toFinset.card ≤ c / ε
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem arrowCongr'_symm {α₁ α₂ β₁ β₂ : Type*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (arrowCongr' e₁ e₂).symm = arrowCongr' e₁.symm e₂.symm
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma reflection_same (x : M) :
    P.reflection i (P.reflection i x) = x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square with `0 : 0 ⟶ 0` on the bottom and `𝟙 X` on the top is a pushout square. -/
@[simp]
theorem zero_bot (X : C) : IsPushout (𝟙 X) (0 : X ⟶ 0) (0 : X ⟶ 0) (0 : (0 : C) ⟶ 0)
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_eq_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) = (y : EReal) ↔ x = y
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem range_subset {n m} : range n ⊆ range m ↔ n ≤ m
-- Mathlib/Data/Matrix/RowCol.lean
theorem diagonal_updateRow_single [DecidableEq n] [Zero α] (v : n → α) (i : n) (x : α) :
    (diagonal v).updateRow i (Pi.single i x) = diagonal (Function.update v i x)
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem opNorm_zero : ‖(0 : ContinuousMultilinearMap 𝕜 E G)‖ = 0
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem mem_ker_modByMonic (hq : q.Monic) {p : R[X]} :
    p ∈ LinearMap.ker (modByMonicHom q) ↔ q ∣ p
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_left_comm : a ∆ (b ∆ c) = b ∆ (a ∆ c)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem coe_normUnit {a : G₀} (h0 : a ≠ 0) : (↑(normUnit a) : G₀) = a⁻¹
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pullbackConeOfRightIso_snd : (pullbackConeOfRightIso f g).snd = f ≫ inv g
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem coe_eq_one_iff : (φ : PowerSeries R) = 1 ↔ φ = 1
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp]
theorem add_apply {f g : 𝓢(E, F)} {x : E} : (f + g) x = f x + g x
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem toQuadraticMap_comp_same (B : BilinMap R M N) (f : N' →ₗ[R] M) :
    BilinMap.toQuadraticMap (B.compl₁₂ f f) = B.toQuadraticMap.comp f
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive]
theorem closure_toSubmonoid (S : Set G) :
    (closure S).toSubmonoid = Submonoid.closure (S ∪ S⁻¹)
-- Mathlib/Order/GameAdd.lean
theorem gameAdd_mk_iff {rα rβ} {a₁ a₂ : α} {b₁ b₂ : β} :
    GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ rα a₁ a₂ ∧ b₁ = b₂ ∨ rβ b₁ b₂ ∧ a₁ = a₂
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem isPWO_insert {a} : IsPWO (insert a s) ↔ IsPWO s
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem edist_eq_iSup (f g : PiLp ∞ β) : edist f g = ⨆ i, edist (f i) (g i)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableWithinAt.sub_const (hf : DifferentiableWithinAt 𝕜 f s x) (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y - c) s x
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
/-- Simpler expression for the differential in the standard resolution of `k` as a
`G`-representation. It sends `(g₀, ..., gₙ₊₁) ↦ ∑ (-1)ⁱ • (g₀, ..., ĝᵢ, ..., gₙ₊₁)`. -/
theorem d_eq (n : ℕ) : ((groupCohomology.resolution k G).d (n + 1) n).hom = d k G (n + 1)
-- Mathlib/GroupTheory/PushoutI.lean
@[simp]
theorem lift_of (f : ∀ i, G i →* K) (k : H →* K)
    (hf : ∀ i, (f i).comp (φ i) = k)
    {i : ι} (g : G i) : (lift f k hf) (of i g : PushoutI φ) = f i g
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extChartAt_target_mem_nhdsWithin' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    (extChartAt I x).target ∈ 𝓝[range I] extChartAt I x y
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is maximized when
`f` and `g` monovary together. Stated by permuting the entries of `g`. -/
theorem Monovary.sum_smul_comp_perm_le_sum_smul (hfg : Monovary f g) :
    ∑ i, f i • g (σ i) ≤ ∑ i, f i • g i
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_of_le_of_lt {a b c : Int} (h₁ : a ≤ b) (h₂ : b < c) : a < c
-- Mathlib/Logic/Relator.lean
lemma BiTotal.rel_forall (h : BiTotal R) :
    ((R ⇒ Iff) ⇒ Iff) (fun p => ∀i, p i) (fun q => ∀i, q i)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_mul_apply_of_not_exists_add [Add G] (r : k) {g g' : G} (x : k[G])
    (h : ¬∃ d, g' = g + d) : (single g r * x) g' = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] protected theorem mul_zero (n : Nat) : n * 0 = 0
-- Mathlib/RingTheory/LaurentSeries.lean
theorem valuation_X_pow (s : ℕ) :
    Valued.v (((X : K⟦X⟧) : LaurentSeries K) ^ s) = Multiplicative.ofAdd (-(s : ℤ))
-- Mathlib/MeasureTheory/Measure/Count.lean
@[simp]
theorem count_apply_eq_top' (s_mble : MeasurableSet s) : count s = ∞ ↔ s.Infinite
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- In a Banach algebra `A` over a nontrivially normed field `𝕜`, for any `a : A` the
power series with coefficients `a ^ n` represents the function `(1 - z • a)⁻¹` in a disk of
radius `‖a‖₊⁻¹`. -/
theorem hasFPowerSeriesOnBall_inverse_one_sub_smul [CompleteSpace A] (a : A) :
    HasFPowerSeriesOnBall (fun z : 𝕜 => Ring.inverse (1 - z • a))
      (fun n => ContinuousMultilinearMap.mkPiRing 𝕜 (Fin n) (a ^ n)) 0 ‖a‖₊⁻¹
-- Mathlib/Topology/Sheaves/Skyscraper.lean
/-- Taking skyscraper presheaf at a point is functorial: `c ↦ skyscraper p₀ c` defines a functor by
sending every `f : a ⟶ b` to the natural transformation `α` defined as: `α(U) = f : a ⟶ b` if
`p₀ ∈ U` and the unique morphism to a terminal object in `C` if `p₀ ∉ U`.
-/
@[simps]
def skyscraperPresheafFunctor : C ⥤ Presheaf C X
-- Mathlib/Probability/Martingale/Basic.lean
theorem smul (c : ℝ) (hf : Martingale f ℱ μ) : Martingale (c • f) ℱ μ
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem comp_id (f : α →*₀o β) : f.comp (OrderMonoidWithZeroHom.id α) = f
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem mem_transpose {μ : YoungDiagram} {c : ℕ × ℕ} : c ∈ μ.transpose ↔ c.swap ∈ μ
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem lookmap_cons_some {a b : α} (l : List α) (h : f a = some b) :
    (a :: l).lookmap f = b :: l
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem Fintype.card_bool : Fintype.card Bool = 2
-- Mathlib/SetTheory/Game/Birthday.lean
theorem birthday_add_nat (n : ℕ) : (a + n).birthday = a.birthday + n
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_ne_last {a : Fin (n + 2)} {b : Fin (n + 1)} (ha : a ≠ last _) (hb : b ≠ last _) :
    a.succAbove b ≠ last _
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toBoundedOrderHom (f : BoundedLatticeHom α β) : ⇑f.toBoundedOrderHom = f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem differentiableAt_arccos {x : ℝ} : DifferentiableAt ℝ arccos x ↔ x ≠ -1 ∧ x ≠ 1
-- Mathlib/Algebra/MonoidAlgebra/Support.lean
lemma support_one_subset [Zero G] : (1 : k[G]).support ⊆ 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem map_add (x y : E) : f (x + y) = f x + f y
-- Mathlib/Topology/Semicontinuous.lean
theorem continuousAt_iff_lower_upperSemicontinuousAt {f : α → γ} :
    ContinuousAt f x ↔ LowerSemicontinuousAt f x ∧ UpperSemicontinuousAt f x
-- Mathlib/LinearAlgebra/Dimension/Finrank.lean
/-- Pushforwards of finite-dimensional submodules along a `LinearEquiv` have the same finrank. -/
theorem finrank_map_eq (f : M ≃ₗ[R] M₂) (p : Submodule R M) :
    finrank R (p.map (f : M →ₗ[R] M₂)) = finrank R p
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
theorem dvd_cancel_right_coe_nonZeroDivisors {x y : R'} {c : R'⁰} : x * c ∣ y * c ↔ x ∣ y
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem cancel_left_of_respectsIso
    (P : AffineTargetMorphismProperty) [P.toProperty.RespectsIso]
    {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso f] [IsAffine Z] : P (f ≫ g) ↔ P g
-- Mathlib/Algebra/Lie/TensorProduct.lean
theorem liftLie_apply (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) (m : M) (n : N) :
    liftLie R L M N P f (m ⊗ₜ n) = f m n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_Y_ne' {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3) :
    W.add P Q = W.dblZ P •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]
-- Mathlib/Order/Max.lean
theorem IsBot.snd (hx : IsBot x) : IsBot x.2
-- Mathlib/Order/SuccPred/Basic.lean
theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The cosine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
adjacent side, version subtracting vectors. -/
theorem cos_oangle_sub_left_mul_norm_of_oangle_eq_pi_div_two {x y : V}
    (h : o.oangle x y = ↑(π / 2)) : Real.Angle.cos (o.oangle (x - y) x) * ‖x - y‖ = ‖x‖
-- Mathlib/CategoryTheory/Closed/Functor.lean
/--
If the exponential comparison transformation (at `A`) is an isomorphism, then the Frobenius morphism
at `A` is an isomorphism.
-/
theorem frobeniusMorphism_iso_of_expComparison_iso (h : L ⊣ F) (A : C)
    [i : IsIso (expComparison F A)] : IsIso (frobeniusMorphism F h A)
-- Mathlib/Topology/Inseparable.lean
theorem subtype_inseparable_iff {p : X → Prop} (x y : Subtype p) : (x ~ᵢ y) ↔ ((x : X) ~ᵢ y)
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
/-- Theorems about `padicNormE` are named with a `'` so the names do not conflict with the
equivalent theorems about `norm` (`‖ ‖`). -/
theorem nonarchimedean' (q r : ℚ_[p]) :
    padicNormE (q + r : ℚ_[p]) ≤ max (padicNormE q) (padicNormE r)
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem Finset.union_symm_inl (h : Disjoint s t) (x : s) :
    Equiv.Finset.union s t h (Sum.inl x) = ⟨x, Finset.mem_union.mpr <| Or.inl x.2⟩
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma preΨ_ofNat (n : ℕ) : W.preΨ n = W.preΨ' n
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem sup_mul_eq_of_coprime_right (h : I ⊔ K = ⊤) : I ⊔ J * K = I ⊔ J
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
@[simp]
theorem comm_trans_lTensorOne :
    (TensorProduct.comm R _ _).trans M.lTensorOne = M.rTensorOne
-- Mathlib/SetTheory/Game/Birthday.lean
theorem neg_birthday_le : -x.birthday.toPGame ≤ x
-- Mathlib/Order/Lattice.lean
theorem sup_ind (a b : α) {p : α → Prop} (ha : p a) (hb : p b) : p (a ⊔ b)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_pow [Monoid R] [AddMonoid M] [DistribMulAction R M] [DistribMulAction Rᵐᵒᵖ M]
    (x : tsze R M) (n : ℕ) : fst (x ^ n) = x.fst ^ n
-- Mathlib/Data/Finset/Lattice.lean
theorem mem_sup {α β} [DecidableEq β] {s : Finset α} {f : α → Multiset β} {x : β} :
    x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem IicSnd_mono {r r' : ℝ} (h_le : r ≤ r') : ρ.IicSnd r ≤ ρ.IicSnd r'
-- Mathlib/Data/Option/Defs.lean
theorem iget_some [Inhabited α] {a : α} : (some a).iget = a
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem natAbs_zero : natAbs (0 : Int) = (0 : Nat)
-- Mathlib/Data/Finset/Prod.lean
@[gcongr]
theorem product_subset_product_right (ht : t ⊆ t') : s ×ˢ t ⊆ s ×ˢ t'
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem single_eq_monomial (s : σ →₀ ℕ) (a : R) : Finsupp.single s a = monomial s a
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem root_left_of_root_gcd [CommSemiring k] [DecidableEq R] {ϕ : R →+* k} {f g : R[X]} {α : k}
    (hα : (EuclideanDomain.gcd f g).eval₂ ϕ α = 0) : f.eval₂ ϕ α = 0
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
@[fun_prop]
protected theorem hasFDerivWithinAt : HasFDerivWithinAt iso (iso : E →L[𝕜] F) s x
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem lift_top (K : IntermediateField F E) :
    lift (F := K) ⊤ = K
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem exists_eq_add_of_le (h : m ≤ n) : ∃ k : Nat, n = m + k
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem toIsometryEquiv_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} :
    f.toIsometryEquiv = g.toIsometryEquiv ↔ f = g
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem ofSubalgebras_apply (h : L₁'.map ↑e = L₂') (x : L₁') : ↑(e.ofSubalgebras _ _ h x) = e x
-- Mathlib/Data/Nat/PrimeFin.lean
lemma le_of_mem_primeFactors (h : p ∈ n.primeFactors) : p ≤ n
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem coprod.map_swap {A B X Y : C} (f : A ⟶ B) (g : X ⟶ Y)
    [HasColimitsOfShape (Discrete WalkingPair) C] :
    coprod.map (𝟙 X) f ≫ coprod.map g (𝟙 B) = coprod.map g (𝟙 A) ≫ coprod.map (𝟙 Y) f
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp]
theorem neg_units_ne_self (u : Rˣ) : -u ≠ u
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
protected theorem map_apply {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
    (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) (i : ι) : b.map L i = L (b i)