ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/PartitionOfUnity.lean
/-- Let `X` be an extended metric space. Let `K : ι → Set X` be a locally finite family of closed
sets, let `U : ι → Set X` be a family of open sets such that `K i ⊆ U i` for all `i`. Then there
exists a positive continuous function `δ : C(X, ℝ)` such that for any `i` and `x ∈ K i`,
we have `EMetric.closedBall x (ENNReal.ofReal (δ x)) ⊆ U i`. -/
theorem exists_continuous_real_forall_closedBall_subset (hK : ∀ i, IsClosed (K i))
    (hU : ∀ i, IsOpen (U i)) (hKU : ∀ i, K i ⊆ U i) (hfin : LocallyFinite K) :
    ∃ δ : C(X, ℝ), (∀ x, 0 < δ x) ∧
      ∀ (i), ∀ x ∈ K i, closedBall x (ENNReal.ofReal <| δ x) ⊆ U i
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
theorem algebraMap_eq_of_integral {x : A} : IsIntegral R x → ∃ y : R, algebraMap R A y = x
-- Mathlib/Data/Sum/Order.lean
theorem inr_lt_inr_iff [LT α] [LT β] {a b : β} : toLex (inr a : α ⊕ₗ β) < toLex (inr b) ↔ a < b
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem absorbs_iff_eventually_nhdsWithin_zero :
    Absorbs 𝕜 s t ↔ ∀ᶠ c : 𝕜 in 𝓝[≠] 0, MapsTo (c • ·) t s
-- Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean
@[simp]
lemma closure_sphere : closure (sphere x ε) = sphere x ε
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If the radius of `p` is positive, then `‖pₙ‖` grows at most geometrically. -/
theorem le_mul_pow_of_radius_pos (p : FormalMultilinearSeries 𝕜 E F) (h : 0 < p.radius) :
    ∃ (C r : _) (hC : 0 < C) (_ : 0 < r), ∀ n, ‖p n‖ ≤ C * r ^ n
-- Mathlib/RingTheory/Ideal/Maps.lean
@[simp]
theorem mem_comap {x} : x ∈ comap f K ↔ f x ∈ K
-- Mathlib/CategoryTheory/Monoidal/Mod_.lean
/-- The identity morphism on a module object. -/
@[simps]
def id (M : Mod_ A) : Hom M M
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem mulLeftRight_apply (x y z : 𝕜') : mulLeftRight 𝕜 𝕜' x y z = x * z * y
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp]
theorem stalkToFiberRingHom_germ' (U : Opens (PrimeSpectrum.Top R)) (x : PrimeSpectrum.Top R)
    (hx : x ∈ U) (s : (structureSheaf R).1.obj (op U)) :
    stalkToFiberRingHom R x ((structureSheaf R).presheaf.germ ⟨x, hx⟩ s) = (s.1 ⟨x, hx⟩ : _)
-- Mathlib/NumberTheory/Dioph.lean
theorem union : ∀ (_ : Dioph S) (_ : Dioph S'), Dioph (S ∪ S')
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_preimage_of_subset_range_lift {α : Type u} {β : Type v} (f : α → β) (s : Set β)
    (h : s ⊆ range f) : lift.{u} #s ≤ lift.{v} #(f ⁻¹' s)
-- Mathlib/Probability/Process/Adapted.lean
theorem stronglyMeasurable_le {i j : ι} (hf : Adapted f u) (hij : i ≤ j) :
    StronglyMeasurable[f j] (u i)
-- Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean
@[simp]
lemma whiskerRight_app_apply {K K' : SSet.{u}} (f : K ⟶ K') (L : SSet.{u})
    {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ L).obj Δ) :
    (f ▷ L).app Δ x = ⟨f.app Δ x.1, x.2⟩
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_inf_le : map f (I ⊓ J) ≤ map f I ⊓ map f J
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem repeat_one {α : Type*} (a : Fin n → α) : Fin.repeat 1 a = a ∘ cast (Nat.one_mul _)
-- Mathlib/Topology/Algebra/UniformField.lean
@[norm_cast]
theorem coe_inv (x : K) : (x : hat K)⁻¹ = ((x⁻¹ : K) : hat K)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem isAdjoinRoot_root_eq_root : (AdjoinRoot.isAdjoinRoot f).root = AdjoinRoot.root f
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem restrictScalars_smul (c : S) (f : M →L[A] M₂) :
    (c • f).restrictScalars R = c • f.restrictScalars R
