ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
theorem diagonalSucc_inv_single_left (g : G) (f : Gⁿ →₀ k) (r : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g r ⊗ₜ f) =
      Finsupp.lift (Gⁿ⁺¹ →₀ k) k Gⁿ (fun f => single (g • partialProd f) r) f
-- Mathlib/RingTheory/MvPowerSeries/Inverse.lean
@[simp]
theorem mul_invOfUnit (φ : MvPowerSeries σ R) (u : Rˣ) (h : constantCoeff σ R φ = u) :
    φ * invOfUnit φ u = 1
-- Mathlib/Algebra/Group/Semiconj/Units.lean
/-- If `a` semiconjugates a unit `x` to a unit `y`, then it semiconjugates `x⁻¹` to `y⁻¹`. -/
@[to_additive "If `a` semiconjugates an additive unit `x` to an additive unit `y`, then it
semiconjugates `-x` to `-y`."]
theorem units_inv_right {a : M} {x y : Mˣ} (h : SemiconjBy a x y) : SemiconjBy a ↑x⁻¹ ↑y⁻¹
-- Mathlib/Order/Hom/Basic.lean
protected theorem monotone (f : F) : Monotone f
-- Mathlib/SetTheory/Game/Basic.lean
theorem neg_mk_mul_moveLeft_inr {xl xr yl yr} {xL xR yL yR} {i j} :
    (-(mk xl xr xL xR * mk yl yr yL yR)).moveLeft (Sum.inr (i, j)) =
      -(xR i * mk yl yr yL yR + mk xl xr xL xR * yL j - xR i * yL j)
-- Mathlib/RingTheory/Jacobson.lean
theorem isMaximal_comap_C_of_isJacobson : (P.comap (C : R →+* R[X])).IsMaximal
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem num_one : num (1 : RatFunc K) = 1
-- Mathlib/Algebra/Star/Pi.lean
theorem update_star [∀ i, Star (f i)] [DecidableEq I] (h : ∀ i : I, f i) (i : I) (a : f i) :
    Function.update (star h) i (star a) = star (Function.update h i a)
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.card_compl [DecidableEq α] [Fintype α] (s : Finset α) :
    sᶜ.card = Fintype.card α - s.card
-- Mathlib/Data/Seq/WSeq.lean
theorem drop.aux_none : ∀ n, @drop.aux α n none = Computation.pure none
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem smul'_mk (r : R) (s : S) (m : M) : r • mk m s = mk (r • m) s
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_id' : ⇑(ContinuousAlgHom.id R A ) = _root_.id
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Three points are affinely independent if and only if they are not collinear. -/
theorem affineIndependent_iff_not_collinear_set {p₁ p₂ p₃ : P} :
    AffineIndependent k ![p₁, p₂, p₃] ↔ ¬Collinear k ({p₁, p₂, p₃} : Set P)
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
lemma nnreal_iff_spectralRadius_le [Algebra ℝ A] {a : A} {t : ℝ≥0} (ht : spectralRadius ℝ a ≤ t) :
    SpectrumRestricts a ContinuousMap.realToNNReal ↔
      spectralRadius ℝ (algebraMap ℝ A t - a) ≤ t
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_assoc {γ : Type*} {u : Finset γ} {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε}
    {g' : β → γ → ε'} (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    image₂ f (image₂ g s t) u = image₂ f' s (image₂ g' t u)
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem range_coprod [Module R₁ M₂] [Module R₁ M₃] [ContinuousAdd M₃] (f₁ : M₁ →L[R₁] M₃)
    (f₂ : M₂ →L[R₁] M₃) : range (f₁.coprod f₂) = range f₁ ⊔ range f₂
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioc_of_Icc (ha : Tendsto a l (𝓝 A)) (hb : Tendsto b l (𝓝 B)) :
    AECover (μ.restrict <| Ioc A B) l fun i => Icc (a i) (b i)
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
protected theorem coe_toBasis_repr_apply (b : OrthonormalBasis ι 𝕜 E) (x : E) (i : ι) :
    b.toBasis.repr x i = b.repr x i
-- Mathlib/MeasureTheory/Order/UpperLower.lean
theorem Set.OrdConnected.null_frontier (hs : s.OrdConnected) : volume (frontier s) = 0
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
lemma map_id_eq_isoClosure (P : MorphismProperty C) :
    P.map (𝟭 _) = P.isoClosure
-- Mathlib/Order/Filter/Basic.lean
@[simp]
protected theorem mem_sets : s ∈ f.sets ↔ s ∈ f
-- Mathlib/Data/Set/SMulAntidiagonal.lean
@[to_additive VAddAntidiagonal.eq_of_fst_eq_fst]
theorem eq_of_fst_eq_fst (h : (x : G × P).fst = (y : G × P).fst) : x = y
-- Mathlib/Order/CompleteLattice.lean
@[congr]
theorem iSup_congr_Prop {p q : Prop} {f₁ : p → α} {f₂ : q → α} (pq : p ↔ q)
    (f : ∀ x, f₁ (pq.mpr x) = f₂ x) : iSup f₁ = iSup f₂
-- Mathlib/RingTheory/RingHom/FinitePresentation.lean
/-- If `R` is a ring, then `Rᵣ` is `R`-finitely-presented for any `r : R`. -/
theorem finitePresentation_holdsForLocalizationAway :
    HoldsForLocalizationAway @FinitePresentation
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
theorem coverPreserving : CoverPreserving J (e.inverse.inducedTopology J) e.functor
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem tensorObj (X Y : C) : X ⊗ Y = (X ⨿ Y)
-- Mathlib/Data/List/Basic.lean
@[simp] theorem self_eq_append_left {x y : List α} : y = x ++ y ↔ x = []
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_subset_of_tendsto {m : τ → τ} {f₁ f₂ : Filter τ} (hf : Tendsto m f₁ f₂) :
    ω f₁ (fun t x ↦ ϕ (m t) x) s ⊆ ω f₂ ϕ s
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem map_biInf_comap {ι β} {I : Set ι} (hI : I.Nonempty) {f : α → β} (m : ι → OuterMeasure β) :
    map f (⨅ i ∈ I, comap f (m i)) = ⨅ i ∈ I, map f (comap f (m i))
-- Mathlib/Data/Set/Sups.lean
theorem Nonempty.of_sups_right : (s ⊻ t).Nonempty → t.Nonempty
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
/-- Auxiliary lemma for defining group cohomology, used to show that the isomorphism
`diagonalHomEquiv` commutes with the differentials in two complexes which compute
group cohomology. -/
theorem diagonalHomEquiv_symm_partialProd_succ (f : (Fin n → G) → A) (g : Fin (n + 1) → G)
    (a : Fin (n + 1)) :
    ((diagonalHomEquiv n A).symm f).hom (Finsupp.single (Fin.partialProd g ∘ a.succ.succAbove) 1)
      = f (Fin.contractNth a (· * ·) g)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem add_linear (f g : P1 →ᵃ[k] V2) : (f + g).linear = f.linear + g.linear
-- Mathlib/Algebra/Tropical/Basic.lean
theorem trop_eq_iff_eq_untrop {x : R} {y} : trop x = y ↔ x = untrop y
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Ioo_top (x : ℝ) : Real.toEReal ⁻¹' Ioo x ⊤ = Ioi x
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem factorial_succ (n : ℕ) : (n + 1)! = (n + 1) * n !
-- Mathlib/Condensed/Discrete.lean
/--
The underlying object of a condensed object in `C` is the condensed object evaluated at a point.
This can be viewed as a sort of forgetful functor from `Condensed C` to `C`
-/
@[simps!]
noncomputable def Condensed.underlying : Condensed.{u} C ⥤ C
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem MDifferentiableWithinAt.mul (hp : MDifferentiableWithinAt I 𝓘(𝕜, F') p s z)
    (hq : MDifferentiableWithinAt I 𝓘(𝕜, F') q s z) :
    MDifferentiableWithinAt I 𝓘(𝕜, F') (p * q) s z
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
/-- The 1-morphism `h` commutes with the left Kan extension `f⁺ g`. -/
@[simps!]
def lanCompIso : f⁺ (g ≫ h) ≅ f⁺ g ≫ h
-- Mathlib/Order/SupIndep.lean
/-- A variant of `CompleteLattice.independent_iff_supIndep` for `Fintype`s. -/
theorem CompleteLattice.independent_iff_supIndep_univ [CompleteLattice α] [Fintype ι] {f : ι → α} :
    CompleteLattice.Independent f ↔ Finset.univ.SupIndep f
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- Viewing a module as an affine space modelled on itself, a `weightedVSub` is just a linear
combination. -/
@[simp]
theorem weightedVSub_eq_linear_combination {ι} (s : Finset ι) {w : ι → k} {p : ι → V}
    (hw : s.sum w = 0) : s.weightedVSub p w = ∑ i ∈ s, w i • p i
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem underlyingIso_top_hom {B : C} : (underlyingIso (𝟙 B)).hom = (⊤ : Subobject B).arrow
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem iterate_derivative_eq_zero {p : R[X]} {x : ℕ} (hx : p.natDegree < x) :
    Polynomial.derivative^[x] p = 0
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem image_preimage (e : P₁ ≃ᵃL[k] P₂) (s : Set P₂) : e '' (e ⁻¹' s) = s
-- Mathlib/Order/Chain.lean
theorem succChain_spec (h : ∃ t, IsChain r s ∧ SuperChain r s t) :
    SuperChain r s (SuccChain r s)
-- Mathlib/NumberTheory/EulerProduct/Basic.lean
/-- If `f` is multiplicative and summable, then its values at natural numbers `> 1`
have norm strictly less than `1`. -/
lemma Summable.norm_lt_one {F : Type*} [NormedField F] [CompleteSpace F] {f : ℕ →* F}
    (hsum : Summable f) {p : ℕ} (hp : 1 < p) :
    ‖f p‖ < 1
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- A continuous image of a Lindelöf set is a Lindelöf set within the codomain. -/
theorem LindelofSpace.of_continuous_surjective {f : X → Y} [LindelofSpace X] (hf : Continuous f)
    (hsur : Function.Surjective f) : LindelofSpace Y
-- Mathlib/Logic/Basic.lean
theorem congr_heq {α β γ : Sort _} {f : α → γ} {g : β → γ} {x : α} {y : β}
    (h₁ : HEq f g) (h₂ : HEq x y) : f x = g y
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem smul_div_one {p : R} {r : X} {s : S} : (p /ₒ s) • (r /ₒ 1) = (p • r) /ₒ s
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.subset_extend (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : s ⊆ hs.extend hst
-- Mathlib/Data/Int/Defs.lean
lemma dvd_div_of_mul_dvd (h : a * b ∣ c) : b ∣ c / a
-- Mathlib/Data/Finset/Basic.lean
@[gcongr]
theorem inter_subset_inter_right (h : s ⊆ t) : s ∩ u ⊆ t ∩ u
-- Mathlib/Algebra/Algebra/Basic.lean
theorem algebraMap_ofSubsemiring_apply (S : Subsemiring R) (x : S) : algebraMap S R x = x
-- Mathlib/Data/DFinsupp/Basic.lean
theorem single_injective {i} : Function.Injective (single i : β i → Π₀ i, β i)
-- Mathlib/GroupTheory/Congruence/Basic.lean
@[to_additive]
theorem mem_coe {c : Con M} {x y} : (x, y) ∈ (↑c : Submonoid (M × M)) ↔ (x, y) ∈ c
-- Mathlib/Data/Nat/Find.lean
theorem findGreatest_of_ne_zero (h : Nat.findGreatest P n = m) (h0 : m ≠ 0) : P m
-- Mathlib/Algebra/Lie/Engel.lean
theorem LieAlgebra.exists_engelian_lieSubalgebra_of_lt_normalizer {K : LieSubalgebra R L}
    (hK₁ : LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K) (hK₂ : K < K.normalizer) :
    ∃ (K' : LieSubalgebra R L), LieAlgebra.IsEngelian.{u₁, u₂, u₄} R K' ∧ K < K'
-- Mathlib/RepresentationTheory/Invariants.lean
/-- `average k G` is invariant under right multiplication by elements of `G`.
-/
@[simp]
theorem mul_average_right (g : G) : average k G * ↑(Finsupp.single g 1) = average k G
-- Mathlib/Data/Matrix/Invertible.lean
/-- A copy of `mul_invOf_mul_self_cancel` for rectangular matrices. -/
protected theorem mul_invOf_mul_self_cancel (A : Matrix m n α) (B : Matrix n n α) [Invertible B] :
    A * ⅟ B * B = A
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
@[simp]
theorem range_cos : Set.range cos = Set.univ
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem trop_iInf [ConditionallyCompleteLinearOrder R] [Fintype S] (f : S → WithTop R) :
    trop (⨅ i : S, f i) = ∑ i : S, trop (f i)
-- Mathlib/Order/Hom/Basic.lean
theorem symm_bijective : Function.Bijective (OrderIso.symm : (α ≃o β) → β ≃o α)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
/-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd)
-- Mathlib/Data/Rat/Defs.lean
@[simp, nolint simpNF, norm_cast] lemma natCast_inj {m n : ℕ} : (m : ℚ) = n ↔ m = n
-- Mathlib/Topology/Maps/Basic.lean
theorem _root_.closedEmbedding_of_continuous_injective_closed (h₁ : Continuous f) (h₂ : Injective f)
    (h₃ : IsClosedMap f) : ClosedEmbedding f
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem PartialHomeomorph.contDiffOn_univUnitBall_symm :
    ContDiffOn ℝ n univUnitBall.symm (ball (0 : E) 1)
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem basisDivisor_add_symm {x y : F} (hxy : x ≠ y) :
    basisDivisor x y + basisDivisor y x = 1
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem refl_trans : (refl R M).trans e = e
-- Mathlib/AlgebraicGeometry/Modules/Tilde.lean
@[simp]
theorem isLocallyFraction_pred {U : Opens (PrimeSpectrum.Top R)}
    (f : ∀ x : U, Localizations M x) :
    (isLocallyFraction M).pred f =
      ∀ y : U,
        ∃ (V : _) (_ : y.1 ∈ V) (i : V ⟶ U),
          ∃ (m : M) (s: R), ∀ x : V, ¬s ∈ x.1.asIdeal ∧ s • f (i x) =
            LocalizedModule.mkLinearMap x.1.asIdeal.primeCompl M m
-- Mathlib/NumberTheory/Padics/PadicVal.lean
lemma Nat.max_log_padicValNat_succ_eq_log_succ (n : ℕ) :
    max (log 2 n) (padicValNat 2 (n + 1)) = log 2 (n + 1)
-- Mathlib/NumberTheory/MulChar/Basic.lean
lemma eq_one_iff {χ : MulChar R R'} : χ = 1 ↔ ∀ a : Rˣ, χ a = 1
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
/-- Clique-freeness is preserved by `replaceVertex`. -/
protected theorem CliqueFree.replaceVertex [DecidableEq α] (h : G.CliqueFree n) (s t : α) :
    (G.replaceVertex s t).CliqueFree n
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformEmbedding_inl : UniformEmbedding (Sum.inl : α → α ⊕ β)
-- Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean
@[simp]
theorem forget₂_obj (X : QuadraticModuleCat R) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).obj X = ModuleCat.of R X
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Ioc : (Ioc a b).Nonempty ↔ a < b
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[simp, nolint simpNF]
theorem homEquiv_apply_eq (f : A ⊗ Y ⟶ X) : (ihom.adjunction A).homEquiv _ _ f = curry f
-- Mathlib/Order/SupIndep.lean
theorem CompleteLattice.independent_iff_supIndep [CompleteLattice α] {s : Finset ι} {f : ι → α} :
    CompleteLattice.Independent (f ∘ ((↑) : s → ι)) ↔ s.SupIndep f
-- Mathlib/Data/FunLike/Basic.lean
theorem ne_iff {f g : F} : f ≠ g ↔ ∃ a, f a ≠ g a
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma IsUnramified.eq (h : IsUnramified k w) : mult (w.comap (algebraMap k K)) = mult w
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem contMDiffOn_coordChangeL :
    ContMDiffOn IB 𝓘(𝕜, F →L[𝕜] F) n (fun b : B => (e.coordChangeL 𝕜 e' b : F →L[𝕜] F))
      (e.baseSet ∩ e'.baseSet)
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
/-- Every presheaf is a sheaf for the regular topology if every object of `C` is projective. -/
theorem isSheaf_of_projective (F : Cᵒᵖ ⥤ D) [Preregular C] [∀ (X : C), Projective X] :
    Presheaf.IsSheaf (regularTopology C) F
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
@[simp]
theorem mod_zero (a : R) : a % 0 = a
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMono.mapsTo_Ico (h : StrictMono f) : MapsTo f (Ico a b) (Ico (f a) (f b))
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive]
theorem Right.pow_lt_one_iff [CovariantClass M M (swap (· * ·)) (· < ·)] {n : ℕ} {x : M}
    (hn : 0 < n) : x ^ n < 1 ↔ x < 1
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem nnnorm_neg (f : Lp E p μ) : ‖-f‖₊ = ‖f‖₊
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_congr' (hs : EqOn f₁ f s) (hx : x ∈ s) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x
-- Mathlib/Data/Finset/Option.lean
lemma none_mem_insertNone {s : Finset α} : none ∈ insertNone s
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma leftRightHomologyComparison'_eq_liftH :
    leftRightHomologyComparison' h₁ h₂ =
      h₂.liftH (h₁.descH (h₁.i ≫ h₂.p) (by simp))
        (by rw [← cancel_epi h₁.π, LeftHomologyData.π_descH_assoc, assoc,
          RightHomologyData.p_g', LeftHomologyData.wi, comp_zero])
-- Mathlib/Order/Filter/CountableInter.lean
theorem le_countableGenerate_iff_of_countableInterFilter {f : Filter α} [CountableInterFilter f] :
    f ≤ countableGenerate g ↔ g ⊆ f.sets
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem tendsto_eval_ae_ae {i : ι} : Tendsto (eval i) (ae (Measure.pi μ)) (ae (μ i))
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem nontrivial_iff_ne_bot (H : Subgroup G) : Nontrivial H ↔ H ≠ ⊥
-- Mathlib/CategoryTheory/Generator.lean
theorem IsCoseparator.def {G : C} :
    IsCoseparator G → ∀ ⦃X Y : C⦄ (f g : X ⟶ Y), (∀ h : Y ⟶ G, f ≫ h = g ≫ h) → f = g
-- Mathlib/RingTheory/Localization/Submodule.lean
@[simp]
theorem coeSubmodule_span (s : Set R) :
    coeSubmodule S (Ideal.span s) = Submodule.span R (algebraMap R S '' s)
-- Mathlib/LinearAlgebra/FreeModule/PID.lean
/-- Given a Smith-normal-form pair of bases for `N ⊆ M`, and a linear endomorphism `f` of `M`
that preserves `N`, the diagonal of the matrix of the restriction `f` to `N` does not depend on
which of the two bases for `N` is used. -/
@[simp]
lemma toMatrix_restrict_eq_toMatrix [Fintype ι] [DecidableEq ι]
    (f : M →ₗ[R] M) (hf : ∀ x, f x ∈ N) (hf' : ∀ x ∈ N, f x ∈ N := fun x _ ↦ hf x) {i : Fin n} :
    LinearMap.toMatrix snf.bN snf.bN (LinearMap.restrict f hf') i i =
    LinearMap.toMatrix snf.bM snf.bM f (snf.f i) (snf.f i)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem IsCycle.cycleType {σ : Perm α} (hσ : IsCycle σ) : σ.cycleType = [σ.support.card]
-- Mathlib/Order/MinMax.lean
@[simp]
theorem max_le_iff : max a b ≤ c ↔ a ≤ c ∧ b ≤ c
-- Mathlib/Combinatorics/Colex.lean
/-- For finsets of naturals, the colexicographic order is equivalent to the order induced by the
`n`-ary expansion. -/
lemma geomSum_lt_geomSum_iff_toColex_lt_toColex (hn : 2 ≤ n) :
    ∑ i ∈ s, n ^ i < ∑ i ∈ t, n ^ i ↔ toColex s < toColex t
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem bmod_sat (m : Nat) (r : Int) (i : Nat) (x v : Coeffs)
    (h : x.length ≤ i)  -- during proof reconstruction this will be by `decide`
    (p : Coeffs.get v i = bmod_div_term m x v) -- and this will be by `rfl`
    (w : (Constraint.exact r).sat' x v) :
    (Constraint.exact (Int.bmod r m)).sat' (bmod_coeffs m i x) v
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem ofRealCLM_apply (x : ℝ) : ofRealCLM x = x
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem smul_eq_C_smul (x : RatFunc K) (r : K) : r • x = Polynomial.C r • x
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem neg_eq_self [Ring R] [AddCommGroup M] [Module R M] (p : Submodule R M) : -p = p
-- Mathlib/Data/DFinsupp/Lex.lean
/-- The less-than relation for the lexicographic ordering is decidable. -/
irreducible_def Lex.decidableLT : @DecidableRel (Lex (Π₀ i, α i)) (· < ·)
-- Mathlib/RingTheory/HahnSeries/PowerSeries.lean
/-- Casting a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`
  is an algebra homomorphism. -/
@[simps!]
def ofPowerSeriesAlg : PowerSeries A →ₐ[R] HahnSeries Γ A
-- Mathlib/Analysis/Seminorm.lean
theorem norm_sub_map_le_sub (p : Seminorm 𝕜 E) (x y : E) : ‖p x - p y‖ ≤ p (x - y)
-- Mathlib/Combinatorics/Colex.lean
lemma toColex_image_ofColex_strictMono (hf : StrictMono f) :
    StrictMono fun s ↦ toColex <| image f <| ofColex s
-- Mathlib/Order/LiminfLimsup.lean
/-- A bounded above function `u` is in particular eventually bounded above. -/
lemma _root_.BddAbove.isBoundedUnder [Preorder α] {f : Filter β} {u : β → α} :
    BddAbove (Set.range u) → f.IsBoundedUnder (· ≤ ·) u
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.homogeneousCore_mono : Monotone (Ideal.homogeneousCore 𝒜)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
/-- Bundle `cfc f a` into a unit given a proof that `f` is nonzero on the spectrum of `a`. -/
@[simps]
noncomputable def cfcUnits (hf' : ∀ x ∈ spectrum R a, f x ≠ 0)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) (ha : p a := by cfc_tac) : Aˣ
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem bsup_one (f : ∀ a < (1 : Ordinal), Ordinal) : bsup 1 f = f 0 zero_lt_one
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem map_induction (as : Array α) (f : α → β) (motive : Nat → Prop) (h0 : motive 0)
    (p : Fin as.size → β → Prop) (hs : ∀ i, motive i.1 → p i (f as[i]) ∧ motive (i+1)) :
    motive as.size ∧
      ∃ eq : (as.map f).size = as.size, ∀ i h, p ⟨i, h⟩ ((as.map f)[i])
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean
theorem hexagon_forward (X Y Z : C) :
    (BinaryFan.associatorOfLimitCone ℬ X Y Z).hom ≫
        (Limits.BinaryFan.braiding (ℬ X (tensorObj ℬ Y Z)).isLimit
              (ℬ (tensorObj ℬ Y Z) X).isLimit).hom ≫
          (BinaryFan.associatorOfLimitCone ℬ Y Z X).hom =
      tensorHom ℬ (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom (𝟙 Z) ≫
        (BinaryFan.associatorOfLimitCone ℬ Y X Z).hom ≫
          tensorHom ℬ (𝟙 Y) (Limits.BinaryFan.braiding (ℬ X Z).isLimit (ℬ Z X).isLimit).hom
-- Mathlib/Data/List/Sigma.lean
theorem map_dlookup_eq_find (a : α) :
    ∀ l : List (Sigma β), (dlookup a l).map (Sigma.mk a) = find? (fun s => a = s.1) l
-- Mathlib/Order/Interval/Finset/Nat.lean
@[simp]
theorem card_Ico : (Ico a b).card = b - a
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem matrixOfPolynomials_blockTriangular {n : ℕ} (p : Fin n → R[X])
    (h_deg : ∀ i, (p i).natDegree ≤ i) :
    Matrix.BlockTriangular (Matrix.of (fun (i j : Fin n) => (p j).coeff i)) id
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem HasEigenvalue.mem_spectrum {f : End R M} {μ : R} (hμ : HasEigenvalue f μ) :
    μ ∈ spectrum R f
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivAt.unique (h₀ : HasDerivAt f f₀' x) (h₁ : HasDerivAt f f₁' x) : f₀' = f₁'
-- Mathlib/Order/Circular.lean
theorem sbtw_irrefl_left {a b : α} : ¬sbtw a a b
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem first_num_eq {gp : Pair K} (zeroth_s_eq : g.s.get? 0 = some gp) :
    g.nums 1 = gp.b * g.h + gp.a
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- A groupoid is closed under restriction if and only if it contains the trivial restriction-closed
groupoid. -/
theorem closedUnderRestriction_iff_id_le (G : StructureGroupoid H) :
    ClosedUnderRestriction G ↔ idRestrGroupoid ≤ G
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem support_subtypeDomain [D : DecidablePred p] {f : α →₀ M} :
    (subtypeDomain p f).support = f.support.subtype p
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem coe_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) :
    (vanishingIdeal t : Set A) =
      { f | ∀ x : ProjectiveSpectrum 𝒜, x ∈ t → f ∈ x.asHomogeneousIdeal }
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive sum_nonpos]
theorem prod_le_one' (h : ∀ i ∈ s, f i ≤ 1) : ∏ i ∈ s, f i ≤ 1
-- Mathlib/Data/Matrix/Basis.lean
theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
    x = ∑ i : m, ∑ j : n, stdBasisMatrix i j (x i j)
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem sigmaFinsuppEquivDFinsupp_support [DecidableEq ι] [Zero N]
    [∀ (i : ι) (x : η i →₀ N), Decidable (x ≠ 0)] (f : (Σi, η i) →₀ N) :
    (sigmaFinsuppEquivDFinsupp f).support = Finsupp.splitSupport f
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
@[simp]
theorem xInTermsOfW_zero [Invertible (p : R)] : xInTermsOfW p R 0 = X 0
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ico_filter_le_of_left_le {a b c : α} [DecidablePred (c ≤ ·)] (hac : a ≤ c) :
    (Ico a b).filter (c ≤ ·) = Ico c b
-- Mathlib/Topology/MetricSpace/ShrinkingLemma.lean
/-- Shrinking lemma for coverings by open balls in a proper metric space. A point-finite open cover
of a proper metric space by open balls can be shrunk to a new cover by open balls so that each of
the new balls has strictly smaller radius than the old one. -/
theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)
    (uU : ⋃ i, ball (c i) (r i) = univ) :
    ∃ r' : ι → ℝ, ⋃ i, ball (c i) (r' i) = univ ∧ ∀ i, r' i < r i
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem setSeq_sub_aux (n : ℕ) : setSeq hf U_mem n ⊆ setSeqAux hf U_mem n
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem mem_ball_symmetry {V : Set (β × β)} (hV : SymmetricRel V) {x y} :
    x ∈ ball y V ↔ y ∈ ball x V
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma RightHomologyData.exact_iff [S.HasHomology]
    (h : S.RightHomologyData) :
    S.Exact ↔ IsZero h.H
-- Mathlib/NumberTheory/LSeries/HurwitzZeta.lean
lemma hurwitzZetaEven_eq (a : UnitAddCircle) (s : ℂ) :
    hurwitzZetaEven a s = (hurwitzZeta a s + hurwitzZeta (-a) s) / 2