ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive] lemma integral_eq_tsum'' (h : IsFundamentalDomain G s μ)
    (f : α → E) (hf : Integrable f μ) : ∫ x, f x ∂μ = ∑' g : G, ∫ x in s, f (g • x) ∂μ
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem map_update_smul [DecidableEq ι] [Fintype ι] (m : ∀ i, M₁ i) (i : ι) (c : R) (x : M₁ i) :
    f (update (c • m) i x) = c ^ (Fintype.card ι - 1) • f (update m i x)
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
theorem OpenCover.compactSpace {X : Scheme.{u}} (𝒰 : X.OpenCover) [Finite 𝒰.J]
    [H : ∀ i, CompactSpace (𝒰.obj i)] : CompactSpace X
-- Mathlib/Topology/Homotopy/Basic.lean
theorem extend_apply_of_le_zero (F : Homotopy f₀ f₁) {t : ℝ} (ht : t ≤ 0) (x : X) :
    F.extend t x = f₀ x
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsionBySet_span_singleton_eq : torsionBySet R M (R ∙ a) = torsionBy R M a
-- Mathlib/Algebra/Star/Unitary.lean
@[norm_cast]
theorem coe_zpow (U : unitary R) (z : ℤ) : ↑(U ^ z) = (U : R) ^ z
-- Mathlib/Algebra/Group/Prod.lean
/-- Division as a monoid homomorphism. -/
@[to_additive (attr := simps) "Subtraction as an additive monoid homomorphism."]
def divMonoidHom [DivisionCommMonoid α] : α × α →* α
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- 0 is weighted homogeneous of any degree. -/
theorem isWeightedHomogeneous_zero (w : σ → M) (m : M) :
    IsWeightedHomogeneous w (0 : MvPolynomial σ R) m
-- Mathlib/RingTheory/Valuation/Integers.lean
theorem one_of_isUnit' {x : O} (hx : IsUnit x) (H : ∀ x, v (algebraMap O R x) ≤ 1) :
    v (algebraMap O R x) = 1
-- Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
/-- The point given by `secondInter` equals the original point if and only if the line is
orthogonal to the radius vector. -/
theorem Sphere.secondInter_eq_self_iff {s : Sphere P} {p : P} {v : V} :
    s.secondInter p v = p ↔ ⟪v, p -ᵥ s.center⟫ = 0
