ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
/-- The sheaf condition
in terms of a limit diagram over all `{ V : Opens X // ∃ i, V ≤ U i }`
is equivalent to the reformulation
in terms of a limit diagram over `U i` and `U i ⊓ U j`.
-/
theorem isSheafOpensLeCover_iff_isSheafPairwiseIntersections :
    F.IsSheafOpensLeCover ↔ F.IsSheafPairwiseIntersections
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem surjective_frobenius : Surjective (frobenius R p)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_wcovBy_toIcoDiv (a b : α) : toIocDiv hp a b ⩿ toIcoDiv hp a b
-- Mathlib/AlgebraicGeometry/Spec.lean
/--
This is the `AlgHom` version of `toPushforwardStalk`, which is the map `S ⟶ (f∗ 𝒪ₛ)ₚ` for some
algebra `R ⟶ S` and some `p : Spec R`.
-/
@[simps!]
def toPushforwardStalkAlgHom :
    S →ₐ[R] (Spec.topMap (algebraMap R S) _* (structureSheaf S).1).stalk p
-- Mathlib/Data/Finset/Basic.lean
@[mono, gcongr]
theorem inter_subset_inter {x y s t : Finset α} (h : x ⊆ y) (h' : s ⊆ t) : x ∩ s ⊆ y ∩ t
-- Mathlib/Data/Num/Lemmas.lean
theorem to_of_nat : ∀ n : ℕ, ((n : Num) : ℕ) = n
-- Mathlib/Logic/Relation.lean
theorem Transitive.comap (h : Transitive r) (f : α → β) : Transitive (r on f)
-- Mathlib/RingTheory/Localization/Algebra.lean
@[simp]
lemma AlgHom.toKerIsLocalization_apply (f : A →ₐ[R] B) (x : RingHom.ker f) :
    AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f x =
      RingHom.toKerIsLocalization Aₚ Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f) x
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Binary biproducts are unique up to isomorphism. This already follows because bilimits are
    limits, but in the case of biproducts we can give an isomorphism with particularly nice
    definitional properties, namely that `biprod.lift b.fst b.snd` and `biprod.desc b.inl b.inr`
    are inverses of each other. -/