-- Mathlib/Order/Filter/Pointwise.lean
theorem NeBot.zero_div_nonneg (hg : g.NeBot) : 0 ≤ 0 / g
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j
-- Mathlib/Algebra/GradedMonoid.lean
theorem SetLike.one_mem_graded {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S)
    [SetLike.GradedOne A] : (1 : R) ∈ A 0
-- Mathlib/Order/Filter/Basic.lean
theorem iInf_sets_eq_finite {ι : Type*} (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets
-- Mathlib/ModelTheory/ElementarySubstructures.lean
/-- The Tarski-Vaught test for elementarity of a substructure. -/
theorem isElementary_of_exists (S : L.Substructure M)
    (htv :
      ∀ (n : ℕ) (φ : L.BoundedFormula Empty (n + 1)) (x : Fin n → S) (a : M),
        φ.Realize default (Fin.snoc ((↑) ∘ x) a : _ → M) →
          ∃ b : S, φ.Realize default (Fin.snoc ((↑) ∘ x) b : _ → M)) :
    S.IsElementary
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem tendsto_arctan_atBot : Tendsto arctan atBot (𝓝[>] (-(π / 2)))
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive] theorem range_eq (f : G ∗ H →* K) :
    MonoidHom.range f = MonoidHom.range (f.comp inl) ⊔ MonoidHom.range (f.comp inr)
-- Mathlib/Data/Int/Cast/Lemmas.lean
/-- If two `MonoidWithZeroHom`s agree on `-1` and the _positive_ naturals then they are equal. -/
theorem ext_int' [MonoidWithZero α] [FunLike F ℤ α] [MonoidWithZeroHomClass F ℤ α] {f g : F}
    (h_neg_one : f (-1) = g (-1)) (h_pos : ∀ n : ℕ, 0 < n → f n = g n) : f = g
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[norm_cast]
theorem coe_prod (s : NonUnitalSubring R) (t : NonUnitalSubring S) :
    (s.prod t : Set (R × S)) = (s : Set R) ×ˢ t
-- Mathlib/Data/Int/GCD.lean
@[simp]
theorem lcm_zero_right (i : ℤ) : lcm i 0 = 0
-- Mathlib/Data/Set/Basic.lean
theorem eq_empty_of_forall_not_mem (h : ∀ x, x ∉ s) : s = ∅
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[reassoc]
theorem biproduct.lift_matrix {K : Type} [Finite K] [HasFiniteBiproducts C] {f : J → C} {g : K → C}
    {P} (x : ∀ j, P ⟶ f j) (m : ∀ j k, f j ⟶ g k) :
    biproduct.lift x ≫ biproduct.matrix m = biproduct.lift fun k => ∑ j, x j ≫ m j k
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mfderiv_eq : mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') f x = f
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma epi₁ (h : T.mor₂ = 0) : Epi T.mor₁
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_hom_rightUnitor (X : C) : (ρ_ X).hom.mop = (λ_ (mop X)).hom
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.symmetrifyStar (u : U) :
    φ.symmetrify.star u =
      (Quiver.symmetrifyStar _).symm ∘ Sum.map (φ.star u) (φ.costar u) ∘
        Quiver.symmetrifyStar u
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_floor_left (n : ℤ) :
    Tendsto (fun x => floor x : α → α) (𝓝[<] n) (𝓝[≤] (n - 1))
-- Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean
theorem aeSeq_eq_mk_ae [Countable ι] (hf : ∀ i, AEMeasurable (f i) μ)
    (hp : ∀ᵐ x ∂μ, p x fun n => f n x) : ∀ᵐ a : α ∂μ, ∀ i : ι, aeSeq hf p i a = (hf i).mk (f i) a
-- Mathlib/CategoryTheory/Functor/ReflectsIso.lean
lemma reflectsIsomorphisms_of_comp (F : C ⥤ D) (G : D ⥤ E)
    [(F ⋙ G).ReflectsIsomorphisms] : F.ReflectsIsomorphisms
