ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_iSup_map_of_injective {ι : Sort*} (S : ι → Submodule R M) :
    (⨆ i, (S i).map f).comap f = iSup S
-- Mathlib/Order/UpperLower/Basic.lean
nonrec lemma Ici_injective : Injective (Ici : α → UpperSet α)
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
@[simp]
theorem assoc_symm_tmul (m : M) (p : P) (q : Q) :
    (assoc R A B M P Q).symm (m ⊗ₜ (p ⊗ₜ q)) = (m ⊗ₜ p) ⊗ₜ q
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem equivOfEq_rfl (S : IntermediateField F E) : equivOfEq (rfl : S = S) = AlgEquiv.refl
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem coe_lcs_eq : LieSubmodule.toSubmodule (I.lcs M k) = lowerCentralSeries R I M k
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc, simp]
theorem whiskerLeft_comp (W : C) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    W ◁ (f ≫ g) = W ◁ f ≫ W ◁ g
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
@[simp]
theorem coeff_scaleRoots (p : R[X]) (s : R) (i : ℕ) :
    (scaleRoots p s).coeff i = coeff p i * s ^ (p.natDegree - i)
-- Mathlib/Data/PFun.lean
@[simp]
theorem mem_preimage (s : Set β) (x : α) : x ∈ f.preimage s ↔ ∃ y ∈ s, y ∈ f x
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toList_toFinset [DecidableEq α] (s : Finset α) : s.toList.toFinset = s
-- Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean
theorem liftR_map_last [lawful : LawfulMvFunctor F]
    {α : TypeVec n} {ι ι'} (R : ι' → ι' → Prop)
    (x : F (α ::: ι)) (f g : ι → ι') (hh : ∀ x : ι, R (f x) (g x)) :
    LiftR' (RelLast' _ R) ((id ::: f) <$$> x) ((id ::: g) <$$> x)
-- .lake/packages/batteries/Batteries/Classes/Order.lean
protected theorem TransCmp.compareOfLessAndEq
    [LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
    (lt_irrefl : ∀ x : α, ¬x < x)
    (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
    (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
    TransCmp (α := α) (compareOfLessAndEq · ·)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to negative infinity along a nontrivial filter `l`,
then `fun x ↦ r * f x` tends to infinity if and only if `r < 0. `-/
theorem tendsto_const_mul_atTop_iff_neg [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atTop ↔ r < 0
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Three points are collinear if and only if they are not affinely
independent. -/
theorem collinear_iff_not_affineIndependent {p : Fin 3 → P} :
    Collinear k (Set.range p) ↔ ¬AffineIndependent k p
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
@[simp]
theorem IsHermitian.add {A B : Matrix n n α} (hA : A.IsHermitian) (hB : B.IsHermitian) :
    (A + B).IsHermitian
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubgroup A} {x : A} : a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem ofSet_eq_refl {s : Set α} [DecidablePred (· ∈ s)] :
    ofSet s = PEquiv.refl α ↔ s = Set.univ
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem smul_eq_empty : s • t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Data/ENNReal/Inv.lean
theorem exists_nnreal_pos_mul_lt (ha : a ≠ ∞) (hb : b ≠ 0) : ∃ n > 0, ↑(n : ℝ≥0) * a < b
-- Mathlib/Data/Nat/Multiplicity.lean
/-- The multiplicity of `p` in `(p * n)!` is `n` more than that of `n!`. -/
theorem multiplicity_factorial_mul {n p : ℕ} (hp : p.Prime) :
    multiplicity p (p * n)! = multiplicity p n ! + n
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
private theorem measure_le_sInf (h : ∀ μ' ∈ m, μ ≤ μ') : μ ≤ sInf m
-- Mathlib/Topology/Basic.lean
theorem Dense.nonempty [h : Nonempty X] (hs : Dense s) : s.Nonempty
-- Mathlib/Data/Set/Lattice.lean
theorem compl_iUnion₂ (s : ∀ i, κ i → Set α) : (⋃ (i) (j), s i j)ᶜ = ⋂ (i) (j), (s i j)ᶜ
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_lt_iff_tsub_lt (h₁ : b ≤ a) (h₂ : c ≤ a) : a - b < c ↔ a - c < b
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Pasting.lean
@[reassoc (attr := simp)]
theorem inl_inl_pushoutLeftPushoutInrIso_hom :
    pushout.inl _ _ ≫ pushout.inl _ _ ≫ (pushoutLeftPushoutInrIso f g g').hom =
      pushout.inl _ _
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem hasFDerivAtFilter_iff_tendsto :
    HasFDerivAtFilter f f' x L ↔
      Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)
-- Mathlib/Order/SymmDiff.lean
theorem bihimp_right_involutive (a : α) : Involutive (a ⇔ ·)
-- Mathlib/Algebra/Divisibility/Basic.lean
@[simp]
theorem dvd_mul_left (a b : α) : a ∣ b * a
-- Mathlib/Data/Int/Defs.lean
lemma pred_neg_pred (a : ℤ) : pred (-pred a) = -a
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem image_mul_right' :
    image (· * b⁻¹) t = preimage t (· * b) (mul_left_injective _).injOn
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem subtypeₐᵢ_toAffineMap (s : AffineSubspace 𝕜 P) [Nonempty s] :
    s.subtypeₐᵢ.toAffineMap = s.subtype
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_idem : (a \ b) \ b = a \ b
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem totallyBounded_iff_subset_finite_iUnion_nhds_one {s : Set α} :
    TotallyBounded s ↔ ∀ U ∈ 𝓝 (1 : α), ∃ t : Set α, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem ker_eq_comap_bot (f : F) : ker f = Ideal.comap f ⊥
-- Mathlib/Algebra/ContinuedFractions/Computation/ApproximationCorollaries.lean
theorem of_convergence [TopologicalSpace K] [OrderTopology K] :
    Filter.Tendsto (of v).convs Filter.atTop <| 𝓝 v
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
theorem Away.eventually_smul_mem {m} (hf : f ∈ 𝒜 m) (z : Away 𝒜 f) :
    ∀ᶠ n in Filter.atTop, f ^ n • z.val ∈ algebraMap _ _ '' (𝒜 (n • m) : Set A)
-- Mathlib/Data/Nat/Defs.lean
lemma succ_div : ∀ a b : ℕ, (a + 1) / b = a / b + if b ∣ a + 1 then 1 else 0
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[continuity]
lemma continuous_dist : Continuous fun p : α × α ↦ dist p.1 p.2
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[instance]
theorem ordConnected_Ioc {a b : α} : OrdConnected (Ioc a b)
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma div : MeromorphicOn (s / t) U
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem rootMultiplicity_mul' {p q : R[X]} {x : R}
    (hpq : (p /ₘ (X - C x) ^ p.rootMultiplicity x).eval x *
      (q /ₘ (X - C x) ^ q.rootMultiplicity x).eval x ≠ 0) :
    rootMultiplicity x (p * q) = rootMultiplicity x p + rootMultiplicity x q
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_eq_preimage_infEdist (δ : ℝ) (E : Set α) :
    cthickening δ E = (fun x => infEdist x E) ⁻¹' Iic (ENNReal.ofReal δ)
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
lemma l2_opNNNorm_def (A : Matrix m n 𝕜) :
    ‖A‖₊ = ‖(toEuclideanLin (𝕜 := 𝕜) (m := m) (n := n)).trans toContinuousLinearMap A‖₊
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
theorem Gamma_one_top : Gamma 1 = ⊤
-- Mathlib/Topology/LocallyClosed.lean
lemma IsLocallyClosed.image {s : Set X} (hs : IsLocallyClosed s)
    {f : X → Y} (hf : Inducing f) (hf' : IsLocallyClosed (range f)) :
    IsLocallyClosed (f '' s)
-- Mathlib/Logic/Function/Basic.lean
protected theorem Surjective.exists (hf : Surjective f) {p : β → Prop} :
    (∃ y, p y) ↔ ∃ x, p (f x)
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem isBounded_Ioo (a b : α) : IsBounded (Ioo a b)
-- Mathlib/Probability/Kernel/Basic.lean
lemma apply_congr_of_mem_measurableAtom (κ : Kernel α β) {y' y : α} (hy' : y' ∈ measurableAtom y) :
  κ y' = κ y
-- Mathlib/Probability/Moments.lean
theorem mgf_pos [IsProbabilityMeasure μ] (h_int_X : Integrable (fun ω => exp (t * X ω)) μ) :
    0 < mgf X μ t
-- Mathlib/Algebra/BigOperators/Associated.lean
theorem prod_ne_zero_of_prime [CancelCommMonoidWithZero α] [Nontrivial α] (s : Multiset α)
    (h : ∀ x ∈ s, Prime x) : s.prod ≠ 0
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
/-- The unit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A
-- Mathlib/RingTheory/GradedAlgebra/Radical.lean
theorem Ideal.IsHomogeneous.radical_eq {I : Ideal A} (hI : I.IsHomogeneous 𝒜) :
    I.radical = InfSet.sInf { J | Ideal.IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime }
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι) :
    ⇑(OrthonormalBasis.ofRepr e) = fun i => e.symm (EuclideanSpace.single i (1 : 𝕜))
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem norm_coe_unitary [Nontrivial E] (U : unitary E) : ‖(U : E)‖ = 1
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_simple_le_iff {K : IntermediateField F E} : F⟮α⟯ ≤ K ↔ α ∈ K
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
@[continuity]
theorem continuous_arsinh : Continuous arsinh
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem self_lt_sinh_iff : x < sinh x ↔ 0 < x
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem compositionAsSet_card (n : ℕ) : Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)
-- Mathlib/LinearAlgebra/Determinant.lean
theorem Basis.det_reindex' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (b : Basis ι R M)
    (e : ι ≃ ι') : (b.reindex e).det = b.det.domDomCongr e
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.le_antisymm_iff {x y : UInt8} : x = y ↔ x ≤ y ∧ y ≤ x
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
/-- The map `Cocycle K L n → Cocycle (K⟦a⟧) (L⟦a⟧) n`. -/
@[simps!]
def shift (γ : Cocycle K L n) (a : ℤ) :
    Cocycle (K⟦a⟧) (L⟦a⟧) n
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
theorem conjugateEquiv_comm {α : L₂ ⟶ L₁} {β : L₁ ⟶ L₂} (βα : β ≫ α = 𝟙 _) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₁ β = 𝟙 _
-- Mathlib/CategoryTheory/Shift/Basic.lean
@[simp]
theorem shiftComm_symm (i j : A) : (shiftComm X i j).symm = shiftComm X j i
-- Mathlib/Algebra/Order/AbsoluteValue.lean
/-- Bound `abv (a - b)` from above -/
lemma sub_le_add (a b : R) : abv (a - b) ≤ abv a + abv b
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive (attr := simp)]
theorem one_right (a : M) : Commute a 1
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- We say that a type has `MeasurableAdd` if `(· + c)` and `(· + c)` are measurable functions.
For a typeclass assuming measurability of `uncurry (· + ·)` see `MeasurableAdd₂`. -/
class MeasurableAdd (M : Type*) [MeasurableSpace M] [Add M] : Prop where
  measurable_const_add : ∀ c : M, Measurable (c + ·)
  measurable_add_const : ∀ c : M, Measurable (· + c)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem extend_comp_eq [MeasurableSpace β] (f₁ : α →ₛ γ) {g : α → β} (hg : MeasurableEmbedding g)
    (f₂ : β →ₛ γ) : (f₁.extend g hg f₂).comp g hg.measurable = f₁
-- Mathlib/Logic/Nontrivial/Basic.lean
/-- Pushforward a `Nontrivial` instance along an injective function. -/
protected theorem Function.Injective.nontrivial [Nontrivial α] {f : α → β}
    (hf : Function.Injective f) : Nontrivial β
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
@[simp]
theorem map_single (f : M →ₗ[R] M') (i : ℕ) (m : M) : map R' f (single R i m) = single R' i (f m)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem deriv_const_add (c : F) : deriv (fun y => c + f y) x = deriv f x
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_sub_eq_right_of_natDegree_lt (h : natDegree p < natDegree q) :
    natDegree (p - q) = natDegree q
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive]
theorem _root_.SubmonoidClass.finsupp_prod_mem {S : Type*} [SetLike S N] [SubmonoidClass S N]
    (s : S) (f : α →₀ M) (g : α → M → N) (h : ∀ c, f c ≠ 0 → g c (f c) ∈ s) : f.prod g ∈ s
-- Mathlib/Data/Nat/Cast/Order/Ring.lean
/-- Specialisation of `Nat.ofNat_nonneg'`, which seems to be easier for Lean to use. -/
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_nonneg {α} [OrderedSemiring α] (n : ℕ) [n.AtLeastTwo] :
    0 ≤ (no_index (OfNat.ofNat n : α))
-- Mathlib/Algebra/Homology/ComplexShape.lean
/-- The reverse of a `ComplexShape`.
-/
@[simps]
def symm (c : ComplexShape ι) : ComplexShape ι
-- Mathlib/Order/Heyting/Basic.lean
theorem IsCompl.eq_hnot (h : IsCompl a b) : a = ￢b
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem prod.rightUnitor_hom_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    prod.map f (𝟙 _) ≫ (prod.rightUnitor Y).hom = (prod.rightUnitor X).hom ≫ f
-- Mathlib/Data/Nat/PrimeFin.lean
lemma primeFactors_pow (n : ℕ) (hk : k ≠ 0) : (n ^ k).primeFactors = n.primeFactors
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem disjoint_take_drop : ∀ {l : List α}, l.Nodup → m ≤ n → Disjoint (l.take m) (l.drop n)
-- Mathlib/LinearAlgebra/Trace.lean
@[simp]
lemma trace_lie {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] (f g : Module.End R M) :
    trace R M ⁅f, g⁆ = 0
-- Mathlib/Algebra/Algebra/Operations.lean
theorem span_mul_span : span R S * span R T = span R (S * T)
-- Mathlib/Data/Int/GCD.lean
/-- **Bézout's lemma**: given `x y : ℕ`, `gcd x y = x * a + y * b`, where `a = gcd_a x y` and
`b = gcd_b x y` are computed by the extended Euclidean algorithm.
-/
theorem gcd_eq_gcd_ab : (gcd x y : ℤ) = x * gcdA x y + y * gcdB x y
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem unitization_injective (h1 : (1 : A) ∉ s) : Function.Injective (unitization s)
-- Mathlib/Computability/TuringMachine.lean
theorem Machine.map_respects (g₁ : PointedMap Λ Λ') (g₂ : Λ' → Λ) {S} (ss : Supports M S)
    (f₂₁ : Function.RightInverse f₁ f₂) (g₂₁ : ∀ q ∈ S, g₂ (g₁ q) = q) :
    Respects (step M) (step (M.map f₁ f₂ g₁ g₂)) fun a b ↦ a.q ∈ S ∧ Cfg.map f₁ g₁ a = b
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem isLindelof_iUnion {ι : Sort*} {f : ι → Set X} [Countable ι] (h : ∀ i, IsLindelof (f i)) :
    IsLindelof (⋃ i, f i)
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
private theorem findim (n : ℕ) [Fact (finrank ℝ E = n + 1)] : FiniteDimensional ℝ E
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[simp, reassoc]
lemma map_comp : map (φ ≫ ψ) c₁₂ = map φ c₁₂ ≫ map ψ c₁₂
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem prefix_or_prefix_of_prefix (h₁ : l₁ <+: l₃) (h₂ : l₂ <+: l₃) : l₁ <+: l₂ ∨ l₂ <+: l₁
-- Mathlib/Analysis/Convex/Strict.lean
theorem Set.Subsingleton.strictConvex (hs : s.Subsingleton) : StrictConvex 𝕜 s
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma map_one_one : map F f 1 1 (by simp) = F.map (𝟙 _)
-- Mathlib/RingTheory/WittVector/Defs.lean
theorem nsmul_coeff (m : ℕ) (x : 𝕎 R) (n : ℕ) :
    (m • x).coeff n = peval (wittNSMul p m n) ![x.coeff]
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem map_tail (s : Stream' α) : map f (tail s) = tail (map f s)
-- Mathlib/Data/Rat/Defs.lean
@[simp] lemma inv_mkRat (a : ℤ) (b : ℕ) : (mkRat a b)⁻¹ = b /. a
-- Mathlib/LinearAlgebra/Orientation.lean
@[simp]
theorem Orientation.reindex_apply (e : ι ≃ ι') (v : M [⋀^ι]→ₗ[R] R) (hv : v ≠ 0) :
    Orientation.reindex R M e (rayOfNeZero _ v hv) =
      rayOfNeZero _ (v.domDomCongr e) (mt (v.domDomCongr_eq_zero_iff e).mp hv)
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem isCauSeq_nthHom (r : R) : IsCauSeq (padicNorm p) fun n => nthHom f r n
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem dist_pointReflection_right (p q : P) :
    dist (Equiv.pointReflection p q) q = ‖(2 : 𝕜)‖ * dist p q
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem MulAction.isClosedMap_quotient [CompactSpace α] :
    letI := orbitRel α β
    IsClosedMap (Quotient.mk' : β → Quotient (orbitRel α β))
-- Mathlib/Algebra/Order/Hom/Ring.lean
/-- `OrderRingHom α β` is the type of monotone semiring homomorphisms from `α` to `β`.

When possible, instead of parametrizing results over `(f : OrderRingHom α β)`,
you should parametrize over `(F : Type*) [OrderRingHomClass F α β] (f : F)`.

When you extend this structure, make sure to extend `OrderRingHomClass`. -/
structure OrderRingHom (α β : Type*) [NonAssocSemiring α] [Preorder α] [NonAssocSemiring β]
  [Preorder β] extends α →+* β where
  /-- The proposition that the function preserves the order. -/
  monotone' : Monotone toFun
-- Mathlib/Algebra/Homology/Additive.lean
@[simp]
theorem neg_f_apply (f : C ⟶ D) (i : ι) : (-f).f i = -f.f i
-- Mathlib/Data/Real/EReal.lean
lemma inv_pos_of_pos_ne_top {a : EReal} (h : 0 < a) (h' : a ≠ ⊤) : 0 < a⁻¹
-- Mathlib/NumberTheory/NumberField/Units/Regulator.lean
theorem regulator_eq_det' (e : {w : InfinitePlace K // w ≠ w₀} ≃ Fin (rank K)) :
    regulator K = |(Matrix.of fun i ↦ (logEmbedding K) (fundSystem K (e i))).det|
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma hasCokernel [S.HasLeftHomology] [HasKernel S.g] :
    HasCokernel (kernel.lift S.g S.f S.zero)
-- Mathlib/Data/Sum/Interval.lean
lemma sumLexLift_nonempty :
    (sumLexLift f₁ f₂ g₁ g₂ a b).Nonempty ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ (f₁ a₁ b₁).Nonempty) ∨
        (∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ ((g₁ a₁ b₂).Nonempty ∨ (g₂ a₁ b₂).Nonempty)) ∨
          ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ (f₂ a₂ b₂).Nonempty
-- Mathlib/Topology/Sheaves/Stalks.lean
/-- Let `F` be a sheaf valued in a concrete category, whose forgetful functor reflects isomorphisms,
preserves limits and filtered colimits. Then two sections who agree on every stalk must be equal.
-/
theorem section_ext (F : Sheaf C X) (U : Opens X) (s t : F.1.obj (op U))
    (h : ∀ x : U, F.presheaf.germ x s = F.presheaf.germ x t) : s = t
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem swap_div [Div G] [Div H] (a b : G × H) : (a / b).swap = a.swap / b.swap
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem intCast_im (n : ℤ) : (n : ℤ√d).im = 0
-- Mathlib/SetTheory/Cardinal/Continuum.lean
theorem continuum_pos : 0 < 𝔠
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem mem_support_iff (p : PMF α) (a : α) : a ∈ p.support ↔ p a ≠ 0
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem ofReal_setAverage {f : α → ℝ} (hf : IntegrableOn f s μ) (hf₀ : 0 ≤ᵐ[μ.restrict s] f) :
    ENNReal.ofReal (⨍ x in s, f x ∂μ) = (∫⁻ x in s, ENNReal.ofReal (f x) ∂μ) / μ s
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem sum_apply (f : ι → Measure α) {s : Set α} (hs : MeasurableSet s) :
    sum f s = ∑' i, f i s
-- Mathlib/Order/CompleteLattice.lean
/-- This is a weaker version of `inf_sSup_eq` -/
theorem iSup_inf_le_inf_sSup : ⨆ b ∈ s, a ⊓ b ≤ a ⊓ sSup s
-- Mathlib/Probability/Kernel/CondDistrib.lean
theorem condexp_ae_eq_integral_condDistrib [NormedSpace ℝ F] [CompleteSpace F] (hX : Measurable X)
    (hY : AEMeasurable Y μ) {f : Ω → F} (hf : StronglyMeasurable f)
    (hf_int : Integrable (fun a => f (Y a)) μ) :
    μ[fun a => f (Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f y ∂condDistrib Y X μ (X a)
-- Mathlib/Data/Finset/Pointwise.lean
theorem mul_add_subset : s * (t + u) ⊆ s * t + s * u
-- Mathlib/Control/Traversable/Lemmas.lean
theorem comp_sequence (x : t (F (G α))) :
    sequence (Comp.mk <$> x) = Comp.mk (sequence <$> sequence x)
-- Mathlib/Topology/VectorBundle/Hom.lean
theorem continuousOn_continuousLinearMapCoordChange [VectorBundle 𝕜₁ F₁ E₁] [VectorBundle 𝕜₂ F₂ E₂]
    [MemTrivializationAtlas e₁] [MemTrivializationAtlas e₁'] [MemTrivializationAtlas e₂]
    [MemTrivializationAtlas e₂'] :
    ContinuousOn (continuousLinearMapCoordChange σ e₁ e₁' e₂ e₂')
      (e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet))
-- Mathlib/Order/Closure.lean
@[simp]
theorem closure_iUnion_closure (f : ι → α) : l (⋃ i, l (f i)) = l (⋃ i, f i)
-- Mathlib/Data/Nat/Cast/Order/Field.lean
theorem one_div_le_one_div {n m : ℕ} (h : n ≤ m) : 1 / ((m : α) + 1) ≤ 1 / ((n : α) + 1)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem coprod_inl_inr {M N : Type*} [CommMonoid M] [CommMonoid N] :
    (inl M N).coprod (inr M N) = id (M × N)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_uIcc (ha : a ≠ 0) (b c : α) :
    (a * ·) ⁻¹' [[b, c]] = [[b / a, c / a]]
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoMod_zsmul_add (a b : α) (m : ℤ) : toIcoMod hp a (m • p + b) = toIcoMod hp a b
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If a set of functions is equicontinuous on a set `S`, the same is true for its closure in *any*
topology for which evaluation at any `x ∈ S` is continuous. Since this will be applied to
`DFunLike` types, we state it for any topological space whith a map to `X → α` satisfying the right
continuity conditions. See also `Set.EquicontinuousOn.closure` for a more familiar
(but weaker) statement. -/
theorem EquicontinuousOn.closure' {A : Set Y} {u : Y → X → α} {S : Set X}
    (hA : EquicontinuousOn (u ∘ (↑) : A → X → α) S) (hu : Continuous (S.restrict ∘ u)) :
    EquicontinuousOn (u ∘ (↑) : closure A → X → α) S
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
/-- Iterates of a Lipschitz function are Lipschitz. -/
protected theorem iterate {f : α → α} (hf : LipschitzWith K f) : ∀ n, LipschitzWith (K ^ n) f^[n]
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
@[deprecated quadraticChar_ne_one (since := "2024-06-16")]
theorem quadraticChar_isNontrivial (hF : ringChar F ≠ 2) : (quadraticChar F).IsNontrivial
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem ext_iff {f g : α →ₘ[μ] β} : f = g ↔ f =ᵐ[μ] g
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- If `s` is not in `-ℕ`, then `hurwitzZetaOdd a (1 - s)` is an explicit multiple of
`sinZeta s`. -/
lemma hurwitzZetaOdd_one_sub (a : UnitAddCircle) {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -n) :
    hurwitzZetaOdd a (1 - s) = 2 * (2 * π) ^ (-s) * Gamma s * sin (π * s / 2) * sinZeta a s
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_le_of_mem {a : α} {s t : Set α} (h : s ∈ 𝓝[t] a) : 𝓝[t] a ≤ 𝓝[s] a
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem mk_coe (f : L₁ →ₗ⁅R⁆ L₂) (h₁ h₂ h₃) : (⟨⟨⟨f, h₁⟩, h₂⟩, h₃⟩ : L₁ →ₗ⁅R⁆ L₂) = f
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem sep_inter : { x | (x ∈ s ∧ x ∈ t) ∧ p x } = { x ∈ s | p x } ∩ { x ∈ t | p x }
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_eq_intCast [DecidableEq n] [Ring α] [StarRing α]
    {M : Matrix n n α} {d : ℤ} :
    Mᴴ = d ↔ M = d
-- Mathlib/Analysis/PSeries.lean
@[simp]
theorem summable_rpow {p : ℝ} : Summable (fun n => (n : ℝ≥0) ^ p : ℕ → ℝ≥0) ↔ p < -1
-- Mathlib/NumberTheory/Harmonic/Bounds.lean
theorem log_le_harmonic_floor (y : ℝ) (hy : 0 ≤ y) :
    Real.log y ≤ harmonic ⌊y⌋₊
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] lemma tensorObj_obj (M N : FGModuleCat.{u} R) : (M ⊗ N).obj = (M.obj ⊗ N.obj)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem Differentiable.cpow (hf : Differentiable ℂ f) (hg : Differentiable ℂ g)
    (h0 : ∀ x, f x ∈ slitPlane) : Differentiable ℂ (fun x ↦ f x ^ g x)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be
constructed and destructed like a pair: if `ha : a` and `hb : b` then
`⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`.
-/
@[pp_using_anonymous_constructor]
structure And (a b : Prop) : Prop where
  /-- `And.intro : a → b → a ∧ b` is the constructor for the And operation. -/
  intro ::
  /-- Extract the left conjunct from a conjunction. `h : a ∧ b` then
  `h.left`, also notated as `h.1`, is a proof of `a`. -/
  left : a
  /-- Extract the right conjunct from a conjunction. `h : a ∧ b` then
  `h.right`, also notated as `h.2`, is a proof of `b`. -/
  right : b
-- Mathlib/Algebra/RingQuot.lean
@[simp]
theorem liftAlgHom_mkAlgHom_apply (f : A →ₐ[S] B) {s : A → A → Prop}
    (w : ∀ ⦃x y⦄, s x y → f x = f y) (x) : (liftAlgHom S ⟨f, w⟩) ((mkAlgHom S s) x) = f x
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation maps balls to balls and scales the radius by `ratio f`. -/
theorem mapsTo_emetric_ball (x : α) (r : ℝ≥0∞) :
    MapsTo (f : α → β) (EMetric.ball x r) (EMetric.ball (f x) (ratio f * r))
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
/-- Construct an isomorphism in `SingleFunctors C D A` by giving
level-wise isomorphisms and checking compatibility only in the forward direction. -/
@[simps]
def isoMk (iso : ∀ a, (F.functor a ≅ G.functor a))
    (comm : ∀ (n a a' : A) (ha' : n + a = a'), (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom) :
    F ≅ G