ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem cocompact_le_atBot [OrderTop α] [CompactIccSpace α] :
    cocompact α ≤ atBot
-- Mathlib/Logic/Basic.lean
@[simp] theorem xor_not_left : Xor' (¬a) b ↔ (a ↔ b)
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
/-- A continuous linear map is zero iff its norm vanishes. -/
theorem opNorm_zero_iff : ‖f‖ = 0 ↔ f = 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem nil_merge (s : α → α → Bool) (r) : merge s [] r = r
-- Mathlib/RingTheory/DiscreteValuationRing/TFAE.lean
/--
Let `(R, m, k)` be a noetherian local domain (possibly a field).
The following are equivalent:
0. `R` is a PID
1. `R` is a valuation ring
2. `R` is a dedekind domain
3. `R` is integrally closed with at most one non-zero prime ideal
4. `m` is principal
5. `dimₖ m/m² ≤ 1`
6. Every nonzero ideal is a power of `m`.

Also see `DiscreteValuationRing.TFAE` for a version assuming `¬ IsField R`.
-/
theorem tfae_of_isNoetherianRing_of_localRing_of_isDomain
    [IsNoetherianRing R] [LocalRing R] [IsDomain R] :
    List.TFAE
      [IsPrincipalIdealRing R, ValuationRing R, IsDedekindDomain R,
        IsIntegrallyClosed R ∧ ∀ P : Ideal R, P ≠ ⊥ → P.IsPrime → P = maximalIdeal R,
        (maximalIdeal R).IsPrincipal,
        finrank (ResidueField R) (CotangentSpace R) ≤ 1,
        ∀ (I) (_ : I ≠ ⊥), ∃ n : ℕ, I = maximalIdeal R ^ n]
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_lt_opow_left_of_succ {a b c : Ordinal} (ab : a < b) : a ^ succ c < b ^ succ c
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive add_const]
theorem StrictAntiOn.mul_const' (hf : StrictAntiOn f s) (c : α) :
    StrictAntiOn (fun x => f x * c) s
-- Mathlib/GroupTheory/Subgroup/Saturated.lean
@[to_additive]
theorem saturated_iff_npow {H : Subgroup G} :
    Saturated H ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma opcyclesMap'_eq : opcyclesMap' φ h₁ h₂ = γ.φQ