-- Mathlib/Analysis/Convex/Combination.lean
theorem Finset.convexHull_eq (s : Finset E) : convexHull R ↑s =
    { x : E | ∃ w : E → R, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x }
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- If every coefficient of a polynomial is in an ideal `I`, then so is the polynomial itself,
multivariate version. -/
theorem mem_ideal_of_coeff_mem_ideal (I : Ideal (MvPolynomial σ R)) (p : MvPolynomial σ R)
    (hcoe : ∀ m : σ →₀ ℕ, p.coeff m ∈ I.comap (C : R →+* MvPolynomial σ R)) : p ∈ I
-- Mathlib/Data/Finsupp/Weight.lean
/-- A weight function is nontorsion if its values are not torsion. -/
class NonTorsionWeight (w : σ → M) : Prop where
  eq_zero_of_smul_eq_zero {n : ℕ} {s : σ} (h : n • w s = 0)  : n = 0
-- Mathlib/Order/Disjointed.lean
theorem iUnion_disjointed {f : ℕ → Set α} : ⋃ n, disjointed f n = ⋃ n, f n
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- Given a family of points together with a chosen base point in that family, membership of the
affine span of this family corresponds to an identity in terms of `weightedVSubOfPoint`, with
weights that are not required to sum to 1. -/
theorem mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd [Nontrivial k] (p : ι → P) (j : ι) (q : P) :
    q ∈ affineSpan k (Set.range p) ↔
      ∃ (s : Finset ι) (w : ι → k), q = s.weightedVSubOfPoint p (p j) w +ᵥ p j
