ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Connected/LocallyConnected.lean
theorem locallyConnectedSpace_iff_open_connected_basis :
    LocallyConnectedSpace α ↔
      ∀ x, (𝓝 x).HasBasis (fun s : Set α => IsOpen s ∧ x ∈ s ∧ IsConnected s) id
-- Mathlib/Topology/Constructions.lean
theorem closure_prod_eq {s : Set X} {t : Set Y} : closure (s ×ˢ t) = closure s ×ˢ closure t
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·)
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem Limit.lift_π_apply (s : Cone F) (j : J) (x : s.pt) :
    limit.π F j (limit.lift F s x) = s.π.app j x
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem tail_cons : tail (cons x p) = p
-- Mathlib/NumberTheory/Dioph.lean
theorem dioph_comp {S : Set (Vector3 ℕ n)} (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) n)
    (df : VectorAllP DiophFn f) : Dioph {v | (fun i => f i v) ∈ S}
-- Mathlib/Topology/Gluing.lean
theorem ι_openEmbedding (i : D.J) : OpenEmbedding (𝖣.ι i)
-- Mathlib/Order/SemiconjSup.lean
theorem right_mono [Preorder α] [Preorder β] {f : α → β} {g : β → α} (h : IsOrderRightAdjoint f g) :
    Monotone g
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem equiv_iff_mem {x y : PSet.{u}} : Equiv x y ↔ ∀ {w : PSet.{u}}, w ∈ x ↔ w ∈ y
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.Bornology.IsBounded.subset_ball (h : IsBounded s) (c : α) : ∃ r, s ⊆ ball c r
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem Colorable.mono {n m : ℕ} (h : n ≤ m) (hc : G.Colorable n) : G.Colorable m
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map_bijective_iff {f : α → β} : Bijective (map f) ↔ Bijective f
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorAdd_add_zero_hom_app (a : A) (X : C) : (shiftFunctorAdd C a 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ (shiftFunctorZero C A).inv.app (X⟦a⟧)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma oddKernel_def' (a x : ℝ) : ↑(oddKernel ↑a x) = cexp (-π * a ^ 2 * x) *
    (jacobiTheta₂' (a * I * x) (I * x) / (2 * π * I) + a * jacobiTheta₂ (a * I * x) (I * x))
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma powerset_infs_powerset_self (s : Finset α) :
    s.powerset ⊼ s.powerset = s.powerset
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem lift_mk'_spec (x v) (y : S) : f.lift hg (f.mk' x y) = v ↔ g x = g y * v
-- Mathlib/CategoryTheory/Abelian/Basic.lean
theorem imageIsoImage_inv :
    (imageIsoImage f).inv =
      kernel.lift _ (Limits.image.ι f) (by simp [← cancel_epi (factorThruImage f)])
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- The main result, *Legendre's Theorem* on rational approximation:
if `ξ` is a real number and `q` is a rational number such that `|ξ - q| < 1/(2*q.den^2)`,
then `q` is a convergent of the continued fraction expansion of `ξ`.
This version uses `Real.convergent`. -/
theorem exists_rat_eq_convergent {q : ℚ} (h : |ξ - q| < 1 / (2 * (q.den : ℝ) ^ 2)) :
    ∃ n, q = ξ.convergent n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem map_drop (f : α → β) :
    ∀ (L : List α) (i : Nat), (L.drop i).map f = (L.map f).drop i
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem lift_unique' (F : MonoidAlgebra k G →ₐ[k] A) :
    F = lift k G A ((F : MonoidAlgebra k G →* A).comp (of k G))
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem right_continuous (x : ℝ) : ContinuousWithinAt f (Ici x) x
-- Mathlib/Order/Filter/Basic.lean
theorem map_comap_of_mem {f : Filter β} {m : α → β} (hf : range m ∈ f) : (f.comap m).map m = f
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem Associates.mk_ne_zero' {R : Type*} [CommSemiring R] {r : R} :
    Associates.mk (Ideal.span {r} : Ideal R) ≠ 0 ↔ r ≠ 0
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
theorem prod_cyclotomic_eq_geom_sum {n : ℕ} (h : 0 < n) (R) [CommRing R] :
    ∏ i ∈ n.divisors.erase 1, cyclotomic i R = ∑ i ∈ Finset.range n, X ^ i
-- Mathlib/LinearAlgebra/Dimension/Finrank.lean
/-- This is like `rank_eq_one_iff_finrank_eq_one` but works for `2`, `3`, `4`, ... -/
lemma rank_eq_ofNat_iff_finrank_eq_ofNat (n : ℕ) [Nat.AtLeastTwo n] :
    Module.rank R M = OfNat.ofNat n ↔ finrank R M = OfNat.ofNat n
-- Mathlib/Data/Real/Cardinality.lean
/-- `cantorFunction c` is injective if `0 < c < 1/2`. -/
theorem cantorFunction_injective (h1 : 0 < c) (h2 : c < 1 / 2) :
    Function.Injective (cantorFunction c)
-- Mathlib/Algebra/CharZero/Quotient.lean
theorem nsmul_mem_zmultiples_iff_exists_sub_div {r : R} {n : ℕ} (hn : n ≠ 0) :
    n • r ∈ AddSubgroup.zmultiples p ↔
      ∃ k : Fin n, r - (k : ℕ) • (p / n : R) ∈ AddSubgroup.zmultiples p
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem subtypeDomain_sub : (v - v').subtypeDomain p = v.subtypeDomain p - v'.subtypeDomain p
-- Mathlib/Analysis/Analytic/Composition.lean
/-- Bounding below the radius of the composition of two formal multilinear series assuming
summability over all compositions. -/
theorem le_comp_radius_of_summable (q : FormalMultilinearSeries 𝕜 F G)
    (p : FormalMultilinearSeries 𝕜 E F) (r : ℝ≥0)
    (hr : Summable fun i : Σ n, Composition n => ‖q.compAlongComposition p i.2‖₊ * r ^ i.1) :
    (r : ℝ≥0∞) ≤ (q.comp p).radius
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_list_sum {l : List (Set E)} (h : ∀ i ∈ l, Convex 𝕜 i) : Convex 𝕜 l.sum
-- Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean
@[reassoc]
lemma map₂_hom_inv_isIso {f g : a ⟶ b} (η : f ⟶ g) [IsIso η] :
    F.map₂ η ≫ F.map₂ (inv η) = 𝟙 (F.map f)
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast]
theorem one_le_coe_iff : (1 : ℝ≥0∞) ≤ ↑r ↔ 1 ≤ r
-- Mathlib/Analysis/BoundedVariation.lean
theorem lowerSemicontinuous_aux {ι : Type*} {F : ι → α → E} {p : Filter ι} {f : α → E} {s : Set α}
    (Ffs : ∀ x ∈ s, Tendsto (fun i => F i x) p (𝓝 (f x))) {v : ℝ≥0∞} (hv : v < eVariationOn f s) :
    ∀ᶠ n : ι in p, v < eVariationOn (F n) s
-- Mathlib/Data/List/Rotate.lean
@[simp]
theorem rotate_append_length_eq (l l' : List α) : (l ++ l').rotate l.length = l' ++ l
-- Mathlib/CategoryTheory/Subobject/Limits.lean
theorem imageSubobject_factors_comp_self {W : C} (k : W ⟶ X) : (imageSubobject f).Factors (k ≫ f)
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem LinearMap.toMatrixAlgEquiv'_symm :
    (LinearMap.toMatrixAlgEquiv'.symm : Matrix n n R ≃ₐ[R] _) = Matrix.toLinAlgEquiv'
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[simp]
theorem coe_toSubMulAction (p : Submodule R M) : (p.toSubMulAction : Set M) = p
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem get_ofFn {n} (f : Fin n → α) (i) : get (ofFn f) i = f i
-- Mathlib/Data/ZMod/IntUnitsPower.lean
lemma uzpow_sub (s : ℤˣ) (x y : R) : s ^ (x - y) = s ^ x / s ^ y
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_def [Preorder ι] [InfSet ι] (u : ι → Ω → β) (s : Set β) (n m : ι) :
    hitting u s n m =
    fun x => if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i : ι | u i x ∈ s}) else m