-- Mathlib/Data/Real/Sign.lean
@[simp]
theorem sign_inv (r : ℝ) : sign r⁻¹ = sign r
-- Mathlib/Data/Real/Irrational.lean
theorem of_div_int (m : ℤ) (h : Irrational (x / m)) : Irrational x
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- Variant of the previous result with the variable expressed as `y` instead of `x + y`. -/
theorem HasFiniteFPowerSeriesOnBall.eq_partialSum'
    (hf : HasFiniteFPowerSeriesOnBall f p x n r) :
    ∀ y ∈ EMetric.ball x r, ∀ m, n ≤ m →
    f y = p.partialSum m (y - x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem toReal_eq_neg_pi_div_two_iff {θ : Angle} : θ.toReal = -π / 2 ↔ θ = (-π / 2 : ℝ)
-- Mathlib/ModelTheory/LanguageMap.lean
@[ext]
protected theorem funext {F G : L →ᴸ L'} (h_fun : F.onFunction = G.onFunction)
    (h_rel : F.onRelation = G.onRelation) : F = G
-- Mathlib/Order/CompleteSublattice.lean
protected lemma codisjoint_iff {a b : L} :
    Codisjoint a b ↔ Codisjoint (a : α) (b : α)
-- Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
/-- If `m : ℕ` is coprime with `n`,
then the minimal polynomials of a primitive `n`-th root of unity `μ`
and of `μ ^ m` are the same. -/
theorem minpoly_eq_pow_coprime {m : ℕ} (hcop : Nat.Coprime m n) :
    minpoly ℤ μ = minpoly ℤ (μ ^ m)
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[ext]
lemma hom_ext₂ {f g : ComposableArrows C 2} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2) :
    φ = φ'
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp]
lemma mk₀_id_comp (α : Ext X Y n) :
    (mk₀ (𝟙 X)).comp α (zero_add n) = α
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem cycleRange_succAbove {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :
    i.cycleRange (i.succAbove j) = j.succ
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
lemma mul_scaleRoots' (p q : R[X]) (r : R) (h : leadingCoeff p * leadingCoeff q ≠ 0) :
    (p * q).scaleRoots r = p.scaleRoots r * q.scaleRoots r
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem finiteType : Algebra.FiniteType R (AdjoinRoot f)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_lt_of_translationNumber_lt_int {n : ℤ} (h : τ f < n) (x : ℝ) : f x < x + n
-- Mathlib/Topology/Sets/Closeds.lean
/-- `TopologicalSpace.Opens.compl` as an `OrderIso` to the order dual of
`TopologicalSpace.Closeds α`. -/
@[simps]
def Opens.complOrderIso : Opens α ≃o (Closeds α)ᵒᵈ
-- Mathlib/Topology/OmegaCompletePartialOrder.lean
theorem continuous_of_scottContinuous {α β} [OmegaCompletePartialOrder α]
    [OmegaCompletePartialOrder β] (f : Scott α → Scott β)
    (hf : OmegaCompletePartialOrder.Continuous' f) : Continuous f
-- Mathlib/Computability/TuringMachine.lean
theorem stmts₁_trans {q₁ q₂ : Stmt₁} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂
-- Mathlib/Algebra/Polynomial/Bivariate.lean
lemma coe_algebraMap_eq_CC : algebraMap R R[X][Y] = CC (R := R)
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem cancel_left {g : β →+* γ} {f₁ f₂ : α →+* β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Computability/Primrec.lean
theorem option_iget [Inhabited α] : Primrec (@Option.iget α _)
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem mem_jacobson_bot {x : R} : x ∈ jacobson (⊥ : Ideal R) ↔ ∀ y, IsUnit (x * y + 1)
-- Mathlib/Algebra/Lie/TraceForm.lean
@[simp] lemma le_killingCompl_top_of_isLieAbelian [IsLieAbelian I] :
    I ≤ LieIdeal.killingCompl R L ⊤
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- The preimage of a set `s` under a continuous linear map `f` with nonzero determinant has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. -/
@[simp]
theorem addHaar_preimage_continuousLinearMap {f : E →L[ℝ] E}
    (hf : LinearMap.det (f : E →ₗ[ℝ] E) ≠ 0) (s : Set E) :
    μ (f ⁻¹' s) = ENNReal.ofReal (abs (LinearMap.det (f : E →ₗ[ℝ] E))⁻¹) * μ s
-- Mathlib/Computability/Partrec.lean
protected theorem encode : Computable (@encode α _)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_add_single : monomial (s + Finsupp.single n e) a = monomial s a * X n ^ e
-- Mathlib/LinearAlgebra/Ray.lean
/-- The rays given by two nonzero vectors are equal if and only if those vectors
satisfy `SameRay`. -/
theorem ray_eq_iff {v₁ v₂ : M} (hv₁ : v₁ ≠ 0) (hv₂ : v₂ ≠ 0) :
    rayOfNeZero R _ hv₁ = rayOfNeZero R _ hv₂ ↔ SameRay R v₁ v₂
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
theorem whiskeringLeft_obj_preimage_app {F G : Karoubi C ⥤ D}
    (τ : toKaroubi _ ⋙ F ⟶ toKaroubi _ ⋙ G) (P : Karoubi C) :
    (((whiskeringLeft _ _ _).obj (toKaroubi _)).preimage τ).app P =
      F.map P.decompId_i ≫ τ.app P.X ≫ G.map P.decompId_p
-- Mathlib/Analysis/Convex/Gauge.lean
theorem le_gauge_of_subset_closedBall (hs : Absorbent ℝ s) (hr : 0 ≤ r) (hsr : s ⊆ closedBall 0 r) :
    ‖x‖ / r ≤ gauge s x
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
@[simp] theorem trunc_trunc_mul {n} (f g : R ⟦X⟧) :
    trunc n ((trunc n f) * g : R⟦X⟧) = trunc n (f * g)
-- Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean
theorem balancedCoreAux_subset (s : Set E) : balancedCoreAux 𝕜 s ⊆ s
-- Mathlib/Topology/Algebra/Constructions/DomMulAct.lean
@[to_additive] theorem embedding_mk_symm : Embedding (@mk M).symm
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem nsmul_comp (n : ℕ) : (n • f) ≫ g = n • f ≫ g
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
lemma isEquivalence_left_of_isEquivalence_right (h : L ⊣ R) [R.IsEquivalence] : L.IsEquivalence
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive]
theorem CancelCommMonoid.toCommMonoid_injective {M : Type u} :
    Function.Injective (@CancelCommMonoid.toCommMonoid M)
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_mrange (g : N →* P) (f : M →* N) : f.mrange.map g = mrange (comp g f)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem erase_zero (a : α) : (0 : Multiset α).erase a = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem range_cos : range cos = (Icc (-1) 1 : Set ℝ)
-- Mathlib/Data/Multiset/Basic.lean
/-- This is a special case of `tsub_le_iff_right`, which should be used instead of this.
  This is needed to prove `OrderedSub (Multiset α)`. -/
protected theorem sub_le_iff_le_add : s - t ≤ u ↔ s ≤ u + t
-- Mathlib/RingTheory/Localization/AtPrime.lean
theorem le_comap_primeCompl_iff {J : Ideal P} [hJ : J.IsPrime] {f : R →+* P} :
    I.primeCompl ≤ J.primeCompl.comap f ↔ J.comap f ≤ I
-- Mathlib/Order/Monotone/Monovary.lean
@[simp]
theorem monovaryOn_id_iff : MonovaryOn f id s ↔ MonotoneOn f s
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp]
theorem add_eq_top : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast] theorem coe_eq_zero : (↑r : ℝ≥0∞) = 0 ↔ r = 0
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem measurePreserving_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· * g) μ μ
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.bddBelow_range [Preorder β] [IsDirected β (· ≥ ·)] {f : ℕ → β}
    (hf : IsBoundedUnder (· ≥ ·) atTop f) : BddBelow (range f)