-- Mathlib/LinearAlgebra/QuadraticForm/IsometryEquiv.lean
@[trans]
theorem trans (h : Q₁.Equivalent Q₂) (h' : Q₂.Equivalent Q₃) : Q₁.Equivalent Q₃
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp, norm_cast]
theorem coe_smul [Semiring R'] [SMul R' R] [Module R' A] [IsScalarTower R' R A] (r : R') (x : S) :
    ↑(r • x) = r • (x : A)
-- Mathlib/Analysis/Calculus/Deriv/Inverse.lean
theorem HasDerivAt.eventually_ne (h : HasDerivAt f f' x) (hf' : f' ≠ 0) :
    ∀ᶠ z in 𝓝[≠] x, f z ≠ f x
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
theorem smul_map_volume_mul_left {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (a * ·) volume = volume
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem eval₂Hom_C_left (f : σ → MvPolynomial τ R) : eval₂Hom C f = bind₁ f
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem edist_map (x y : E) : edist (f x) (f y) = edist x y
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffWithinAt_const {c : F} : ContDiffWithinAt 𝕜 n (fun _ : E => c) s x
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_min_of_nonneg [PosMulMono α]
    (b c : α) (ha : 0 ≤ a) : a * min b c = min (a * b) (a * c)
-- Mathlib/Tactic/NormNum/Result.lean
/-- Assert that an element of a ring is equal to the coercion of some integer. -/
structure IsInt [Ring α] (a : α) (n : ℤ) : Prop where
  /-- The element is equal to the coercion of the integer. -/
  out : a = n
-- Mathlib/Algebra/BigOperators/Ring.lean
@[simp, norm_cast]
lemma cast_list_prod [Ring β] (s : List ℤ) : (↑s.prod : β) = (s.map (↑)).prod
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem orElse_none' (x : Option α) : x.orElse (fun _ ↦ none) = x
-- Mathlib/Data/Countable/Defs.lean
theorem exists_surjective_nat (α : Sort u) [Nonempty α] [Countable α] : ∃ f : ℕ → α, Surjective f
-- Mathlib/Algebra/DirectLimit.lean
theorem totalize_of_le {i j} (h : i ≤ j) : totalize G f i j = f i j h
-- Mathlib/Order/InitialSeg.lean
/-- If `r` is a relation on `α` and `s` in a relation on `β`, then `f : r ≼i s` is an order
embedding whose range is an initial segment. That is, whenever `b < f a` in `β` then `b` is in the
range of `f`. -/
structure InitialSeg {α β : Type*} (r : α → α → Prop) (s : β → β → Prop) extends r ↪r s where
  /-- The order embedding is an initial segment -/
  init' : ∀ a b, s b (toRelEmbedding a) → ∃ a', toRelEmbedding a' = b
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- The weighted degree of a weighted homogeneous polynomial controls its support. -/
theorem coeff_eq_zero {w : σ → M} (hφ : IsWeightedHomogeneous w φ n) (d : σ →₀ ℕ)
    (hd : weight w d ≠ n) : coeff d φ = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem mul_le_add_right (m k n : Nat) : k * m ≤ m + n ↔ (k-1) * m ≤ n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem replace_replicate_ne {a b c : α} (h : !b == a) :
    (replicate n a).replace b c = replicate n a
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem map_lift_kernelComparison [HasKernel f] [HasKernel (G.map f)] {Z : C} {h : Z ⟶ X}
    (w : h ≫ f = 0) :
    G.map (kernel.lift _ h w) ≫ kernelComparison f G =
      kernel.lift _ (G.map h) (by simp only [← G.map_comp, w, Functor.map_zero])
-- Mathlib/Analysis/Convex/Gauge.lean
/-- Any seminorm arises as the gauge of its unit ball. -/
@[simp]
protected theorem Seminorm.gauge_ball (p : Seminorm ℝ E) : gauge (p.ball 0 1) = p
-- Mathlib/Data/List/GetD.lean
theorem getD_default_eq_getI {n : ℕ} : l.getD n default = l.getI n
-- Mathlib/SetTheory/Ordinal/Basic.lean
/--
A variation on `Cardinal.lt_ord` using `≤`: If `o` is no greater than the
initial ordinal of cardinality `c`, then its cardinal is no greater than `c`.

The converse, however, is false (for instance, `o = ω+1` and `c = ℵ₀`).
-/
lemma card_le_of_le_ord {o : Ordinal} {c : Cardinal} (ho : o ≤ c.ord) :
    o.card ≤ c
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem id_comp (f : M →[L] N) : (id L N).comp f = f
-- Mathlib/Algebra/Homology/ShortComplex/Abelian.lean
@[reassoc (attr := simp 1100)]
lemma abelianImageToKernel_comp_kernel_ι_comp_cokernel_π :
    S.abelianImageToKernel ≫ kernel.ι S.g ≫ cokernel.π S.f = 0
-- Mathlib/Topology/PartitionOfUnity.lean
/-- If `X` is a normal topological space and `U i`, `i : ι`, is a locally finite open covering of a
closed set `s`, then there exists a `BumpCovering ι X s` that is subordinate to `U`. If `X` is a
paracompact space, then the assumption `hf : LocallyFinite U` can be omitted, see
`BumpCovering.exists_isSubordinate`. This version assumes that `p : (X → ℝ) → Prop` is a predicate
that satisfies Urysohn's lemma, and provides a `BumpCovering` such that each function of the
covering satisfies `p`. -/
theorem exists_isSubordinate_of_locallyFinite_of_prop [NormalSpace X] (p : (X → ℝ) → Prop)
    (h01 : ∀ s t, IsClosed s → IsClosed t → Disjoint s t →
      ∃ f : C(X, ℝ), p f ∧ EqOn f 0 s ∧ EqOn f 1 t ∧ ∀ x, f x ∈ Icc (0 : ℝ) 1)
    (hs : IsClosed s) (U : ι → Set X) (ho : ∀ i, IsOpen (U i)) (hf : LocallyFinite U)
    (hU : s ⊆ ⋃ i, U i) : ∃ f : BumpCovering ι X s, (∀ i, p (f i)) ∧ f.IsSubordinate U
-- Mathlib/Probability/CondCount.lean
theorem condCount_eq_one_of (hs : s.Finite) (hs' : s.Nonempty) (ht : s ⊆ t) :
    condCount s t = 1
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[reassoc (attr := simp)]
theorem coev_naturality {X Y : C} (f : X ⟶ Y) :
    f ≫ (coev A).app Y = (coev A).app X ≫ (ihom A).map (A ◁ f)
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[simp] theorem forall₂_cons {R : α → β → Prop} {a b l₁ l₂} :
    Forall₂ R (a :: l₁) (b :: l₂) ↔ R a b ∧ Forall₂ R l₁ l₂
-- Mathlib/MeasureTheory/Group/Action.lean
@[to_additive]
theorem smulInvariantMeasure_map [SMul M α] [SMul M β]
    [MeasurableSMul M β]
    (μ : Measure α) [SMulInvariantMeasure M α μ] (f : α → β)
    (hsmul : ∀ (m : M) a, f (m • a) = m • f a) (hf : Measurable f) :
    SMulInvariantMeasure M β (map f μ)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
/-- Euclid's lemma: if `a ∣ b * c` and `a` and `c` have no common prime factors, `a ∣ b`.
Compare `IsCoprime.dvd_of_dvd_mul_left`. -/
theorem dvd_of_dvd_mul_left_of_no_prime_factors {a b c : R} (ha : a ≠ 0)
    (h : ∀ ⦃d⦄, d ∣ a → d ∣ c → ¬Prime d) : a ∣ b * c → a ∣ b
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
lemma desc_f' (j : ι) (hj : ¬ c.Rel j (c.next j)) :
    (desc φ α hα).f j = sndX φ j ≫ α.f j
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The symbol `J(0 | b)` vanishes when `b > 1`. -/
theorem zero_left {b : ℕ} (hb : 1 < b) : J(0 | b) = 0
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem tendsto_nhdsWithin_nhds [PseudoMetricSpace β] {f : α → β} {a b} :
    Tendsto f (𝓝[s] a) (𝓝 b) ↔
      ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, x ∈ s → dist x a < δ → dist (f x) b < ε
-- Mathlib/Data/Set/Card.lean
theorem ncard_diff (h : s ⊆ t) (ht : t.Finite := by toFinite_tac) :
    (t \ s).ncard = t.ncard - s.ncard
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem isUnit_det_of_invertible [Invertible A] : IsUnit A.det
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp, norm_cast]
theorem coe_restrictScalars (f : M →ₗ[S] M₂) : ((f : M →ₗ[R] M₂) : M → M₂) = f
-- Mathlib/Algebra/ContinuedFractions/Computation/ApproximationCorollaries.lean
/-- The recurrence relation for the convergents of the continued fraction expansion
of an element `v` of `K` in terms of the convergents of the inverse of its fractional part.
-/
theorem convs_succ (n : ℕ) :
    (of v).convs (n + 1) = ⌊v⌋ + 1 / (of (Int.fract v)⁻¹).convs n
-- Mathlib/Data/PFunctor/Univariate/M.lean
@[simp]
theorem cases_mk {r : M F → Sort*} (x : F (M F)) (f : ∀ x : F (M F), r (M.mk x)) :
    PFunctor.M.cases f (M.mk x) = f x
-- Mathlib/Data/Nat/Factors.lean
theorem dvd_of_primeFactorsList_subperm {a b : ℕ} (ha : a ≠ 0)
    (h : a.primeFactorsList <+~ b.primeFactorsList) : a ∣ b
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In any preadditive category, any biproduct satsifies
`∑ j : J, biproduct.π f j ≫ biproduct.ι f j = 𝟙 (⨁ f)`
-/
@[simp]
theorem biproduct.total : ∑ j : J, biproduct.π f j ≫ biproduct.ι f j = 𝟙 (⨁ f)
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem next_apply (t : Icc v.tMin v.tMax) : f.next t = v.x₀ + ∫ τ : ℝ in v.t₀..t, f.vComp τ
-- Mathlib/Data/Vector/MapLemmas.lean
/-- If `f` takes a pair of states, but always returns the same value for both elements of the
    pair, then we can simplify to just a single element of state
  -/
@[simp]
theorem mapAccumr_redundant_pair (f : α → (σ × σ) → (σ × σ) × β)
    (h : ∀ x s, (f x (s, s)).fst.fst = (f x (s, s)).fst.snd) :
    (mapAccumr f xs (s, s)).snd = (mapAccumr (fun x (s : σ) =>
      (f x (s, s) |>.fst.fst, f x (s, s) |>.snd)
    ) xs s).snd
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[simp 1100]
theorem wideCoequalizer.cotrident_ι_app_one :
    (wideCoequalizer.cotrident f).ι.app one = wideCoequalizer.π f
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem cauchySeq_finset_iff_nat_tprod_vanishing {f : ℕ → G} :
    (CauchySeq fun s : Finset ℕ ↦ ∏ n ∈ s, f n) ↔
      ∀ e ∈ 𝓝 (1 : G), ∃ N : ℕ, ∀ t ⊆ {n | N ≤ n}, (∏' n : t, f n) ∈ e
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem drop_nil : ([] : List α).drop i = []
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem map_equiv_eq_comap_symm (f : R ≃+* S) (K : NonUnitalSubsemiring R) :
    K.map (f : R →ₙ+* S) = K.comap f.symm
-- Mathlib/Dynamics/FixedPoints/Basic.lean
/-- Given two maps `f : α → β` and `g : β → α`, `g` is a bijective map between the fixed points
of `f ∘ g` and the fixed points of `g ∘ f`. The inverse map is `f`, see `invOn_fixedPoints_comp`. -/
theorem bijOn_fixedPoints_comp (f : α → β) (g : β → α) :
    Set.BijOn g (fixedPoints <| f ∘ g) (fixedPoints <| g ∘ f)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[elab_as_elim]
theorem Eq.substr {α : Sort u} {p : α → Prop} {a b : α} (h₁ : b = a) (h₂ : p a) : p b
-- Mathlib/Logic/Nontrivial/Defs.lean
lemma not_subsingleton_iff_nontrivial : ¬ Subsingleton α ↔ Nontrivial α
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma finite_weightSpace_ne_bot [NoZeroSMulDivisors R M] [IsNoetherian R M] :
    {χ : L → R | weightSpace M χ ≠ ⊥}.Finite
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
protected theorem AECover.restrict {φ : ι → Set α} (hφ : AECover μ l φ) {s : Set α} :
    AECover (μ.restrict s) l φ
-- Mathlib/Computability/Primrec.lean
theorem vector_tail {n} : Primrec (@Vector.tail α n)
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem trailingDegree_le_of_ne_zero (h : coeff p n ≠ 0) : trailingDegree p ≤ n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Basic.lean
theorem modn_lt : ∀ {m : Nat} (i : Fin n), m > 0 → (modn i m).val < m
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem erase_eq_eraseP' (a : α) (l : List α) : l.erase a = l.eraseP (· == a)
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- Also known as the stability axiom. -/
@[simp]
theorem pullback_stable (f : Y ⟶ X) (hS : S ∈ J X) : S.pullback f ∈ J Y
-- Mathlib/Control/Fold.lean
@[simps]
def Foldl.ofFreeMonoid (f : β → α → β) : FreeMonoid α →* Monoid.Foldl β
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem contDiffAt_arccos_iff {x : ℝ} {n : ℕ∞} :
    ContDiffAt ℝ n arccos x ↔ n = 0 ∨ x ≠ -1 ∧ x ≠ 1
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
theorem LeftExactFunctor.forget_obj_of (F : C ⥤ D) [PreservesFiniteLimits F] :
    (LeftExactFunctor.forget C D).obj (LeftExactFunctor.of F) = F
-- Mathlib/Data/Nat/Fib/Basic.lean
@[simp]
theorem fib_one : fib 1 = 1
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma cast_eq_self (a : Fin n) : cast rfl a = a
-- Mathlib/Data/Finsupp/Defs.lean
theorem not_mem_support_iff {f : α →₀ M} {a} : a ∉ f.support ↔ f a = 0
-- Mathlib/Data/Finsupp/Defs.lean
theorem mapRange_add' [AddZeroClass N] [FunLike β M N] [AddMonoidHomClass β M N]
    {f : β} (v₁ v₂ : α →₀ M) :
    mapRange f (map_zero f) (v₁ + v₂) = mapRange f (map_zero f) v₁ + mapRange f (map_zero f) v₂
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem isLUB_sSup (s : Set (WithTop α)) : IsLUB s (sSup s)
-- Mathlib/Data/ENNReal/Inv.lean
theorem div_lt_of_lt_mul (h : a < b * c) : a / c < b
-- Mathlib/CategoryTheory/Elements.lean
@[ext]
theorem ext (F : C ⥤ Type w) {x y : F.Elements} (f g : x ⟶ y) (w : f.val = g.val) : f = g
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem bmod_length (x : IntList) (m) : (bmod x m).length ≤ x.length
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem mk_d_2_0 : (mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 2 = d₁
-- Mathlib/Algebra/Group/Subgroup/Finite.lean
@[to_additive]
theorem pi_mem_of_mulSingle_mem [Finite η] [DecidableEq η] {H : Subgroup (∀ i, f i)} (x : ∀ i, f i)
    (h : ∀ i, Pi.mulSingle i (x i) ∈ H) : x ∈ H
-- Mathlib/RingTheory/Regular/RegularSequence.lean
@[simp]
lemma isWeaklyRegular_cons_iff (r : R) (rs : List R) :
    IsWeaklyRegular M (r :: rs) ↔
      IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs
-- Mathlib/Data/Set/Countable.lean
theorem countable_univ_pi {π : α → Type*} [Finite α] {s : ∀ a, Set (π a)}
    (hs : ∀ a, (s a).Countable) : (pi univ s).Countable
-- Mathlib/FieldTheory/RatFunc/Degree.lean
@[simp]
theorem intDegree_X : intDegree (X : RatFunc K) = 1
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem _root_.Int.addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle
-- Mathlib/Algebra/Order/Ring/Basic.lean
lemma pow_add_pow_le' (ha : 0 ≤ a) (hb : 0 ≤ b) : a ^ n + b ^ n ≤ 2 * (a + b) ^ n
-- Mathlib/Data/Set/Finite.lean
theorem exists_min_image [LinearOrder β] (s : Set α) (f : α → β) (h1 : s.Finite) :
    s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f a ≤ f b
-- Mathlib/Topology/Basic.lean
theorem IsClosed.compl_mem_nhds (hs : IsClosed s) (hx : x ∉ s) : sᶜ ∈ 𝓝 x
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem startPos : ∀ {s}, ValidFor l m r s → s.startPos = ⟨utf8Len l⟩
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem sum_mult_eq [NumberField K] :
    ∑ w : InfinitePlace K, mult w = FiniteDimensional.finrank ℚ K
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem lt_next (s : String) (i : Pos) : i.1 < (s.next i).1
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem mem_image_of_mem_range_restrict {r : β} {s : Set α} {f : α →ₛ β}
    (hr : r ∈ (restrict f s).range) (h0 : r ≠ 0) : r ∈ f '' s
-- Mathlib/Tactic/Positivity/Basic.lean
private lemma ite_nonneg_of_pos_of_nonneg [Preorder α] (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ ite p a b
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
/-- Given a ring filter basis on a commutative ring `R`, define a compatibility condition
on a family of submodules of an `R`-module `M`. This compatibility condition allows to get
a topological module structure. -/
structure RingFilterBasis.SubmodulesBasis (BR : RingFilterBasis R) (B : ι → Submodule R M) :
    Prop where
  /-- Condition for `B` to be a filter basis on `M`. -/
  inter : ∀ i j, ∃ k, B k ≤ B i ⊓ B j
  /-- For any element `m : M` and any set `B i` in the submodule basis on `M`,
    there is a `U` in the ring filter basis on `R` such that `U * m` is in `B i`. -/
  smul : ∀ (m : M) (i : ι), ∃ U ∈ BR, U ⊆ (· • m) ⁻¹' B i
-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean
lemma smoothSheaf.smooth_section {U : (Opens (TopCat.of M))ᵒᵖ}
    (f : (smoothSheaf IM I M N).presheaf.obj U) :
    Smooth IM I f
-- Mathlib/Data/Multiset/Basic.lean
theorem exists_multiset_eq_map_quot_mk {r : α → α → Prop} (s : Multiset (Quot r)) :
    ∃ t : Multiset α, s = t.map (Quot.mk r)