-- Mathlib/Control/Fold.lean
@[simp]
theorem foldrm.ofFreeMonoid_comp_of {m} [Monad m] [LawfulMonad m] (f : β → α → m α) :
    foldrM.ofFreeMonoid f ∘ FreeMonoid.of = foldrM.mk ∘ f
-- Mathlib/Analysis/Complex/LocallyUniformLimit.lean
theorem tendstoUniformlyOn_deriv_of_cthickening_subset (hf : TendstoLocallyUniformlyOn F f φ U)
    (hF : ∀ᶠ n in φ, DifferentiableOn ℂ (F n) U) {δ : ℝ} (hδ : 0 < δ) (hK : IsCompact K)
    (hU : IsOpen U) (hKU : cthickening δ K ⊆ U) :
    TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- A subspace is dense iff its topological closure is the entire space. -/
theorem Submodule.dense_iff_topologicalClosure_eq_top {s : Submodule R M} :
    Dense (s : Set M) ↔ s.topologicalClosure = ⊤
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- `Finsupp.single` as a `MonoidHom` from the product type into the monoid algebra.

Note the order of the elements of the product are reversed compared to the arguments of
`Finsupp.single`.
-/
@[simps]
def singleHom [MulOneClass G] : k × G →* MonoidAlgebra k G
-- Mathlib/Order/Filter/Pointwise.lean
theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g
-- Mathlib/LinearAlgebra/Dual.lean
theorem LinearEquiv.dualMap_trans {M₃ : Type*} [AddCommGroup M₃] [Module R M₃] (f : M₁ ≃ₗ[R] M₂)
    (g : M₂ ≃ₗ[R] M₃) : g.dualMap.trans f.dualMap = (f.trans g).dualMap