-- Mathlib/Topology/ContinuousOn.lean
theorem insert_mem_nhds_iff {a : α} {s : Set α} : insert a s ∈ 𝓝 a ↔ s ∈ 𝓝[≠] a
-- Mathlib/Algebra/Group/Action/Basic.lean
@[simp]
protected lemma Equiv.Perm.smul_def {α : Type*} (f : Equiv.Perm α) (a : α) : f • a = f a
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem exp_mem_unitary_of_mem_skewAdjoint [StarRing 𝔸] [ContinuousStar 𝔸] {x : 𝔸}
    (h : x ∈ skewAdjoint 𝔸) : exp 𝕂 x ∈ unitary 𝔸
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
theorem integral_Ioi_rpow_of_lt {a : ℝ} (ha : a < -1) {c : ℝ} (hc : 0 < c) :
    ∫ t : ℝ in Ioi c, t ^ a = -c ^ (a + 1) / (a + 1)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem wellFounded_associates : WellFounded ((· < ·) : Associates α → Associates α → Prop)
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem eq_of_xn_modEq_lem1 {i n} : ∀ {j}, i < j → j < n → xn a1 i % xn a1 n < xn a1 j % xn a1 n
-- Mathlib/Analysis/Convex/Join.lean
theorem convexHull_union (hs : s.Nonempty) (ht : t.Nonempty) :
    convexHull 𝕜 (s ∪ t) = convexJoin 𝕜 (convexHull 𝕜 s) (convexHull 𝕜 t)
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma hom_ext_of_isLeftKanExtension {G : D ⥤ H} (γ₁ γ₂ : F' ⟶ G)
    (hγ : α ≫ whiskerLeft L γ₁ = α ≫ whiskerLeft L γ₂) : γ₁ = γ₂
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem HeapNode.realSize_toHeap (s : HeapNode α) : s.toHeap.realSize = s.realSize
-- Mathlib/Algebra/CharP/Algebra.lean
/-- If a ring homomorphism `R →+* A` is injective then `A` has the same characteristic as `R`. -/
theorem charP_of_injective_ringHom {R A : Type*} [NonAssocSemiring R] [NonAssocSemiring A]
    {f : R →+* A} (h : Function.Injective f) (p : ℕ) [CharP R p] : CharP A p
-- Mathlib/Data/List/Range.lean
theorem nthLe_range'_1 {n m} (i) (H : i < (range' n m).length) :
    nthLe (range' n m) i H = n + i
-- Mathlib/Analysis/Complex/Basic.lean
theorem nndist_self_conj (z : ℂ) : nndist z (conj z) = 2 * Real.nnabs z.im
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (h : b + a = c + a) : b = c
-- Mathlib/GroupTheory/PushoutI.lean
theorem base_smul_eq_smul (h : H) (w : NormalWord d) :
    base φ h • w = h • w
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem colimit.pre_map' [HasColimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂) :
    colimit.pre F E₁ = colim.map (whiskerRight α F) ≫ colimit.pre F E₂
-- Mathlib/Order/GaloisConnection.lean
theorem u_surjective [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) : Surjective u
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
/-- If `g, h ≤ f` and `g i + h i ≤ f i`, then the product of `f` over `s` is at least the
  sum of the products of `g` and `h`. This is the version for `CanonicallyOrderedCommSemiring`.
-/
lemma prod_add_prod_le' (hi : i ∈ s) (h2i : g i + h i ≤ f i) (hgf : ∀ j ∈ s, j ≠ i → g j ≤ f j)
    (hhf : ∀ j ∈ s, j ≠ i → h j ≤ f j) : ((∏ i ∈ s, g i) + ∏ i ∈ s, h i) ≤ ∏ i ∈ s, f i
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma isZero_zero [Nontrivial (weightSpace M (0 : L → R))] : IsZero (0 : Weight R L M)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
/-- The complex sine function is everywhere differentiable, with the derivative `cos x`. -/
theorem hasDerivAt_sin (x : ℂ) : HasDerivAt sin (cos x) x
-- Mathlib/Algebra/MvPolynomial/Comap.lean
@[simp]
theorem comap_apply (f : MvPolynomial σ R →ₐ[R] MvPolynomial τ R) (x : τ → R) (i : σ) :
    comap f x i = aeval x (f (X i))
-- Mathlib/Algebra/Module/Injective.lean
theorem extensionOfMax_le (h : Module.Baer R Q) {y : N} :
    extensionOfMax i f ≤ extensionOfMaxAdjoin i f h y
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem isNormal_comap {S : Subgroupoid D} (Sn : IsNormal S) : IsNormal (comap φ S)
-- Mathlib/Algebra/Ring/Defs.lean
theorem distrib_three_right [Mul R] [Add R] [RightDistribClass R] (a b c d : R) :
    (a + b + c) * d = a * d + b * d + c * d
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_congr_ae (hT : DominatedFinMeasAdditive μ T C) (h : f =ᵐ[μ] g) :
    setToFun μ T hT f = setToFun μ T hT g
-- Mathlib/Data/Fintype/BigOperators.lean
@[to_additive (attr := simp)]
theorem Fintype.prod_sum_type (f : α₁ ⊕ α₂ → M) :
    ∏ x, f x = (∏ a₁, f (Sum.inl a₁)) * ∏ a₂, f (Sum.inr a₂)
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_natTrailingDegree : p.mirror.natTrailingDegree = p.natTrailingDegree
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
    {F : Filter ι} [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) :
    ⋃ i : ι, Ici (as i) = Ioi x
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mul_mem_mul : a ∈ s → b ∈ t → a * b ∈ s * t
-- Mathlib/Data/Rel.lean
theorem dom_inv : r.inv.dom = r.codom
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem deriv.neg : deriv (fun y => -f y) x = -deriv f x
-- Mathlib/Combinatorics/Hall/Finite.lean
/-- This is the version of **Hall's Marriage Theorem** in terms of indexed
families of finite sets `t : ι → Finset α` with `ι` finite.
It states that there is a set of distinct representatives if and only
if every union of `k` of the sets has at least `k` elements.

See `Finset.all_card_le_biUnion_card_iff_exists_injective` for a version
where the `Finite ι` constraint is removed.
-/
theorem Finset.all_card_le_biUnion_card_iff_existsInjective' {ι α : Type*} [Finite ι]
    [DecidableEq α] (t : ι → Finset α) :
    (∀ s : Finset ι, s.card ≤ (s.biUnion t).card) ↔
      ∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
lemma IsLocalDiffeomorph.image_coe (hf : IsLocalDiffeomorph I J n f) : hf.image.1 = range f
-- Mathlib/Logic/Basic.lean
theorem exists_of_exists_mem : (∃ (x : _) (_ : p x), q x) → ∃ x, q x
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem takeD_length : ∀ n l a, length (@takeD α n l a) = n
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_map_equiv {Y} [MeasurableSpace Y] (e : X ≃ᵐ Y) (f : Y → E) (s : Set Y) :
    ∫ y in s, f y ∂Measure.map e μ = ∫ x in e ⁻¹' s, f (e x) ∂μ
-- Mathlib/NumberTheory/NumberField/Basic.lean
@[ext] theorem ext {x y : 𝓞 K} (h : (x : K) = (y : K)) : x = y
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
/-- See `MvPolynomial.IsHomogeneous.funext`
for a version that assumes `Infinite R`. -/
lemma funext_of_le_card (hF : F.IsHomogeneous n) (hG : G.IsHomogeneous n)
    (h : ∀ r : σ → R, eval r F = eval r G) (hnR : n ≤ #R) :
    F = G
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem proj_comp_of_subset (h : ∀ i, J i → K i) : (Proj J ∘ Proj K) =
    (Proj J : (I → Bool) → (I → Bool))
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem div_isBoundedUnder_of_isBigO {α : Type*} {l : Filter α} {f g : α → 𝕜} (h : f =O[l] g) :
    IsBoundedUnder (· ≤ ·) l fun x => ‖f x / g x‖
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.prod_le {s : Finset ι} {f : ι → Ideal R} {P : Ideal R} (hp : IsPrime P) :
    s.prod f ≤ P ↔ ∃ i ∈ s, f i ≤ P
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_congr (h : ∀ n : ℕ, a ≤ n ↔ b ≤ n) : ⌈a⌉₊ = ⌈b⌉₊
-- Mathlib/Logic/Basic.lean
theorem forall_prop_congr {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
    (∀ h, q h) ↔ ∀ h : p', q' (hp.2 h)
-- Mathlib/Combinatorics/SimpleGraph/Hasse.lean
theorem hasse_preconnected_of_succ [SuccOrder α] [IsSuccArchimedean α] : (hasse α).Preconnected
-- Mathlib/Algebra/Field/Subfield.lean
theorem eq_of_eqOn_subfield_top {f g : K →+* L} (h : Set.EqOn f g (⊤ : Subfield K)) : f = g
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem injective_subtype (s : AffineSubspace k P) [Nonempty s] : Function.Injective s.subtype
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
theorem modOf_add_divOf (x : k[G]) (g : G) : x %ᵒᶠ g + of' k G g * (x /ᵒᶠ g) = x
-- Mathlib/Data/List/Basic.lean
theorem map_erase [DecidableEq β] {f : α → β} (finj : Injective f) {a : α} (l : List α) :
    map f (l.erase a) = (map f l).erase (f a)
-- Mathlib/Order/Lattice.lean
theorem inf_le_of_left_le (h : a ≤ c) : a ⊓ b ≤ c
-- Mathlib/Data/Real/Hyperreal.lean
theorem gt_of_tendsto_zero_of_neg {f : ℕ → ℝ} (hf : Tendsto f atTop (𝓝 0)) :
    ∀ {r : ℝ}, r < 0 → (r : ℝ*) < ofSeq f
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem reverse_nil {u : V} : (nil : G.Walk u u).reverse = nil
-- Mathlib/RingTheory/Multiplicity.lean
theorem not_finite_iff_forall {a b : α} : ¬Finite a b ↔ ∀ n : ℕ, a ^ n ∣ b
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- The `NonUnitalSubsemiring` generated by a multiplicative subsemigroup coincides with the
`NonUnitalSubsemiring.closure` of the subsemigroup itself . -/
theorem nonUnitalSubsemiringClosure_eq_closure :
    M.nonUnitalSubsemiringClosure = NonUnitalSubsemiring.closure (M : Set R)
-- Mathlib/ModelTheory/Definability.lean
theorem Definable.mono (hAs : A.Definable L s) (hAB : A ⊆ B) : B.Definable L s
-- Mathlib/CategoryTheory/ConnectedComponents.lean
/-- The inclusion functor from a connected component to the whole category. -/
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem op_iSup (S : ι → Submonoid M) : (iSup S).op = ⨆ i, (S i).op
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
private theorem two_mul_sub_one {n : Nat} (n_pos : n > 0) : (2*n - 1) % 2 = 1
-- Mathlib/Data/Fintype/Perm.lean
theorem mem_permsOfList_of_mem {l : List α} {f : Perm α} (h : ∀ x, f x ≠ x → x ∈ l) :
    f ∈ permsOfList l
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigOWith_top : IsBigOWith c ⊤ f g ↔ ∀ x, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Deprecated/Subring.lean
theorem IsSubring.iInter {ι : Sort*} {S : ι → Set R} (h : ∀ y : ι, IsSubring (S y)) :
    IsSubring (Set.iInter S)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mod_eq_of_lt {a b : Ordinal} (h : a < b) : a % b = a
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- Open elements `s : Set (α × α)` of `𝓤 α` such that `(x, y) ∈ s ↔ (y, x) ∈ s` form a basis
of `𝓤 α`. -/
theorem uniformity_hasBasis_open_symmetric :
    HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsOpen V ∧ SymmetricRel V) id
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem joinedIn_univ : JoinedIn univ x y ↔ Joined x y
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem map_inj {f g : α → β} : Option.map f = Option.map g ↔ f = g
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem ciSup_mono' {ι'} {f : ι → α} {g : ι' → α} (hg : BddAbove (range g))
    (h : ∀ i, ∃ i', f i ≤ g i') : iSup f ≤ iSup g
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem top_coe_submodule : ((⊤ : LieSubalgebra R L) : Submodule R L) = ⊤
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem le_map_of_comap_le_of_surjective : comap f K ≤ I → K ≤ map f I
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
/-- Subtracting `x` from the all ones bitvector is equivalent to taking its complement -/
theorem allOnes_sub_eq_not (x : BitVec w) : allOnes w - x = ~~~x
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem terminatedAt_iff_partDen_none : g.TerminatedAt n ↔ g.partDens.get? n = none
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
@[simp]
theorem cycleType_extendDomain {β : Type*} [Fintype β] [DecidableEq β] {p : β → Prop}
    [DecidablePred p] (f : α ≃ Subtype p) {g : Perm α} :
    cycleType (g.extendDomain f) = cycleType g
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem addChar_right_comm (p : Pos) (c₁ c₂ : Char) : p + c₁ + c₂ = p + c₂ + c₁
-- Mathlib/Order/JordanHolder.lean
@[refl]
theorem refl (s : CompositionSeries X) : Equivalent s s
-- Mathlib/Order/SymmDiff.lean
theorem bihimp_eq_inf_himp_inf : a ⇔ b = a ⊔ b ⇨ a ⊓ b
-- Mathlib/LinearAlgebra/Ray.lean
/-- `SameRay` is symmetric. -/
@[symm]
theorem symm (h : SameRay R x y) : SameRay R y x
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_neg_Ico : -Ico a b = Ioc (-b) (-a)
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma polyCharpolyAux_map_eval [Module.Finite R M] [Module.Free R M]
    (x : ι → R) :
    (polyCharpolyAux φ b bₘ).map (MvPolynomial.eval x) =
      (φ (b.repr.symm (Finsupp.equivFunOnFinite.symm x))).charpoly
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem degrees_prod {ι : Type*} (s : Finset ι) (f : ι → MvPolynomial σ R) :
    (∏ i ∈ s, f i).degrees ≤ ∑ i ∈ s, (f i).degrees
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.smul_measure_nnreal {f : α → β} (h : Integrable f μ) {c : ℝ≥0} :
    Integrable f (c • μ)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem order_pow {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Semiring R] [NoZeroDivisors R]
    (x : HahnSeries Γ R) (n : ℕ) : (x ^ n).order = n • x.order
-- .lake/packages/batteries/Batteries/Data/Sum/Basic.lean
@[simp] theorem isLeft_inr : (inr x : α ⊕ β).isLeft = false
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
theorem coordinate_eval_6 :
    (coordinate 6).eval (.ofList (a0 :: a1 :: a2 :: a3 :: a4 :: a5 :: a6 :: t)) = a6
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem isOneCocycle_of_oneCocycles (f : oneCocycles (Rep.ofDistribMulAction k G A)) :
    IsOneCocycle (A := A) f.1
-- Mathlib/Combinatorics/Derangements/Finite.lean
theorem numDerangements_succ (n : ℕ) :
    (numDerangements (n + 1) : ℤ) = (n + 1) * (numDerangements n : ℤ) - (-1) ^ n
-- Mathlib/Topology/MetricSpace/Holder.lean
@[simp]
theorem holderOnWith_singleton (C r : ℝ≥0) (f : X → Y) (x : X) : HolderOnWith C r f {x}
-- Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
@[simp]
theorem fork_π_app_walkingParallelPair_zero : (fork F U).π.app WalkingParallelPair.zero = res F U
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.union {s t : Set M} (hs : LinearIndependent R (fun x => x : s → M))
    (ht : LinearIndependent R (fun x => x : t → M)) (hst : Disjoint (span R s) (span R t)) :
    LinearIndependent R (fun x => x : ↥(s ∪ t) → M)
-- Mathlib/Algebra/Category/MonCat/Colimits.lean
@[simp]
theorem cocone_naturality_components (j j' : J) (f : j ⟶ j') (x : F.obj j) :
    (coconeMorphism F j') (F.map f x) = (coconeMorphism F j) x
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_eq_of_dvd_sub_right {a b c : α} (h : a ∣ b - c) : gcd a b = gcd a c
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- If `R` satisfies the strong rank condition,
then any linearly independent family `v : ι → M`
contained in the span of some finite `w : Set M`,
is itself finite.
-/
lemma LinearIndependent.finite_of_le_span_finite {ι : Type*} (v : ι → M) (i : LinearIndependent R v)
    (w : Set M) [Finite w] (s : range v ≤ span R w) : Finite ι
-- Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean
@[fun_prop]
theorem DifferentiableOn.restrictScalars (h : DifferentiableOn 𝕜' f s) : DifferentiableOn 𝕜 f s
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
/-- A split short complex is short exact. -/
lemma Splitting.shortExact {S : ShortComplex C} [HasZeroObject C] (s : S.Splitting) :
    S.ShortExact
-- Mathlib/Data/Num/Lemmas.lean
theorem succ_ofInt' : ∀ n, ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1
-- Mathlib/Probability/Martingale/Basic.lean
theorem condexp_ae_le [LE E] (hf : Supermartingale f ℱ μ) {i j : ι} (hij : i ≤ j) :
    μ[f j|ℱ i] ≤ᵐ[μ] f i
-- Mathlib/Analysis/Normed/Group/InfiniteSum.lean
theorem summable_iff_vanishing_norm [CompleteSpace E] {f : ι → E} :
    Summable f ↔ ∀ ε > (0 : ℝ), ∃ s : Finset ι, ∀ t, Disjoint t s → ‖∑ i ∈ t, f i‖ < ε
-- Mathlib/Data/ENNReal/Operations.lean
theorem smul_def {M : Type*} [MulAction ℝ≥0∞ M] (c : ℝ≥0) (x : M) : c • x = (c : ℝ≥0∞) • x
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem hasCompactMulSupport_def : HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f))
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasStrictDerivAt.comp_hasStrictFDerivAt {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} (x)
    (hh : HasStrictDerivAt h₂ h₂' (f x)) (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (h₂ ∘ f) (h₂' • f') x
-- Mathlib/Tactic/Ring/Basic.lean
theorem mul_add {d : R} (_ : (a : R) * b₁ = c₁) (_ : a * b₂ = c₂) (_ : c₁ + 0 + c₂ = d) :
    a * (b₁ + b₂) = d
-- Mathlib/Topology/Compactness/Compact.lean
/-- A compact discrete space is finite. -/
theorem finite_of_compact_of_discrete [CompactSpace X] [DiscreteTopology X] : Finite X
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_setOf [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { x | p x }] :
    { x | p x }.toFinset = Finset.univ.filter p
-- Mathlib/Order/Minimal.lean
@[simp]
theorem maximals_idem : maximals r (maximals r s) = maximals r s
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem norm_le_seminorm (f : 𝓢(E, F)) (x₀ : E) : ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem integrable_iff_integrableAtFilter_atTop [LinearOrder X] [OrderBot X] [CompactIccSpace X] :
    Integrable f μ ↔ IntegrableAtFilter f atTop μ ∧ LocallyIntegrable f μ
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
@[simp]
lemma binaryProductIso_inv_comp_fst_apply (a : C) (z : (prod F G).obj a) :
    (Limits.prod.fst (X := F)).app a ((binaryProductIso F G).inv.app a z) = z.1
-- Mathlib/Order/Interval/Set/Image.lean
lemma Monotone.image_Iic_subset (h : Monotone f) : f '' Iic b ⊆ Iic (f b)
-- Mathlib/RingTheory/Adjoin/Basic.lean
/-- If `K / E / F` is a ring extension tower, `L` is a subalgebra of `K / F`,
then `E[L]` is generated by any basis of `L / F` as an `E`-module. -/
theorem Subalgebra.adjoin_eq_span_basis {ι : Type*} (bL : Basis ι F L) :
    toSubmodule (adjoin E (L : Set K)) = span E (Set.range fun i : ι ↦ (bL i).1)
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
lemma endMulEquivAutGalois_pi (f : End F) (A : PointedGaloisObject F) :
    F.map (AutGalois.π F A (endMulEquivAutGalois F f).unop).hom A.2 = f.app A A.pt
-- Mathlib/Order/GameAdd.lean
theorem GameAdd.fst_snd {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(a₁, b) s(b, a₂)
-- Mathlib/Topology/Category/TopCat/Basic.lean
@[simp]
theorem openEmbedding_iff_comp_isIso' {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) [IsIso g] :
    OpenEmbedding ((forget TopCat).map f ≫ (forget TopCat).map g) ↔ OpenEmbedding f
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_mk [SupSet α] [SupSet β] (f : ι → α) (g : ι → β) :
    ⨆ i, (f i, g i) = (⨆ i, f i, ⨆ i, g i)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem coe_prod : (prod S S₁ : Set (A × B)) = (S : Set A) ×ˢ S₁
-- Mathlib/Order/Chain.lean
theorem Set.Subsingleton.isChain (hs : s.Subsingleton) : IsChain r s
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem sum_congr {μ ν : ℕ → Measure α} (h : ∀ n, μ n = ν n) : sum μ = sum ν
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `del` function has the `DelProp` property. -/
protected theorem Balanced.del {t : RBNode α} (h : t.Balanced c n) :
    (t.del cut).DelProp t.isBlack n
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_mul_natCast (hx : 0 ≤ x) (y : ℝ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n
-- Mathlib/Algebra/Opposites.lean
@[to_additive (attr := simp)]
theorem unop_comp_op : (unop : αᵐᵒᵖ → α) ∘ op = id
-- Mathlib/CategoryTheory/Quotient.lean
theorem CompClosure.of {a b : C} (m₁ m₂ : a ⟶ b) (h : r m₁ m₂) : CompClosure r m₁ m₂
-- Mathlib/Data/Matrix/Basic.lean
theorem smul_eq_mul_diagonal [Fintype n] [DecidableEq n] (M : Matrix m n α) (a : α) :
    a • M = M * diagonal fun _ => a
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
/-- Any linear form on a topological vector space over a nontrivially normed field is continuous if
    and only if its kernel is closed. -/
theorem LinearMap.continuous_iff_isClosed_ker (l : E →ₗ[𝕜] 𝕜) :
    Continuous l ↔ IsClosed (LinearMap.ker l : Set E)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem map_map_symm (e : α ≃ᵐ β) : (ν.map e.symm).map e = ν
-- Mathlib/CategoryTheory/Grothendieck.lean
/-- Composition of morphisms in the Grothendieck category.
-/
@[simps]
def comp {X Y Z : Grothendieck F} (f : Hom X Y) (g : Hom Y Z) : Hom X Z
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem one_le_of_lt_one {w : InfinitePlace K} {a : (𝓞 K)} (ha : a ≠ 0)
    (h : ∀ ⦃z⦄, z ≠ w → z a < 1) : 1 ≤ w a
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem comap_iInf {ι : Sort*} (f : F) (s : ι → NonUnitalSubring S) :
    (iInf s).comap f = ⨅ i, (s i).comap f
-- Mathlib/Algebra/Quaternion.lean
theorem normSq_coe : normSq (x : ℍ[R]) = x ^ 2
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem toPartialEquiv_coe_symm : (I.toPartialEquiv.symm : E → H) = I.symm
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem pushoutComparison_map_desc (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g]
    [HasPushout (G.map f) (G.map g)] {W : C} {h : Y ⟶ W} {k : Z ⟶ W} (w : f ≫ h = g ≫ k) :
    pushoutComparison G f g ≫ G.map (pushout.desc _ _ w) =
      pushout.desc (G.map h) (G.map k) (by simp only [← G.map_comp, w])
-- Mathlib/Data/NNReal/Basic.lean
theorem image_real_toNNReal (h : s.OrdConnected) : (Real.toNNReal '' s).OrdConnected
-- Mathlib/Topology/Maps/Basic.lean
theorem closure_image_eq (hf : ClosedEmbedding f) (s : Set X) :
    closure (f '' s) = f '' closure s
-- Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean
@[simp]
lemma associator_inv_app (F₁ F₂ F₃ : J ⥤ C) (j : J) :
    (α_ F₁ F₂ F₃).inv.app j = (α_ _ _ _).inv
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem le_TFAE : List.TFAE [I ≤ J, (I : Set (ι → ℝ)) ⊆ J,
    Icc I.lower I.upper ⊆ Icc J.lower J.upper, J.lower ≤ I.lower ∧ I.upper ≤ J.upper]
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toDFinsupp_replicate (a : α) (n : ℕ) :
    toDFinsupp (Multiset.replicate n a) = DFinsupp.single a n
-- Mathlib/CategoryTheory/Sites/Coverage.lean
lemma le_of_factorsThru_sieve {X : C} (S : Presieve X) (T : Sieve X) (h : S.FactorsThru T) :
    S ≤ T
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem iUnion_iUnion_eq_right {b : β} {s : ∀ x : β, b = x → Set α} :
    ⋃ (x) (h : b = x), s x h = s b rfl
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp] lemma nonempty_Iic : (Iic a).Nonempty