@[simps]
def biprod.uniqueUpToIso (X Y : C) [HasBinaryBiproduct X Y] {b : BinaryBicone X Y}
    (hb : b.IsBilimit) : b.pt ≅ X ⊞ Y
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem iSup_zero_eq_zero {ι : Sort*} : ⨆ _ : ι, (0 : ℝ≥0∞) = 0
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem map_top_of_surjective (f : G →* N) (h : Function.Surjective f) : Subgroup.map f ⊤ = ⊤
-- Mathlib/NumberTheory/NumberField/Discriminant.lean
theorem finite_of_finite_generating_set {p : IntermediateField ℚ A → Prop}
    (S : Set {F : IntermediateField ℚ A // p F}) {T : Set A}
    (hT : T.Finite) (h : ∀ F ∈ S, ∃ x ∈ T, F = ℚ⟮x⟯) :
    S.Finite
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem filter_eq (l : List α) (a : α) : l.filter (· = a) = replicate (count a l) a
-- Mathlib/FieldTheory/Finite/Basic.lean
theorem pow_card_pow (n : ℕ) (a : K) : a ^ q ^ n = a
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem setLaverage_eq (f : α → ℝ≥0∞) (s : Set α) :
    ⨍⁻ x in s, f x ∂μ = (∫⁻ x in s, f x ∂μ) / μ s
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma shiftIso_hom_app (n a a' : ℤ) (ha' : n + a = a') (K : CochainComplex C ℤ) :
    (shiftIso C n a a' ha').hom.app K =
      ShortComplex.homologyMap ((shiftShortComplexFunctorIso C n a a' ha').hom.app K)
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
/-- The restriction of a Scheme along an open embedding. -/
@[simps! (config := .lemmasOnly) carrier, simps! presheaf_obj]
def Scheme.restrict : Scheme
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem codisjoint_self : Codisjoint a a ↔ a = ⊤
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- Note that this is not quite as useful as it looks because the measure takes values in `ℝ≥0∞`.
Thus the subtraction appearing is the truncated subtraction of `ℝ≥0∞`, rather than the
better-behaved subtraction of `ℝ`. -/
lemma prob_compl_eq_one_sub₀ (h : NullMeasurableSet s μ) : μ sᶜ = 1 - μ s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sub_lt (hd : degree p = degree q) (hp0 : p ≠ 0)
    (hlc : leadingCoeff p = leadingCoeff q) : degree (p - q) < degree p
-- Mathlib/Order/Interval/Set/Pi.lean
@[simp]
theorem pi_univ_Ici : (pi univ fun i ↦ Ici (x i)) = Ici x
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive (attr := mono)]
theorem tprod_mono (hf : Multipliable f) (hg : Multipliable g) (h : f ≤ g) :
    ∏' n, f n ≤ ∏' n, g n
-- Mathlib/Order/Monotone/Basic.lean
protected theorem strictAnti [Subsingleton α] (f : α → β) : StrictAnti f
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem truncate_or {x y : BitVec w} :
    (x ||| y).truncate k = x.truncate k ||| y.truncate k
-- Mathlib/Algebra/Order/AddTorsor.lean
/-- An ordered cancellative scalar multiplication is an ordered scalar multiplication that is
  cancellative. -/
@[to_additive]
class IsOrderedCancelSMul (G P : Type*) [LE G] [LE P] [SMul G P] extends
    IsOrderedSMul G P : Prop where
  protected le_of_smul_le_smul_left : ∀ (a : G) (b c : P), a • b ≤ a • c → b ≤ c
  protected le_of_smul_le_smul_right : ∀ (a b : G) (c : P), a • c ≤ b • c → a ≤ b
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_eq_right_iff [NormalizedGCDMonoid α] (a b : α) (h : normalize b = b) :
    gcd a b = b ↔ b ∣ a
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
protected theorem monotone {p q : ℝ≥0∞} (hpq : q ≤ p) : lp E q ≤ lp E p
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_mul_iff_mul_left_eq {o : Ordinal} :
    Principal (· * ·) o ↔ ∀ a, 0 < a → a < o → a * o = o
-- Mathlib/GroupTheory/GroupAction/Hom.lean
/-- `MulActionSemiHomClass F φ X Y` states that
  `F` is a type of morphisms which are `φ`-equivariant.

You should extend this class when you extend `MulActionHom`. -/
class MulActionSemiHomClass (F : Type*)
    {M N : outParam Type*} (φ : outParam (M → N))
    (X Y : outParam Type*) [SMul M X] [SMul N Y] [FunLike F X Y] : Prop where
  /-- The proposition that the function preserves the action. -/
  map_smulₛₗ : ∀ (f : F) (c : M) (x : X), f (c • x) = (φ c) • (f x)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[to_additive Iic_add_Iic_subset]
theorem Iic_mul_Iic_subset' (a b : α) : Iic a * Iic b ⊆ Iic (a * b)
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp, norm_cast]
theorem coe_Ioc (a b : α) : (Ioc a b : Set α) = Set.Ioc a b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_sum {ι : Type*} (f : ι → R → R) (a : A) (s : Finset ι)
    (hf : ∀ i ∈ s, ContinuousOn (f i) (spectrum R a) := by cfc_cont_tac) :
    cfc (∑ i in s, f i)  a = ∑ i in s, cfc (f i) a
-- Mathlib/Order/SuccPred/Limit.lean
theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp)]
theorem orderOf_inv (x : G) : orderOf x⁻¹ = orderOf x
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem ContMDiffWithinAt.div_const (hf : ContMDiffWithinAt I' I n f s x) :
    ContMDiffWithinAt I' I n (fun x ↦ f x / c) s x
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem map_inf_comap_of_surjective (p q : Submodule R₂ M₂) :
    (p.comap f ⊓ q.comap f).map f = p ⊓ q
-- Mathlib/Analysis/Convex/Side.lean
theorem wSameSide_iff_exists_right {s : AffineSubspace R P} {x y p₂ : P} (h : p₂ ∈ s) :
    s.WSameSide x y ↔ y ∈ s ∨ ∃ p₁ ∈ s, SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
-- Mathlib/Data/Set/Card.lean
theorem ncard_eq_toFinset_card (s : Set α) (hs : s.Finite := by toFinite_tac) :
    s.ncard = hs.toFinset.card
-- Mathlib/Data/Set/Prod.lean
theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem le_mkMetric (m : ℝ≥0∞ → ℝ≥0∞) (μ : Measure X) (ε : ℝ≥0∞) (h₀ : 0 < ε)
    (h : ∀ s : Set X, diam s ≤ ε → μ s ≤ m (diam s)) : μ ≤ mkMetric m
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem pow_left (H : IsRelPrime x y) : IsRelPrime (x ^ m) y
-- Mathlib/LinearAlgebra/DFinsupp.lean
@[simp, nolint simpNF]
theorem lmk_apply (s : Finset ι) (x) : (lmk s : _ →ₗ[R] Π₀ i, M i) x = mk s x
-- Mathlib/Probability/Variance.lean
theorem _root_.MeasureTheory.Memℒp.variance_eq_of_integral_eq_zero (hX : Memℒp X 2 μ)
    (hXint : μ[X] = 0) : variance X μ = μ[X ^ (2 : Nat)]
-- Mathlib/Topology/Instances/Matrix.lean
/-- When `Ring.inverse` is continuous at the determinant (such as in a `NormedRing`, or a
topological field), so is `Matrix.inv`. -/
theorem continuousAt_matrix_inv [Fintype n] [DecidableEq n] [CommRing R] [TopologicalRing R]
    (A : Matrix n n R) (h : ContinuousAt Ring.inverse A.det) : ContinuousAt Inv.inv A
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[csimp] theorem takeList_eq_takeListTR : @takeList = @takeListTR
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
/-- An isomorphism of `PresheafedSpace`s is a homeomorphism of the underlying space, and a
natural transformation between the sheaves.
-/
@[simps hom inv]
def isoOfComponents (H : X.1 ≅ Y.1) (α : H.hom _* X.2 ≅ Y.2) : X ≅ Y
-- Mathlib/Logic/Function/Iterate.lean
theorem iterate_self (n : ℕ) : Commute f^[n] f
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp) ite_smul]
lemma pow_ite (p : Prop) [Decidable p] (a : α) (b c : β) :
    a ^ (if p then b else c) = if p then a ^ b else a ^ c