-- Mathlib/Order/Sublattice.lean
@[simp] lemma isSublattice (L : Sublattice α) : IsSublattice (L : Set α)
-- Mathlib/Logic/Embedding/Basic.lean
@[simp]
theorem coe_subtype {α} (p : α → Prop) : ↑(subtype p) = Subtype.val
-- Mathlib/Topology/QuasiSeparated.lean
theorem IsQuasiSeparated.image_of_embedding {s : Set α} (H : IsQuasiSeparated s) (h : Embedding f) :
    IsQuasiSeparated (f '' s)
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem sInf_toSubring (s : Set (Subfield K)) :
    (sInf s).toSubring = ⨅ t ∈ s, Subfield.toSubring t
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_pow {f : K[X]} (hf : f.Splits i) (n : ℕ) : (f ^ n).Splits i
-- Mathlib/RingTheory/DedekindDomain/PID.lean
/-- An invertible ideal in a commutative ring with finitely many maximal ideals is principal.

https://math.stackexchange.com/a/95857 -/
theorem Ideal.IsPrincipal.of_finite_maximals_of_isUnit (hf : {I : Ideal R | I.IsMaximal}.Finite)
    {I : Ideal R} (hI : IsUnit (I : FractionalIdeal R⁰ (FractionRing R))) : I.IsPrincipal
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem basisFun_apply [DecidableEq ι] (i) :
    basisFun p 𝕜 ι i = (WithLp.equiv p _).symm (Pi.single i 1)