-- Mathlib/RingTheory/FreeCommRing.lean
theorem exists_finset_support (x : FreeCommRing α) : ∃ s : Finset α, IsSupported x ↑s
-- Mathlib/RingTheory/FiniteType.lean
/-- A theorem by Vasconcelos, given a finite module `M` over a commutative ring, any
surjective endomorphism of `M` is also injective.
It is a consequence of the fact `CommRing.orzechProperty`
that any commutative ring `R` satisfies the `OrzechProperty`;
please use `OrzechProperty.injective_of_surjective_endomorphism` instead.
This is similar to `IsNoetherian.injective_of_surjective_endomorphism` but only applies in the
commutative case, but does not use a Noetherian hypothesis. -/
@[deprecated OrzechProperty.injective_of_surjective_endomorphism (since := "2024-05-30")]
theorem Module.Finite.injective_of_surjective_endomorphism {R : Type*} [CommRing R] {M : Type*}
    [AddCommGroup M] [Module R M] [Finite R M] (f : M →ₗ[R] M)
    (f_surj : Function.Surjective f) : Function.Injective f
-- Mathlib/Data/Set/Lattice.lean
theorem _root_.Monotone.iUnion_nat_add {f : ℕ → Set α} (hf : Monotone f) (k : ℕ) :
    ⋃ n, f (n + k) = ⋃ n, f n
-- Mathlib/Data/Int/CardIntervalMod.lean
/-- There are `⌈b / r⌉ - ⌈a / r⌉` multiples of `r` in `[a, b)`, if `a ≤ b`. -/
theorem Ico_filter_dvd_card : ((Ico a b).filter (r ∣ ·)).card =
    max (⌈b / (r : ℚ)⌉ - ⌈a / (r : ℚ)⌉) 0
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem comp_mul_left (hf : IntervalIntegrable f volume a b) (c : ℝ) :
    IntervalIntegrable (fun x => f (c * x)) volume (a / c) (b / c)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- A linear isometry preserves the property of being orthonormal. -/