-- Mathlib/Data/Real/Basic.lean
theorem ofCauchy_sub (a b) : (⟨a - b⟩ : ℝ) = ⟨a⟩ - ⟨b⟩
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
theorem rotation_apply (θ : Real.Angle) (x : V) :
    o.rotation θ x = Real.Angle.cos θ • x + Real.Angle.sin θ • J x
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
theorem eq_of_empty [IsEmpty α] (f g : C_c(α, β)) : f = g
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
lemma nil_iff_length_eq {p : G.Walk v w} : p.Nil ↔ p.length = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem irreducible_iff_prime_of_exists_prime_factors {p : α} : Irreducible p ↔ Prime p
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_add [DecidableEq α] {g₁ g₂ : α →₀ M} :
    (g₁ + g₂).support ⊆ g₁.support ∪ g₂.support
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem uniformContinuous_inv : UniformContinuous fun x : α => x⁻¹
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem C_dvd_iff_map_hom_eq_zero (q : R →+* S₁) (r : R) (hr : ∀ r' : R, q r' = 0 ↔ r ∣ r')
    (φ : MvPolynomial σ R) : C r ∣ φ ↔ map q φ = 0
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
/-- If all `f i`, `i ∈ s`, are nonnegative and each `f i` is less than or equal to `g i`, then the
product of `f i` is less than or equal to the product of `g i`.

This is a variant (beta-reduced) version of the standard lemma `Finset.prod_le_prod`, convenient
for the `gcongr` tactic. -/
@[gcongr]
lemma _root_.GCongr.prod_le_prod (h0 : ∀ i ∈ s, 0 ≤ f i) (h1 : ∀ i ∈ s, f i ≤ g i) :
    s.prod f ≤ s.prod g
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
@[reassoc (attr := simp)]
theorem whiskerLeft_naturality (f : a' ⟶ F.obj b) (g : b ⟶ c) :
    f ◁ F.map g ◁ Γ.app c ≫ f ◁ θ.naturality g = f ◁ η.naturality g ≫ f ◁ Γ.app b ▷ G.map g
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of the constant sequence `1` equals the Riemann Zeta Function on its
domain of convergence `1 < re s`. -/
lemma LSeries_one_eq_riemannZeta {s : ℂ} (hs : 1 < s.re) : L 1 s = riemannZeta s
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem preimage_symm (h : α ≃ᵢ β) : preimage h.symm = image h
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem concat_eq_append (as : List α) (a : α) : as.concat a = as ++ [a]
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_cases (f : ℝ → E) (a b) :
    (∫ x in a..b, f x ∂μ) ∈ ({∫ x in Ι a b, f x ∂μ, -∫ x in Ι a b, f x ∂μ} : Set E)
-- Mathlib/Data/Multiset/Basic.lean
theorem strongDownwardInduction_eq {p : Multiset α → Sort*} {n : ℕ}
    (H : ∀ t₁, (∀ {t₂ : Multiset α}, card t₂ ≤ n → t₁ < t₂ → p t₂) → card t₁ ≤ n → p t₁)
    (s : Multiset α) :
    strongDownwardInduction H s = H s fun ht _hst => strongDownwardInduction H _ ht
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem top_subgroupOf : (⊤ : Subgroup G).subgroupOf H = ⊤
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem WithLp.equiv_single (i : ι) (a : 𝕜) :
    WithLp.equiv _ _ (EuclideanSpace.single i a) = Pi.single i a
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
@[simp] lemma shatters_empty : 𝒜.Shatters ∅ ↔ 𝒜.Nonempty
-- Mathlib/FieldTheory/SplittingField/Construction.lean
protected theorem splits : Splits (algebraMap K (SplittingField f)) f
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
/-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem vecMul_injective_of_invertible (A : Matrix m m K) [Invertible A] :
    Function.Injective A.vecMul
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem inclusion_lt_inclusion [Preorder α] {s t : Set α} (h : s ⊆ t) {x y : s} :
    inclusion h x < inclusion h y ↔ x < y
-- Mathlib/RingTheory/Multiplicity.lean
theorem pow {p a : α} (hp : Prime p) : ∀ {k : ℕ}, multiplicity p (a ^ k) = k • multiplicity p a
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_mul_le {p q : R[X]} : natDegree (p * q) ≤ natDegree p + natDegree q
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem norm_setToSimpleFunc_le_sum_mul_norm_of_integrable (T : Set α → E →L[ℝ] F') {C : ℝ}
    (hT_norm : ∀ s, MeasurableSet s → μ s < ∞ → ‖T s‖ ≤ C * (μ s).toReal) (f : α →ₛ E)
    (hf : Integrable f μ) :
    ‖f.setToSimpleFunc T‖ ≤ C * ∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal * ‖x‖
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem algebraMap_apply' (p : MvPolynomial σ R) :
    algebraMap (MvPolynomial σ R) (MvPowerSeries σ A) p = map σ (algebraMap R A) p
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
/-- Representable presheaves are (trivially) ind-objects. -/
@[simps]
def yoneda (X : C) : IndObjectPresentation (yoneda.obj X)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma baseChange_polynomialY : (W.baseChange B).toAffine.polynomialY =
    (W.baseChange A).toAffine.polynomialY.map (mapRingHom f)
-- Mathlib/Data/Finsupp/Basic.lean
theorem subtypeDomain_eq_zero_iff' {f : α →₀ M} : f.subtypeDomain p = 0 ↔ ∀ x, p x → f x = 0
-- Mathlib/Data/Matrix/DMatrix.lean
theorem ext_iff : (∀ i j, M i j = N i j) ↔ M = N
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem integral_log_of_pos (ha : 0 < a) (hb : 0 < b) :
    ∫ x in a..b, log x = b * log b - a * log a - b + a
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lt_one_iff_zero {c : Cardinal} : c < 1 ↔ c = 0
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem IsNClique.insert (hs : G.IsNClique n s) (h : ∀ b ∈ s, G.Adj a b) :
    G.IsNClique (n + 1) (insert a s)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem card_pos_of_affineSpan_eq_top {ι : Type*} [Fintype ι] {p : ι → P}
    (h : affineSpan k (range p) = ⊤) : 0 < Fintype.card ι
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem add_coe_eq_bot_iff : a + y = ⊥ ↔ a = ⊥
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem basicOpen_one : basicOpen (1 : R) = ⊤
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive, field_simps] -- The attributes are out of order on purpose
theorem inv_eq_one_div (x : G) : x⁻¹ = 1 / x
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/--
The double sum of weighted inner products of pairs of vectors from an orthonormal sequence is the
sum of the weights.
-/
theorem Orthonormal.inner_left_right_finset {s : Finset ι} {v : ι → E} (hv : Orthonormal 𝕜 v)
    {a : ι → ι → 𝕜} : (∑ i ∈ s, ∑ j ∈ s, a i j • ⟪v j, v i⟫) = ∑ k ∈ s, a k k
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem sub_add_eq (a b c : Nat) : a - (b + c) = a - b - c
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem some_eq_coe' (a : ℝ≥0) : (WithTop.some a : ℝ≥0∞) = (↑a : ℝ≥0∞)
-- Mathlib/Data/Nat/Squarefree.lean
theorem minSqFacAux_has_prop {n : ℕ} (k) (n0 : 0 < n) (i) (e : k = 2 * i + 3)
    (ih : ∀ m, Prime m → m ∣ n → k ≤ m) : MinSqFacProp n (minSqFacAux n k)
-- Mathlib/Data/Seq/WSeq.lean
theorem dropn_congr {s t : WSeq α} (h : s ~ʷ t) (n) : drop s n ~ʷ drop t n
-- Mathlib/LinearAlgebra/InvariantBasisNumber.lean
/-- We say that `R` satisfies the strong rank condition if `(Fin n → R) →ₗ[R] (Fin m → R)` injective
    implies `n ≤ m`. -/
@[mk_iff]
class StrongRankCondition : Prop where
  /-- Any injective linear map from `Rⁿ` to `Rᵐ` guarantees `n ≤ m`. -/
  le_of_fin_injective : ∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Injective f → n ≤ m
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
-- Mathlib/Order/Interval/Finset/Basic.lean
/-- `Finset.cons` version of `Finset.Iio_insert`. -/
theorem Iic_eq_cons_Iio (b : α) : Iic b = (Iio b).cons b not_mem_Iio_self
-- Mathlib/Data/PNat/Xgcd.lean
@[simp]
theorem flip_z : (flip u).z = u.w
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
theorem preservesEpimorphisms_of_preserves_of_reflects (F : C ⥤ D) (G : D ⥤ E)
    [PreservesEpimorphisms (F ⋙ G)] [ReflectsEpimorphisms G] : PreservesEpimorphisms F
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem coeToSubmodule_ne_bot {I : FractionalIdeal S P} : ↑I ≠ (⊥ : Submodule R P) ↔ I ≠ 0
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem darts_map : (p.map f).darts = p.darts.map f.mapDart
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp, fun_prop]
theorem Differentiable.sum (h : ∀ i ∈ u, Differentiable 𝕜 (A i)) :
    Differentiable 𝕜 fun y => ∑ i ∈ u, A i y
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem symm_trans_self (e : P₁ ≃ᵃL[k] P₂) : e.symm.trans e = refl k P₂
-- Mathlib/ModelTheory/Substructures.lean
theorem comap_comap (S : L.Substructure P) (g : N →[L] P) (f : M →[L] N) :
    (S.comap g).comap f = S.comap (g.comp f)
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousOn_biInf {p : ι → Prop} {f : ∀ i, p i → α → δ}
    (h : ∀ i hi, UpperSemicontinuousOn (f i hi) s) :
    UpperSemicontinuousOn (fun x' => ⨅ (i) (hi), f i hi x') s
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
@[simp]
theorem one_apply (n : ℕ) : (1 : AdicCauchySequence I R) n = 1
-- Mathlib/Data/List/Basic.lean
theorem cons_subset_of_subset_of_mem {a : α} {l m : List α}
    (ainm : a ∈ m) (lsubm : l ⊆ m) : a::l ⊆ m
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
@[simp]
theorem isVonNBounded_insert (x : E) {s : Set E} :
    IsVonNBounded 𝕜 (insert x s) ↔ IsVonNBounded 𝕜 s
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- If a function and its derivative are integrable on the real line, then the integral of the
derivative is zero. -/
theorem integral_eq_zero_of_hasDerivAt_of_integrable
    (hderiv : ∀ x, HasDerivAt f (f' x) x) (hf' : Integrable f') (hf : Integrable f) :
    ∫ x, f' x = 0
-- Mathlib/Analysis/Convex/AmpleSet.lean
/-- Affine translations of ample sets are ample. -/
theorem vadd [ContinuousAdd E] {s : Set E} (h : AmpleSet s) {y : E} :
    AmpleSet (y +ᵥ s)
-- Mathlib/Computability/Primrec.lean
theorem vector_ofFn' {n} : Primrec (@Vector.ofFn α n)
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem AddValuation.map_mul (x y : ℚ_[p]) :
    addValuationDef (x * y : ℚ_[p]) = addValuationDef x + addValuationDef y
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- A linear map is an isometry if and it preserves the inner product. -/
theorem LinearMap.norm_map_iff_inner_map_map {F : Type*} [FunLike F E E'] [LinearMapClass F 𝕜 E E']
    (f : F) : (∀ x, ‖f x‖ = ‖x‖) ↔ (∀ x y, ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes left covariance.
The lemma assuming right covariance is `Right.one_le_mul`. -/
@[to_additive Left.add_nonneg "Assumes left covariance.
The lemma assuming right covariance is `Right.add_nonneg`."]
theorem Left.one_le_mul [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (ha : 1 ≤ a) (hb : 1 ≤ b) :
    1 ≤ a * b
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive (attr := simp)] lemma mabs_mabs (a : α) : |(|a|ₘ)|ₘ = |a|ₘ
-- Mathlib/Data/Matrix/Composition.lean
/-- `Matrix.comp` as `AddEquiv` -/
@[simps!]
def compAddEquiv : Matrix I J (Matrix K L R) ≃+ Matrix (I × K) (J × L) R
-- Mathlib/Tactic/CC/Lemmas.lean
theorem eq_false_of_or_eq_false_left {a b : Prop} (h : (a ∨ b) = False) : a = False
-- Mathlib/Data/ZMod/Units.lean
/-- Any element of `ZMod N` has the form `u * d` where `u` is a unit and `d` is a divisor of `N`. -/
lemma eq_unit_mul_divisor {N : ℕ} (a : ZMod N) :
    ∃ d : ℕ, d ∣ N ∧ ∃ (u : ZMod N), IsUnit u ∧ a = u * d
-- Mathlib/Order/Hom/Basic.lean
protected theorem isWellOrder [IsWellOrder β (· < ·)] (f : α ↪o β) : IsWellOrder α (· < ·)
-- Mathlib/SetTheory/Cardinal/PartENat.lean
@[simp]
theorem partENatOfENat_toENat (c : Cardinal) : (toENat c : PartENat) = toPartENat c
-- Mathlib/Algebra/CharP/ExpChar.lean
/-- The exponential characteristic is one iff the characteristic is zero. -/
theorem expChar_one_iff_char_zero (p q : ℕ) [CharP R p] [ExpChar R q] : q = 1 ↔ p = 0
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- The topology of the Lévy-Prokhorov metric is at least as fine as the topology of convergence in
distribution. -/
theorem levyProkhorov_le_convergenceInDistribution :
    TopologicalSpace.coinduced (LevyProkhorov.toProbabilityMeasure (Ω := Ω)) inferInstance
      ≤ (inferInstance : TopologicalSpace (ProbabilityMeasure Ω))
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem total_apply_of_mem_supported {l : α →₀ R} {s : Finset α}
    (hs : l ∈ supported R R (↑s : Set α)) : Finsupp.total α M R v l = s.sum fun i => l i • v i
-- Mathlib/Data/Set/Prod.lean
theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t
-- Mathlib/MeasureTheory/Integral/Marginal.lean
theorem lmarginal_union (f : (∀ i, π i) → ℝ≥0∞) (hf : Measurable f)
    (hst : Disjoint s t) : ∫⋯∫⁻_s ∪ t, f ∂μ = ∫⋯∫⁻_s, ∫⋯∫⁻_t, f ∂μ ∂μ
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_self (V : Submodule R M) : V.restrictScalars R = V
-- Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean
theorem aeSeq_eq_fun_of_mem_aeSeqSet (hf : ∀ i, AEMeasurable (f i) μ) {x : α}
    (hx : x ∈ aeSeqSet hf p) (i : ι) : aeSeq hf p i x = f i x
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem reindex_apply (i' : ι') : b.reindex e i' = b (e.symm i')
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem comp₂Measurable_eq_mk (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) :
    comp₂Measurable g hg f₁ f₂ =
      mk (fun a => g (f₁ a) (f₂ a))
        (hg.comp_aemeasurable (f₁.aemeasurable.prod_mk f₂.aemeasurable)).aestronglyMeasurable
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem isEmpty_psum {α β} : IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma coe_eq_ofNat (n : ℕ) [n.AtLeastTwo] (m : α) :
    (m : WithBot α) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n
-- Mathlib/Probability/Martingale/Basic.lean
theorem submartingale_of_condexp_sub_nonneg [IsFiniteMeasure μ] {f : ι → Ω → ℝ} (hadp : Adapted ℱ f)
    (hint : ∀ i, Integrable (f i) μ) (hf : ∀ i j, i ≤ j → 0 ≤ᵐ[μ] μ[f j - f i|ℱ i]) :
    Submartingale f ℱ μ
-- Mathlib/Data/Real/Sqrt.lean
theorem Filter.Tendsto.sqrt {f : α → ℝ} {l : Filter α} {x : ℝ} (h : Tendsto f l (𝓝 x)) :
    Tendsto (fun x => √(f x)) l (𝓝 (√x))
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem eq_bot_or_nonempty (Q : AffineSubspace k P) : Q = ⊥ ∨ (Q : Set P).Nonempty
-- Mathlib/Data/Multiset/Basic.lean
/-- This is a special case of `tsub_zero`, which should be used instead of this.
  This is needed to prove `OrderedSub (Multiset α)`. -/
protected theorem sub_zero (s : Multiset α) : s - 0 = s
-- Mathlib/Data/Finset/Image.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma image_nonempty : (s.image f).Nonempty ↔ s.Nonempty
-- Mathlib/Algebra/Ring/Action/Field.lean
/-- Note that `smul_inv'` refers to the group case, and `smul_inv` has an additional inverse
on `x`. -/
@[simp]
theorem smul_inv'' [MulSemiringAction M F] (x : M) (m : F) : x • m⁻¹ = (x • m)⁻¹
-- Mathlib/Data/Nat/Choose/Sum.lean
/-- **Zhu Shijie's identity** aka hockey-stick identity. -/
theorem sum_Icc_choose (n k : ℕ) : ∑ m ∈ Icc k n, m.choose k = (n + 1).choose (k + 1)