-- Mathlib/Data/Set/Finite.lean
@[simp]
protected theorem mem_toFinset : a ∈ hs.toFinset ↔ a ∈ s
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp] lemma card_plift (α : Type*) : card (PLift α) = card α
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem tail_cons (a : α) (s) : tail (cons a s) = s
-- Mathlib/Data/Matrix/Basic.lean
theorem star_eq_conjTranspose [Star α] (M : Matrix m m α) : star M = Mᴴ
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem one_of_mem_closedBall (hx : x ∈ closedBall c f.rIn) : f x = 1
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.sum_type {v' : ι' → M} (hv : LinearIndependent R v)
    (hv' : LinearIndependent R v')
    (h : Disjoint (Submodule.span R (range v)) (Submodule.span R (range v'))) :
    LinearIndependent R (Sum.elim v v')
-- Mathlib/Analysis/MellinTransform.lean
/-- If `f` is `O(x ^ (-a))` as `x → 0`, then `log • f` is `O(x ^ (-b))` for every `a < b`. -/
theorem isBigO_rpow_zero_log_smul [NormedSpace ℝ E] {a b : ℝ} {f : ℝ → E} (hab : a < b)
    (hf : f =O[𝓝[>] 0] (· ^ (-a))) :
    (fun t : ℝ => log t • f t) =O[𝓝[>] 0] (· ^ (-b))
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isPrimal (hu : IsUnit u) : IsPrimal u
-- Mathlib/Data/ENNReal/Inv.lean
@[simp] protected lemma inv_eq_one : a⁻¹ = 1 ↔ a = 1
-- Mathlib/RingTheory/Localization/FractionRing.lean
/-- The inverse of an element in the field of fractions of an integral domain. -/
protected noncomputable irreducible_def inv (z : K) : K
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem EuclideanSpace.volume_closedBall (x : EuclideanSpace ℝ ι) (r : ℝ) :
    volume (Metric.closedBall x r) = (.ofReal r) ^ card ι *
      .ofReal (sqrt π ^ card ι / Gamma (card ι / 2 + 1))
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_add_aleph0 (m : ℕ∞) : m + ℵ₀ = ℵ₀
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
@[simp]
protected theorem _root_.Complex.oangle (w z : ℂ) :
    Complex.orientation.oangle w z = Complex.arg (conj w * z)
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
/-- A local diffeomorphism has open range. -/
lemma IsLocalDiffeomorph.isOpen_range (hf : IsLocalDiffeomorph I J n f) : IsOpen (range f)
-- Mathlib/Analysis/InnerProductSpace/NormPow.lean
theorem norm_fderiv_norm_rpow_le {f : F → E} (hf : Differentiable ℝ f) {x : F}
    {p : ℝ} (hp : 1 < p) :
    ‖fderiv ℝ (fun x ↦ ‖f x‖ ^ p) x‖ ≤ p * ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.mul_toMatrix' (B : (n → R) →ₗ[R] (m → R) →ₗ[R] R) (M : Matrix n' n R) :
    M * toMatrix₂' R B = toMatrix₂' R (B.comp <| toLin' Mᵀ)
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem measure_trim_toMeasurable_eq_zero {hm : m ≤ m0} (hs : μ.trim hm s = 0) :
    μ (@toMeasurable α m (μ.trim hm) s) = 0
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
/-- If `r` is less than the Hausdorff dimension of a set `s` in an (extended) metric space with
second countable topology, then there exists a point `x ∈ s` such that every neighborhood
`t` of `x` within `s` has Hausdorff dimension greater than `r`. -/
theorem exists_mem_nhdsWithin_lt_dimH_of_lt_dimH {s : Set X} {r : ℝ≥0∞} (h : r < dimH s) :
    ∃ x ∈ s, ∀ t ∈ 𝓝[s] x, r < dimH t
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem pullbackSymmetry_hom_comp_fst [HasPullback f g] :
    (pullbackSymmetry f g).hom ≫ pullback.fst g f = pullback.snd f g
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem isPiSystem_isOpen [TopologicalSpace α] : IsPiSystem ({s : Set α | IsOpen s})
-- Mathlib/NumberTheory/NumberField/House.lean
private theorem lin_1 (l k r) : a k l * (newBasis K) r =
    ∑ u, (a' K a k l r u) * (newBasis K) u
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem lineMap_vsub (p₁ p₂ p₃ : P₁) (c : k) :
    lineMap p₁ p₂ c -ᵥ p₃ = lineMap (p₁ -ᵥ p₃) (p₂ -ᵥ p₃) c
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive ofNat_zsmul]
lemma zpow_ofNat (a : G) (n : ℕ) : a ^ (no_index (OfNat.ofNat n) : ℤ) = a ^ OfNat.ofNat n
-- Mathlib/RingTheory/Perfection.lean
theorem coeff_pow_p (f : Ring.Perfection R p) (n : ℕ) :
    coeff R p (n + 1) (f ^ p) = coeff R p n f
-- .lake/packages/lean4/src/lean/Init/Data/String/Lemmas.lean
protected theorem data_eq_of_eq {a b : String} (h : a = b) : a.data = b.data
-- Mathlib/GroupTheory/GroupAction/SubMulAction/Pointwise.lean
theorem coe_pow (p : SubMulAction R M) : ∀ {n : ℕ} (_ : n ≠ 0), ↑(p ^ n) = (p : Set M) ^ n
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_smul' (c : S₂) (f : M₁ →SL[σ₁₂] M₂) :
    ↑(c • f) = c • (f : M₁ → M₂)
-- Mathlib/Order/Filter/Prod.lean
theorem le_prod {f : Filter (α × β)} {g : Filter α} {g' : Filter β} :
    (f ≤ g ×ˢ g') ↔ Tendsto Prod.fst f g ∧ Tendsto Prod.snd f g'
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem ne_of_not_mem_cons {a b : α} {l : List α} : a ∉ b::l → a ≠ b
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Icc_self : Ico a b ⊆ Icc a b
-- Mathlib/Topology/Sequences.lean
/-- If the domain of a function `f : α → β` is a Fréchet-Urysohn space, then convergence
is equivalent to sequential convergence. See also `Filter.tendsto_iff_seq_tendsto` for a version
that works for any pair of filters assuming that the filter in the domain is countably generated.

This property is equivalent to the definition of `FrechetUrysohnSpace`, see
`FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto`. -/
theorem tendsto_nhds_iff_seq_tendsto [FrechetUrysohnSpace X] {f : X → Y} {a : X} {b : Y} :
    Tendsto f (𝓝 a) (𝓝 b) ↔ ∀ u : ℕ → X, Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 b)
-- Mathlib/RingTheory/HahnSeries/Addition.lean
@[simp]
theorem add_coeff' {x y : HahnSeries Γ R} : (x + y).coeff = x.coeff + y.coeff
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem map_id : map id μ = μ
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- In the characteristic zero case, the weights in the centroid sum
to 1 if the number of points is `n + 1`. -/
theorem sum_centroidWeights_eq_one_of_card_eq_add_one [CharZero k] {n : ℕ} (h : card s = n + 1) :
    ∑ i ∈ s, s.centroidWeights k i = 1
-- Mathlib/CategoryTheory/Limits/Shapes/NormalMono/Basic.lean
/-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem typesGlue_eval {S hs α} (s) : typesGlue.{u} S hs α (eval S α s) = s
-- Mathlib/Data/List/Cycle.lean
@[simp]
nonrec theorem nodup_nil : Nodup (@nil α)
-- Mathlib/Data/ENNReal/Real.lean
theorem lt_ofReal_iff_toReal_lt {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ∞) :
    a < ENNReal.ofReal b ↔ ENNReal.toReal a < b
-- Mathlib/Algebra/Order/Field/Power.lean
theorem Nat.zpow_ne_zero_of_pos {a : ℕ} (h : 0 < a) (n : ℤ) : (a : α) ^ n ≠ 0
-- Mathlib/Analysis/Calculus/Implicit.lean
@[simp]
theorem prodFun_apply (x : E) : φ.prodFun x = (φ.leftFun x, φ.rightFun x)
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
lemma norm_fourierSMulRight_le (L : V →L[ℝ] W →L[ℝ] ℝ) (f : V → E) (v : V) :
    ‖fourierSMulRight L f v‖ ≤ 2 * π * ‖L‖ * ‖v‖ * ‖f v‖
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
/-- The map `M.sections → N.sections` induced by a morphisms `M ⟶ N` of presheaves of modules. -/
@[simps!]
def sectionsMap {M N : PresheafOfModules.{v} R} (f : M ⟶ N) (s : M.sections) : N.sections
-- Mathlib/Logic/Encodable/Basic.lean
theorem encode_injective [Encodable α] : Function.Injective (@encode α _)
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_lt : |a|ₘ < b ↔ b⁻¹ < a ∧ a < b
-- Mathlib/Data/Set/Finite.lean
@[simp]
nonrec theorem disjoint_toFinset {hs : s.Finite} {ht : t.Finite} :
    Disjoint hs.toFinset ht.toFinset ↔ Disjoint s t
-- Mathlib/Data/ENNReal/Inv.lean
theorem inv_ne_top : a⁻¹ ≠ ∞ ↔ a ≠ 0
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem filter_ne_eq_erase' (f : Π₀ i, β i) (i : ι) : f.filter (i ≠ ·) = f.erase i
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_comp_botHom (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) :
    (f.comp g : BotHom α γ) = (f : BotHom β γ).comp g
-- Mathlib/Data/List/Basic.lean
theorem get_length_sub_one {l : List α} (h : l.length - 1 < l.length) :
    l.get ⟨l.length - 1, h⟩ = l.getLast (by rintro rfl; exact Nat.lt_irrefl 0 h)
-- Mathlib/Analysis/Calculus/BumpFunction/Convolution.lean
/-- If a function `g` is locally integrable, then the convolution `φ i * g` converges almost
everywhere to `g` if `φ i` is a sequence of bump functions with support tending to `0`, provided
that the ratio between the inner and outer radii of `φ i` remains bounded. -/
theorem ae_convolution_tendsto_right_of_locallyIntegrable
    {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι} {K : ℝ}
    (hφ : Tendsto (fun i ↦ (φ i).rOut) l (𝓝 0))
    (h'φ : ∀ᶠ i in l, (φ i).rOut ≤ K * (φ i).rIn) (hg : LocallyIntegrable g μ) : ∀ᵐ x₀ ∂μ,
    Tendsto (fun i ↦ ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀) l (𝓝 (g x₀))
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem pow_apply [Monoid R] [BoundedMul R] [ContinuousMul R] (n : ℕ) (f : α →ᵇ R) (x : α) :
    (f ^ n) x = f x ^ n
-- Mathlib/Order/Atoms.lean
@[simp] theorem isStronglyCoatomic_dual_iff_is_stronglyAtomic :
    IsStronglyCoatomic αᵒᵈ ↔ IsStronglyAtomic α
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem iSup_eapprox_apply (f : α → ℝ≥0∞) (hf : Measurable f) (a : α) :
    ⨆ n, (eapprox f n : α →ₛ ℝ≥0∞) a = f a
-- Mathlib/Combinatorics/SetFamily/LYM.lean
/-- **Sperner's theorem**. The size of an antichain in `Finset α` is bounded by the size of the
maximal layer in `Finset α`. This precisely means that `Finset α` is a Sperner order. -/
theorem IsAntichain.sperner [Fintype α] {𝒜 : Finset (Finset α)}
    (h𝒜 : IsAntichain (· ⊆ ·) (𝒜 : Set (Finset α))) :
    𝒜.card ≤ (Fintype.card α).choose (Fintype.card α / 2)
-- Mathlib/Data/List/Sigma.lean
theorem Perm.kinsert {a} {b : β a} {l₁ l₂ : List (Sigma β)} (nd₁ : l₁.NodupKeys) (p : l₁ ~ l₂) :
    kinsert a b l₁ ~ kinsert a b l₂
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[reassoc (attr := simp)]
theorem rightDistributor_inv_comp_biproduct_π {J : Type} [Fintype J] (f : J → C) (X : C) (j : J) :
    (rightDistributor f X).inv ≫ (biproduct.π _ j ▷ X) = biproduct.π _ j
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem Integrable.integral_prod_right [SFinite μ] ⦃f : α × β → E⦄
    (hf : Integrable f (μ.prod ν)) : Integrable (fun y => ∫ x, f (x, y) ∂μ) ν
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem ge_trans (h₁ : cmp x y ≠ .lt) (h₂ : cmp y z ≠ .lt) : cmp x z ≠ .lt
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem comp_isOpenMap_iff' (h : X ≃ₜ Y) {f : Y → Z} : IsOpenMap (f ∘ h) ↔ IsOpenMap f
-- Mathlib/LinearAlgebra/AffineSpace/Slope.lean
theorem sub_smul_slope_vadd (f : k → PE) (a b : k) : (b - a) • slope f a b +ᵥ f a = f b
-- Mathlib/Algebra/Module/PID.lean
theorem Submodule.isSemisimple_torsionBy_of_irreducible {a : R} (h : Irreducible a) :
    IsSemisimpleModule R (torsionBy R M a)
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
@[symm]
nonrec theorem symm (H : Homotopic f g) : Homotopic g f
-- .lake/packages/batteries/Batteries/WF.lean
@[csimp] private theorem fix_eq_fixC : @fix = @fixC
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_eq_of_equiv_fin {α : Type*} {n : ℕ} (f : α ≃ Fin n) : Nat.card α = n
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem edist_dist (x y : α) : edist x y = ENNReal.ofReal (dist x y)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem getD_none : getD none a = a
-- Mathlib/NumberTheory/LSeries/Linearity.lean
lemma LSeriesSummable.neg {f : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s) :
    LSeriesSummable (-f) s
-- Mathlib/LinearAlgebra/LinearPMap.lean
protected theorem right_le_sup (f g : E →ₗ.[R] F)
    (h : ∀ (x : f.domain) (y : g.domain), (x : E) = y → f x = g y) : g ≤ f.sup g h
-- Mathlib/RingTheory/Artinian.lean
theorem isArtinianRing_iff {R} [Ring R] : IsArtinianRing R ↔ IsArtinian R R
-- Mathlib/Algebra/Lie/Weights/Basic.lean
@[simp] lemma coe_weight_mk (χ : L → R) (h) :
    (↑(⟨χ, h⟩ : Weight R L M) : L → R) = χ
-- Mathlib/Algebra/CharP/Defs.lean
lemma eq {p q : ℕ} (_hp : CharP R p) (_hq : CharP R q) : p = q
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem length_edges {u v : V} (p : G.Walk u v) : p.edges.length = p.length
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_Iio : IsPiSystem (range Iio : Set (Set α))
-- Mathlib/Data/Vector/Snoc.lean
@[simp]
theorem snoc_cons : (x ::ᵥ xs).snoc y = x ::ᵥ (xs.snoc y)
-- Mathlib/AlgebraicGeometry/Spec.lean
lemma Spec.locallyRingedSpaceObj_sheaf' (R : Type u) [CommRing R] :
    (Spec.locallyRingedSpaceObj <| CommRingCat.of R).sheaf = structureSheaf R
-- Mathlib/Data/Set/Basic.lean
theorem not_subset : ¬s ⊆ t ↔ ∃ a ∈ s, a ∉ t
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt16.toNat_div (x y : UInt16) : (x / y).toNat = x.toNat / y.toNat
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[nontriviality, measurability]
theorem Subsingleton.measurable [Subsingleton α] : Measurable f
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast]
theorem cast_natCast (n : ℕ) : ((n : ℚ) : α) = n
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem elim_comp_map {f₁ : α → β} {f₂ : β → ε} {g₁ : γ → δ} {g₂ : δ → ε} :
    Sum.elim f₂ g₂ ∘ Sum.map f₁ g₁ = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrictₗ_apply {_m0 : MeasurableSpace α} (s : Set α) (μ : Measure α) :
    restrictₗ s μ = μ.restrict s
-- Mathlib/Data/Set/Basic.lean
@[refl]
theorem Subset.refl (a : Set α) : a ⊆ a
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem hasMFDerivWithinAt_inter' (h : t ∈ 𝓝[s] x) :
    HasMFDerivWithinAt I I' f (s ∩ t) x f' ↔ HasMFDerivWithinAt I I' f s x f'
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem piCongrRight_trans (e : (i : ι) → φ i ≃ₗ[R] ψ i) (f : (i : ι) → ψ i ≃ₗ[R] χ i) :
    (piCongrRight e).trans (piCongrRight f) = piCongrRight fun i => (e i).trans (f i)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem hasFiniteIntegral_const_iff {c : β} :
    HasFiniteIntegral (fun _ : α => c) μ ↔ c = 0 ∨ μ univ < ∞
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
/-- Given presieve `R` and presheaf `P : Cᵒᵖ ⥤ A`, the natural cone associated to `P` and
    the sieve `Sieve.generate R` generated by `R` is a limit cone iff `Hom (E, P -)` is a
    sheaf of types for the presieve `R` and all `E : A`. -/
theorem isLimit_iff_isSheafFor_presieve :
    Nonempty (IsLimit (P.mapCone (generate R).arrows.cocone.op)) ↔
      ∀ E : Aᵒᵖ, IsSheafFor (P ⋙ coyoneda.obj E) R
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[simp]
theorem rightAdjointMate_id {X : C} [HasRightDual X] : (𝟙 X)ᘁ = 𝟙 (Xᘁ)