theorem Orthonormal.comp_linearIsometry {v : ι → E} (hv : Orthonormal 𝕜 v) (f : E →ₗᵢ[𝕜] E') :
    Orthonormal 𝕜 (f ∘ v)
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
lemma Pi.map'_comp_map' {f : α → C} {g : β → C} {h : γ → C} [HasProduct f] [HasProduct g]
    [HasProduct h] (p : β → α) (p' : γ → β) (q : ∀ (b : β), f (p b) ⟶ g b)
    (q' : ∀ (c : γ), g (p' c) ⟶ h c) :
    Pi.map' p q ≫ Pi.map' p' q' = Pi.map' (p ∘ p') (fun c => q (p' c) ≫ q' c)
-- Mathlib/Analysis/InnerProductSpace/NormPow.lean
theorem contDiff_norm_rpow {p : ℝ} (hp : 1 < p) : ContDiff ℝ 1 (fun x : E ↦ ‖x‖ ^ p)
-- Mathlib/Analysis/Convex/StrictConvexBetween.lean
theorem Sbtw.dist_lt_max_dist (p : P) {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) :
    dist p₂ p < max (dist p₁ p) (dist p₃ p)
-- Mathlib/Data/Finset/Sups.lean
theorem card_infs_le : (s ⊼ t).card ≤ s.card * t.card
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
@[fun_prop]
protected theorem DifferentiableWithinAt.iterate {f : E → E} (hf : DifferentiableWithinAt 𝕜 f s x)
    (hx : f x = x) (hs : MapsTo f s s) (n : ℕ) : DifferentiableWithinAt 𝕜 f^[n] s x
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bodd_subNatNat (m n : ℕ) : bodd (subNatNat m n) = xor m.bodd n.bodd
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem toEquiv_injective : Injective (toEquiv : (P₁ ≃ᵃ[k] P₂) → P₁ ≃ P₂)
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
/-- An open null set w.r.t. an `IsOpenPosMeasure` is empty. -/
theorem _root_.IsOpen.eq_empty_of_measure_zero (hU : IsOpen U) (h₀ : μ U = 0) : U = ∅
-- Mathlib/RingTheory/Perfection.lean
theorem valAux_eq {f : PreTilt K v O hv p} {n : ℕ} (hfn : coeff _ _ n f ≠ 0) :
    valAux K v O hv p f = ModP.preVal K v O hv p (coeff _ _ n f) ^ p ^ n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem neg_lt_sub_left_of_lt_add {a b c : Int} (h : c < a + b) : -a < b - c
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem and_twoPow_eq (x : BitVec w) (i : Nat) :
    x &&& (twoPow w i) = if x.getLsb i then twoPow w i else 0#w
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
/-- The composition of homology map data. -/
@[simps]
def comp {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃} {h₁ : S₁.HomologyData}
    {h₂ : S₂.HomologyData} {h₃ : S₃.HomologyData}
    (ψ : HomologyMapData φ h₁ h₂) (ψ' : HomologyMapData φ' h₂ h₃) :
    HomologyMapData (φ ≫ φ') h₁ h₃
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem pow (H : IsRelPrime x y) : IsRelPrime (x ^ m) (y ^ n)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
/-- The cokernel of a zero morphism is an isomorphism -/
theorem cokernel.π_of_zero : IsIso (cokernel.π (0 : X ⟶ Y))
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
theorem apply_mem_neighborSet {v w : V} (h : w ∈ G.neighborSet v) : f w ∈ G'.neighborSet (f v)
-- Mathlib/Data/Set/Defs.lean
lemma seq_eq_image2 (s : Set (α → β)) (t : Set α) : seq s t = image2 (fun f a ↦ f a) s t
-- Mathlib/Data/Set/Prod.lean
theorem eval_preimage' [DecidableEq ι] {s : Set (α i)} :
    eval i ⁻¹' s = pi {i} (update (fun i => univ) i s)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem tail?_cons : @tail? α (a::l) = some l
-- Mathlib/CategoryTheory/Monoidal/FunctorCategory.lean
@[simp]
theorem rightUnitor_inv_app {F : C ⥤ D} {X} :
    ((ρ_ F).inv : F ⟶ F ⊗ 𝟙_ _).app X = (ρ_ (F.obj X)).inv
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma units_inf (S T : Submonoid M) : (S ⊓ T).units = S.units ⊓ T.units
-- Mathlib/Order/Partition/Finpartition.lean
lemma eq_of_mem_parts (ht : t ∈ P.parts) (hu : u ∈ P.parts) (hat : a ∈ t) (hau : a ∈ u) : t = u
-- Mathlib/Data/List/Indexes.lean
theorem mapIdx_append_one : ∀ (f : ℕ → α → β) (l : List α) (e : α),
    mapIdx f (l ++ [e]) = mapIdx f l ++ [f l.length e]
-- Mathlib/Data/Set/Semiring.lean
@[simp]
theorem down_mul (s t : SetSemiring α) : down (s * t) = down s * down t
-- Mathlib/Algebra/Order/AbsoluteValue.lean
/-- Convert an unbundled `IsAbsoluteValue` to a bundled `AbsoluteValue`. -/
@[simps]
def toAbsoluteValue : AbsoluteValue R S
-- Mathlib/Order/Interval/Set/Image.lean
lemma directedOn_le_Iic (b : α) : DirectedOn (· ≤ ·) (Iic b)
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem comp_symmCompOfNondegenerate_apply (B₁ : BilinForm K V) {B₂ : BilinForm K V}
    (b₂ : B₂.Nondegenerate) (v : V) :
    B₂ (B₁.symmCompOfNondegenerate B₂ b₂ v) = B₁ v
-- Mathlib/RepresentationTheory/GroupCohomology/Basic.lean
/-- The theorem that our isomorphism `Fun(Gⁿ, A) ≅ Hom(k[Gⁿ⁺¹], A)` (where the righthand side is
morphisms in `Rep k G`) commutes with the differentials in the complex of inhomogeneous cochains
and the homogeneous `linearYonedaObjResolution`. -/
@[nolint checkType] theorem d_eq :
    d n A =
      (diagonalHomEquiv n A).toModuleIso.inv ≫
        (linearYonedaObjResolution A).d n (n + 1) ≫
          (diagonalHomEquiv (n + 1) A).toModuleIso.hom
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp]
theorem linearEquivAt_apply (e : Trivialization F (π F E)) [e.IsLinear R] (b : B)
    (hb : b ∈ e.baseSet) (v : E b) : e.linearEquivAt R b hb v = (e ⟨b, v⟩).2
-- Mathlib/Computability/Partrec.lean
theorem rfindOpt {f : α → ℕ → Option σ} (hf : Computable₂ f) :
    Partrec fun a => Nat.rfindOpt (f a)
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_subtype (s : Set β) (f : β → α) : ∏' x : s, f x = ∏' x, s.mulIndicator f x
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_eq {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] :
    type r = type s ↔ Nonempty (r ≃r s)
-- Mathlib/Topology/Basic.lean
theorem Filter.EventuallyEq.continuousAt (h : f =ᶠ[𝓝 x] fun _ => y) :
    ContinuousAt f x
-- Mathlib/Topology/Order/OrderClosed.lean
protected lemma BddAbove.of_closure : BddAbove (closure s) → BddAbove s
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
lemma inv_op_smul_finset_distrib (a : α) (s : Finset α) : (op a • s)⁻¹ = a⁻¹ • s⁻¹
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem infix_cons : l₁ <:+: l₂ → l₁ <:+: a :: l₂
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp) card_nsmul_eq_zero]
theorem pow_card_eq_one : x ^ Fintype.card G = 1
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
theorem summable_apply [AddCommMonoid β] [ContinuousAdd β] {γ : Type*} {f : γ → C(α, β)}
    (hf : Summable f) (x : α) : Summable fun i : γ => f i x
-- Mathlib/Data/Num/Lemmas.lean
theorem cast_to_znum : ∀ n : PosNum, (n : ZNum) = ZNum.pos n
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem pos_of_mem_ball (hx : x ∈ ball c f.rOut) : 0 < f x
-- Mathlib/Order/Compare.lean
@[simp]
lemma compares_eq [LT α] (a b : α) : Compares eq a b = (a = b)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem sSup_coe_toSubmodule (S : Set (LieSubmodule R L M)) :
    (↑(sSup S) : Submodule R M) = sSup {(s : Submodule R M) | s ∈ S}
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffOn.inv {f : E → 𝕜'} {n} (hf : ContDiffOn 𝕜 n f s) (h : ∀ x ∈ s, f x ≠ 0) :
    ContDiffOn 𝕜 n (fun x => (f x)⁻¹) s
-- Mathlib/RingTheory/Localization/Basic.lean
/-- For any given denominator `b : M`, the map `a ↦ a / b` is an `AddMonoidHom` from `R` to
  `Localization M`-/
@[simps]
def mkAddMonoidHom (b : M) : R →+ Localization M
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- Sum of elements in a `NonUnitalSubring` of a `NonUnitalRing` indexed by a `Finset`
is in the `NonUnitalSubring`. -/
protected theorem sum_mem {R : Type*} [NonUnitalNonAssocRing R] (s : NonUnitalSubring R)
    {ι : Type*} {t : Finset ι} {f : ι → R} (h : ∀ c ∈ t, f c ∈ s) : (∑ i ∈ t, f i) ∈ s
-- Mathlib/Algebra/Order/Field/Basic.lean
private lemma div_ne_zero_of_ne_zero_of_pos (ha : a ≠ 0) (hb : 0 < b) : a / b ≠ 0
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_disjoint : Disjoint (t \ s) s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem one_add (n) : 1 + n = succ n
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_right_hasFDerivWithinAt_iff' {f : F → G} {s : Set F} {x : E} {f' : E →L[𝕜] G} :
    HasFDerivWithinAt (f ∘ iso) f' (iso ⁻¹' s) x ↔
      HasFDerivWithinAt f (f'.comp (iso.symm : F →L[𝕜] E)) s (iso x)
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- If the multiplicative action of `M` on `N` is compatible with multiplication on `N`, then
`fun x ↦ x • 1` is a monoid homomorphism from `M` to `N`. -/
@[to_additive (attr := simps)
"If the additive action of `M` on `N` is compatible with addition on `N`, then
`fun x ↦ x +ᵥ 0` is an additive monoid homomorphism from `M` to `N`."]
def MonoidHom.smulOneHom {M N} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] :
    M →* N
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp, norm_cast)] lemma val_inv_eq_inv_val (u : αˣ) : ↑u⁻¹ = (u⁻¹ : α)
-- Mathlib/Data/Finset/Image.lean
theorem _root_.Function.Semiconj.finset_map {f : α ↪ β} {ga : α ↪ α} {gb : β ↪ β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (map f) (map ga) (map gb)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma IsEllDivSequence.smul (h : IsEllDivSequence W) (x : R) : IsEllDivSequence (x • W)
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem zeroLocus_bUnion (s : Set (Set R)) :
    zeroLocus (⋃ s' ∈ s, s' : Set R) = ⋂ s' ∈ s, zeroLocus s'
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Square.lean
lemma IsPullback.of_iso {sq₁ sq₂ : Square C} (h : sq₁.IsPullback)
    (e : sq₁ ≅ sq₂) : sq₂.IsPullback
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem subset_iUnion (h : J ∈ π) : ↑J ⊆ π.iUnion
-- Mathlib/Algebra/Lie/Weights/Cartan.lean
lemma mem_corootSpace {x : H} :
    x ∈ corootSpace α ↔
    (x : L) ∈ Submodule.span R {⁅y, z⁆ | (y ∈ rootSpace H α) (z ∈ rootSpace H (-α))}
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem add_const (hf : DiffContOnCl 𝕜 f s) (c : F) : DiffContOnCl 𝕜 (fun x => f x + c) s
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_self : IsCoprime x x ↔ IsUnit x
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp] lemma coe_tosSupHom (f : CompleteLatticeHom α β) : ⇑f.tosSupHom = f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem dual_Iio : Iio (toDual a) = ofDual ⁻¹' Ioi a
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Pythagorean theorem, vector inner product form. -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero (x y : E) (h : ⟪x, y⟫ = 0) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lift_strictMono : StrictMono lift
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
@[simp]
theorem NormedAddGroupHom.completion_coe_to_fun (f : NormedAddGroupHom G H) :
    (f.completion : Completion G → Completion H) = Completion.map f
-- Mathlib/Order/Sublattice.lean
lemma copy_eq (L : Sublattice α) (s : Set α) (hs) : L.copy s hs = L
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma Subgroup.orderOf_le_card (s : Subgroup G) (hs : (s : Set G).Finite) (hx : x ∈ s) :
    orderOf x ≤ Nat.card s
-- Mathlib/Data/Int/GCD.lean
theorem xgcd_val (x y) : xgcd x y = (gcdA x y, gcdB x y)
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem infs_subset_iff : s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
/-- If `n % 4 = 3`, then `χ₄ n = -1`. -/
theorem χ₄_nat_three_mod_four {n : ℕ} (hn : n % 4 = 3) : χ₄ n = -1
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictAnti.strictAntiOn (hf : StrictAnti f) (s : Set α) : StrictAntiOn f s
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[simp, measurability]
theorem measurableSet_Iic : MeasurableSet (Iic a)
-- Mathlib/FieldTheory/Perfect.lean
theorem roots_expand_pow_image_iterateFrobenius_subset [DecidableEq R] :
    (expand R (p ^ n) f).roots.toFinset.image (iterateFrobenius R p n) ⊆ f.roots.toFinset
-- Mathlib/Data/Set/Countable.lean
theorem MapsTo.countable_of_injOn {s : Set α} {t : Set β} {f : α → β} (hf : MapsTo f s t)
    (hf' : InjOn f s) (ht : t.Countable) : s.Countable
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The affine span of a single point, coerced to a set, contains just that point. -/
@[simp 1001] -- Porting note: this needs to take priority over `coe_affineSpan`
theorem coe_affineSpan_singleton (p : P) : (affineSpan k ({p} : Set P) : Set P) = {p}
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem span_eq : span (I : Set α) = I
-- Mathlib/Order/Filter/Archimedean.lean
theorem Tendsto.atTop_zsmul_const {f : α → ℤ} (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atTop
-- Mathlib/Order/Antisymmetrization.lean
@[simp]
theorem OrderHom.antisymmetrization_apply_mk (f : α →o β) (a : α) :
    f.antisymmetrization (toAntisymmetrization _ a) = toAntisymmetrization _ (f a)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- If the derivative of a function defined on the real line is integrable close to `+∞`, then
the function has a limit at `+∞`. -/
theorem tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi [CompleteSpace E]
    (hderiv : ∀ x ∈ Ioi a, HasDerivAt f (f' x) x) (f'int : IntegrableOn f' (Ioi a)) :
    Tendsto f atTop (𝓝 (limUnder atTop f))
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem powHalf_pos (n : ℕ) : 0 < powHalf n
-- Mathlib/RingTheory/IsAdjoinRoot.lean
/-- Auxiliary lemma for `IsAdjoinRoot.lift` -/
theorem eval₂_repr_eq_eval₂_of_map_eq (h : IsAdjoinRoot S f) (z : S) (w : R[X])
    (hzw : h.map w = z) : (h.repr z).eval₂ i x = w.eval₂ i x