ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Two n-simplices among cospherical points in n-space have the same
circumradius. -/
theorem circumradius_eq_of_cospherical {ps : Set P} {n : ℕ} [FiniteDimensional ℝ V]
    (hd : finrank ℝ V = n) (hc : Cospherical ps) {sx₁ sx₂ : Simplex ℝ P n}
    (hsx₁ : Set.range sx₁.points ⊆ ps) (hsx₂ : Set.range sx₂.points ⊆ ps) :
    sx₁.circumradius = sx₂.circumradius
-- Mathlib/Order/Bounded.lean
theorem unbounded_le_inter_not_le [SemilatticeSup α] (a : α) :
    Unbounded (· ≤ ·) (s ∩ { b | ¬b ≤ a }) ↔ Unbounded (· ≤ ·) s
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
theorem comp_P_eq_self_iff {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} :
    φ ≫ (P q).f (n + 1) = φ ↔ HigherFacesVanish q φ
-- Mathlib/Order/RelIso/Basic.lean
/-- `Sum.inl` as a relation embedding into `Sum.Lex r s`. -/
@[simps]
def sumLexInl (r : α → α → Prop) (s : β → β → Prop) : r ↪r Sum.Lex r s
-- Mathlib/Topology/Compactness/Lindelof.lean
lemma eq_open_union_countable [HereditarilyLindelofSpace X] {ι : Type u} (U : ι → Set X)
    (h : ∀ i, IsOpen (U i)) : ∃ t : Set ι, t.Countable ∧ ⋃ i∈t, U i = ⋃ i, U i
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem zero_coeff {a : Γ} : (0 : HahnSeries Γ R).coeff a = 0
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem map_id (S : ConvexCone 𝕜 E) : S.map LinearMap.id = S
-- Mathlib/MeasureTheory/OuterMeasure/Defs.lean
/-- An outer measure is a countably subadditive monotone function that sends `∅` to `0`. -/
structure OuterMeasure (α : Type*) where
  /-- Outer measure function. Use automatic coercion instead. -/
  protected measureOf : Set α → ℝ≥0∞
  protected empty : measureOf ∅ = 0
  protected mono : ∀ {s₁ s₂}, s₁ ⊆ s₂ → measureOf s₁ ≤ measureOf s₂
  protected iUnion_nat : ∀ s : ℕ → Set α, Pairwise (Disjoint on s) →
    measureOf (⋃ i, s i) ≤ ∑' i, measureOf (s i)
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
/-- The regular topology on any preregular category is subcanonical. -/
theorem subcanonical [Preregular C] : Sheaf.Subcanonical (regularTopology C)
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
theorem cauchy_iff {F : Filter R} : Cauchy F ↔
    F.NeBot ∧ ∀ γ : Γ₀ˣ, ∃ M ∈ F, ∀ᵉ (x ∈ M) (y ∈ M), (v (y - x) : Γ₀) < γ
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
/-- The canonical comparison functor between the indexing category of the presentation and the
    comma category `CostructuredArrow yoneda A`. This functor is always final. -/
@[simps! obj_left obj_right_as obj_hom map_left]
def toCostructuredArrow : P.I ⥤ CostructuredArrow yoneda A
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_def (b : α) : { x | x ≤ b } = Iic b
-- Mathlib/Analysis/Calculus/Deriv/Pow.lean
theorem differentiable_pow : Differentiable 𝕜 fun x : 𝕜 => x ^ n
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.sup' (hl : l.HasBasis p s) (hl' : l'.HasBasis p' s') :
    (l ⊔ l').HasBasis (fun i : PProd ι ι' => p i.1 ∧ p' i.2) fun i => s i.1 ∪ s' i.2
-- Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean
@[to_additive nsmul_nonpos]
theorem pow_le_one' {a : M} (H : a ≤ 1) (n : ℕ) : a ^ n ≤ 1
-- Mathlib/Algebra/FreeNonUnitalNonAssocAlgebra.lean
@[simp]
theorem lift_symm_apply (F : FreeNonUnitalNonAssocAlgebra R X →ₙₐ[R] A) :
    (lift R).symm F = F ∘ of R
-- Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean
/-- Shows that `Aₙ = bₙ * Aₙ₋₁ + aₙ * Aₙ₋₂` and `Bₙ = bₙ * Bₙ₋₁ + aₙ * Bₙ₋₂`. -/
theorem conts_recurrence {gp ppred pred : Pair K} (succ_nth_s_eq : g.s.get? (n + 1) = some gp)
    (nth_conts_eq : g.conts n = ppred) (succ_nth_conts_eq : g.conts (n + 1) = pred) :
    g.conts (n + 2) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩
-- Mathlib/CategoryTheory/Localization/DerivabilityStructure/Constructor.lean
/-- Given `Φ : LocalizerMorphism W₁ W₂`, `L : C₂ ⥤ D` a localization functor for `W₂` and
a morphism `y : L.obj X₂ ⟶ X₃`, this is the functor which sends `R : Φ.RightResolution d` to
`(isoOfHom L W₂ R.w R.hw).inv ≫ y` in the category `w.CostructuredArrowDownwards y`
where `w` is `TwoSquare.mk Φ.functor (Φ.functor ⋙ L) L (𝟭 _) (Functor.rightUnitor _).inv`. -/
@[simps]
noncomputable def fromRightResolution :
    Φ.RightResolution X₂ ⥤ (TwoSquare.mk Φ.functor (Φ.functor ⋙ L) L (𝟭 _)
      (Functor.rightUnitor _).inv).CostructuredArrowDownwards y
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
/-- A short complex `S` is short exact if it is exact, `S.f` is a mono and `S.g` is an epi. -/
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
-- Mathlib/Tactic/Abel.lean
/-- A type synonym used by `abel` to represent `n • x + a` in an additive commutative group. -/
theorem termg_eq {α : Type*} [AddCommGroup α] (n : ℤ) (x a : α) : termg n x a = n • x + a
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem closure_iUnion {ι} (s : ι → Set M) : closure (⋃ i, s i) = ⨆ i, closure (s i)
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot
-- Mathlib/LinearAlgebra/SModEq.lean
@[simp]
theorem bot : x ≡ y [SMOD (⊥ : Submodule R M)] ↔ x = y
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := nontriviality)]
theorem isUnit_of_subsingleton [Monoid M] [Subsingleton M] (a : M) : IsUnit a
-- Mathlib/GroupTheory/Complement.lean
@[to_additive "A left transversal is finite iff the subgroup has finite index"]
theorem finite_iff
    (h : S ∈ Subgroup.leftTransversals (H : Set G)) :
    Finite S ↔ H.FiniteIndex
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsMinOn.hasLineDerivAt_eq_zero (h : IsMinOn f s a) (hd : HasLineDerivAt ℝ f f' a b)
    (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) : f' = 0
-- Mathlib/CategoryTheory/Monoidal/Discrete.lean
@[to_additive (attr := simp) Discrete.addMonoidal_tensorUnit_as]
lemma Discrete.monoidal_tensorUnit_as : (𝟙_ (Discrete M)).as = 1
-- Mathlib/Data/List/Basic.lean
theorem getLast_concat' {a : α} (l : List α) : getLast (concat l a) (concat_ne_nil a l) = a
-- Mathlib/Topology/Separation.lean
theorem strictMono_nhdsSet [T1Space X] : StrictMono (𝓝ˢ : Set X → Filter X)
-- Mathlib/Data/Set/Lattice.lean
theorem nonempty_of_union_eq_top_of_nonempty {ι : Type*} (t : Set ι) (s : ι → Set α)
    (H : Nonempty α) (w : ⋃ i ∈ t, s i = ⊤) : t.Nonempty
-- Mathlib/Topology/Connected/PathConnected.lean
theorem Inseparable.joinedIn (h : Inseparable x y) (hx : x ∈ F) (hy : y ∈ F) : JoinedIn F x y
-- Mathlib/Analysis/Normed/Operator/Compact.lean
@[continuity]
theorem IsCompactOperator.continuous {f : M₁ →ₛₗ[σ₁₂] M₂} (hf : IsCompactOperator f) :
    Continuous f
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
/-- `Finsupp.toDFinsupp` and `DFinsupp.toFinsupp` together form an equiv. -/
@[simps (config := .asFn)]
def finsuppEquivDFinsupp [DecidableEq ι] [Zero M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃ Π₀ _ : ι, M
-- Mathlib/Topology/Inseparable.lean
@[symm]
nonrec theorem symm (h : x ~ᵢ y) : y ~ᵢ x
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A proper map `f : X → Y` is **universally closed**: for any topological space `Z`, the map
`Prod.map f id : X × Z → Y × Z` is closed. We will prove in `isProperMap_iff_universally_closed`
that proper maps are exactly continuous maps which have this property, but this result should be
easier to use because it allows `Z` to live in any universe. -/
theorem IsProperMap.universally_closed (Z) [TopologicalSpace Z] (h : IsProperMap f) :
    IsClosedMap (Prod.map f id : X × Z → Y × Z)
-- Mathlib/RingTheory/Polynomial/Quotient.lean
theorem eval₂_C_mk_eq_zero {I : Ideal R} :
    ∀ f ∈ (map (C : R →+* R[X]) I : Ideal R[X]), eval₂RingHom (C.comp (Quotient.mk I)) X f = 0
-- Mathlib/Logic/Equiv/Set.lean
/-- Equivalence between the range of `Sum.inl : α → α ⊕ β` and `α`. -/
@[simps symm_apply_coe]
def rangeInl (α β : Type*) : Set.range (Sum.inl : α → α ⊕ β) ≃ α
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem contDiffOn_arccos {n : ℕ∞} : ContDiffOn ℝ n arccos {-1, 1}ᶜ
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem map_cocompact (h : X ≃ₜ Y) : map h (cocompact X) = cocompact Y
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The `n`th power of a quadratic character is the trivial character, when `n` is even. -/
theorem IsQuadratic.pow_even {χ : MulChar R R'} (hχ : χ.IsQuadratic) {n : ℕ} (hn : Even n) :
    χ ^ n = 1
-- Mathlib/Data/Fin/Basic.lean
/-- `succAbove` is injective at the pivot -/
lemma succAbove_left_injective : Injective (@succAbove n)
-- Mathlib/Data/Finset/NatAntidiagonal.lean
@[simp] lemma antidiagonal_filter_le_fst_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ k ≤ a.fst) = (antidiagonal (n - k)).map
      (Embedding.prodMap ⟨_, add_left_injective k⟩ (Embedding.refl ℕ))
-- Mathlib/Topology/RestrictGenTopology.lean
theorem of_continuous_prop (h : ∀ f : X → Prop, (∀ s ∈ S, ContinuousOn f s) → Continuous f) :
    RestrictGenTopology S
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem isEquiv_iff_val_sub_one_lt_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v (x - 1) < 1 ↔ v' (x - 1) < 1
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
/-- Shows that $e^{x} * e^{-x} = 1$ -/
theorem exp_mul_exp_neg_eq_one [Algebra ℚ A] : exp A * evalNegHom (exp A) = 1
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem coe_id : ⇑(OrderMonoidWithZeroHom.id α) = id
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_mul_real {r : ℝ} (hr : 0 < r) (x : ℂ) : arg (x * r) = arg x
-- Mathlib/Data/Vector/Basic.lean
/-- Accessing the nth element of a vector made up
of one element `x : α` is `x` itself. -/
@[simp]
theorem get_cons_nil : ∀ {ix : Fin 1} (x : α), get (x ::ᵥ nil) ix = x
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem norm_mul_le (x y : FreeGroup α) : norm (x * y) ≤ norm x + norm y
-- Mathlib/Data/Finite/Defs.lean
theorem finite_iff_exists_equiv_fin {α : Sort*} : Finite α ↔ ∃ n, Nonempty (α ≃ Fin n)
-- Mathlib/Data/Seq/Computation.lean
theorem get_mem : get s ∈ s
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiff_transDiffeomorph_right {f : M' → M} :
    ContMDiff I' (I.transDiffeomorph e) n f ↔ ContMDiff I' I n f
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProd_restrict {s : Set β} {t : Set γ} (hs : MeasurableSet s) (ht : MeasurableSet t) :
    Kernel.restrict κ hs ⊗ₖ Kernel.restrict η ht = Kernel.restrict (κ ⊗ₖ η) (hs.prod ht)
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
theorem dimH_ball_pi (x : ι → ℝ) {r : ℝ} (hr : 0 < r) :
    dimH (Metric.ball x r) = Fintype.card ι
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagram_sndFrom (i j : D.J) : D.diagram.sndFrom ⟨i, j⟩ = j
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- The functor `(L, R) ⥤ (L ⋙ F, R ⋙ F)` -/
@[simps]
def post (L : A ⥤ T) (R : B ⥤ T) (F : T ⥤ C) : Comma L R ⥤ Comma (L ⋙ F) (R ⋙ F)
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
@[simp, norm_cast]
theorem coe_zero [Nontrivial α] : ↑(0 : Ico (0 : α) 1) = (0 : α)
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem id_onBoundedFormula :
    ((LHom.id L).onBoundedFormula : L.BoundedFormula α n → L.BoundedFormula α n) = id
-- Mathlib/Algebra/GradedMonoid.lean
/-- A graded version of `Monoid`

Like `Monoid.npow`, this has an optional `GMonoid.gnpow` field to allow definitional control of
natural powers of a graded monoid. -/
class GMonoid [AddMonoid ι] extends GMul A, GOne A where
  /-- Multiplication by `one` on the left is the identity -/
  one_mul (a : GradedMonoid A) : 1 * a = a
  /-- Multiplication by `one` on the right is the identity -/
  mul_one (a : GradedMonoid A) : a * 1 = a
  /-- Multiplication is associative -/
  mul_assoc (a b c : GradedMonoid A) : a * b * c = a * (b * c)
  /-- Optional field to allow definitional control of natural powers -/
  gnpow : ∀ (n : ℕ) {i}, A i → A (n • i) := GMonoid.gnpowRec
  /-- The zeroth power will yield 1 -/
  gnpow_zero' : ∀ a : GradedMonoid A, GradedMonoid.mk _ (gnpow 0 a.snd) = 1 := by
    apply_gmonoid_gnpowRec_zero_tac
  /-- Successor powers behave as expected -/
  gnpow_succ' :
    ∀ (n : ℕ) (a : GradedMonoid A),
      (GradedMonoid.mk _ <| gnpow n.succ a.snd) = ⟨_, gnpow n a.snd⟩ * a := by
    apply_gmonoid_gnpowRec_succ_tac
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isTopologicalBasis_basic_opens :
    TopologicalSpace.IsTopologicalBasis
      (Set.range fun r : R => (basicOpen r : Set (PrimeSpectrum R)))
-- Mathlib/GroupTheory/Complement.lean
theorem quotientEquivSigmaZMod_symm_apply (q : orbitRel.Quotient (zpowers g) (G ⧸ H))
    (k : ZMod (minimalPeriod (g • ·) q.out')) :
    (quotientEquivSigmaZMod H g).symm ⟨q, k⟩ = g ^ (cast k : ℤ) • q.out'
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem coe_top : ⇑(⊤ : sInfHom α β) = ⊤
-- Mathlib/MeasureTheory/Integral/Asymptotics.lean
/-- If `f` is locally integrable, `f` has a bottom element, and `f =O[atTop] g`, for some
`g` integrable at `atTop`, then `f` is integrable. -/
theorem LocallyIntegrable.integrable_of_isBigO_atTop [IsMeasurablyGenerated (atTop (α := α))]
    [OrderBot α] (hf : LocallyIntegrable f μ) (ho : f =O[atTop] g)
    (hg : IntegrableAtFilter g atTop μ) : Integrable f μ
-- Mathlib/Combinatorics/Additive/AP/Three/Defs.lean
@[to_additive]
theorem le_mulRothNumber_product (s : Finset α) (t : Finset β) :
    mulRothNumber s * mulRothNumber t ≤ mulRothNumber (s ×ˢ t)
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
theorem homEquiv_symm_id (X : D) : (adj.homEquiv _ X).symm (𝟙 _) = adj.counit.app X
-- Mathlib/Probability/Distributions/Uniform.lean
theorem mem_support_uniformOfFintype (a : α) : a ∈ (uniformOfFintype α).support
-- Mathlib/GroupTheory/Schreier.lean
theorem exists_finset_card_le_mul [FiniteIndex H] {S : Finset G} (hS : closure (S : Set G) = ⊤) :
    ∃ T : Finset H, T.card ≤ H.index * S.card ∧ closure (T : Set H) = ⊤
-- Mathlib/Init/Order/LinearOrder.lean
theorem min_def (a b : α) : min a b = if a ≤ b then a else b
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem eq_wittStructureInt (Φ : MvPolynomial idx ℤ) (φ : ℕ → MvPolynomial (idx × ℕ) ℤ)
    (h : ∀ n, bind₁ φ (wittPolynomial p ℤ n) = bind₁ (fun i => rename (Prod.mk i) (W_ ℤ n)) Φ) :
    φ = wittStructureInt p Φ
-- Mathlib/CategoryTheory/Limits/Pi.lean
/-- If we have a functor `F : J ⥤ Π i, C i` into a category of indexed families,
and we have limits for each of the `F ⋙ Pi.eval C i`,
then `F` has a limit.
-/
theorem hasLimit_of_hasLimit_comp_eval : HasLimit F
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem ideal_le_vanishingIdeal_zeroLocus (I : Ideal A) :
    I ≤ (vanishingIdeal (zeroLocus 𝒜 I)).toIdeal
-- Mathlib/CategoryTheory/Category/PartialFun.lean
/-- The functor which maps undefined values to a new point. This makes the maps total and creates
pointed types. This is the noncomputable part of the equivalence `PartialFunEquivPointed`. It can't
be computable because `= Option.none` is decidable while the domain of a general `Part` isn't. -/
@[simps obj map]
noncomputable def partialFunToPointed : PartialFun ⥤ Pointed
-- Mathlib/Order/GameAdd.lean
/-- `Prod.GameAdd` is a subrelation of `Prod.Lex`. -/
theorem gameAdd_le_lex : GameAdd rα rβ ≤ Prod.Lex rα rβ
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_himp_compl : xᶜ ⇨ yᶜ = y ⇨ x
-- Mathlib/Analysis/Convex/Intrinsic.lean
theorem isClosed_intrinsicFrontier (hs : IsClosed (affineSpan 𝕜 s : Set P)) :
    IsClosed (intrinsicFrontier 𝕜 s)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contDiffWithinAtProp_self {f : E → E'} {s : Set E} {x : E} :
    ContDiffWithinAtProp 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem rank_submodule_le (s : Submodule R M) : Module.rank R s ≤ Module.rank R M
-- Mathlib/Algebra/FreeAlgebra.lean
/-- See note [partially-applied ext lemmas]. -/
@[ext high]
theorem hom_ext {f g : FreeAlgebra R X →ₐ[R] A}
    (w : (f : FreeAlgebra R X → A) ∘ ι R = (g : FreeAlgebra R X → A) ∘ ι R) : f = g
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_lt_div_left (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : a / b < a / c ↔ c < b
-- Mathlib/Topology/Maps/Basic.lean
theorem Inducing.isClosedMap (hf : Inducing f) (h : IsClosed (range f)) : IsClosedMap f
-- Mathlib/NumberTheory/ClassNumber/Finite.lean
theorem finsetApprox.zero_not_mem : (0 : R) ∉ finsetApprox bS adm
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The pushout provided by `HasPushout f g` fits into an `IsPushout`. -/
theorem of_hasPushout (f : Z ⟶ X) (g : Z ⟶ Y) [HasPushout f g] :
    IsPushout f g (pushout.inl f g) (pushout.inr f g)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem weightedSMul_congr (s t : Set α) (hst : μ s = μ t) :
    (weightedSMul μ s : F →L[ℝ] F) = weightedSMul μ t
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem congr_mk {ra : Setoid α} {rb : Setoid β} (e : α ≃ β)
    (eq : ∀ a₁ a₂ : α, Setoid.r a₁ a₂ ↔ Setoid.r (e a₁) (e a₂)) (a : α) :
    Quotient.congr e eq (Quotient.mk ra a) = Quotient.mk rb (e a)
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem comp_zero : p.comp (0 : R[X]) = C (p.eval 0)
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive (attr := simp)]
theorem coe_toHomUnits {G M : Type*} [Group G] [Monoid M] (f : G →* M) (g : G) :
    (f.toHomUnits g : M) = f g
-- Mathlib/Topology/Maps/Basic.lean
theorem closed_iff_preimage_closed (hf : ClosedEmbedding f) {s : Set Y}
    (hs : s ⊆ range f) : IsClosed s ↔ IsClosed (f ⁻¹' s)
-- Mathlib/Analysis/Seminorm.lean
theorem closedBall_sup (p : Seminorm 𝕜 E) (q : Seminorm 𝕜 E) (e : E) (r : ℝ) :
    closedBall (p ⊔ q) e r = closedBall p e r ∩ closedBall q e r
-- Mathlib/Data/ULift.lean
@[simp]
theorem «forall» {p : ULift α → Prop} : (∀ x, p x) ↔ ∀ x : α, p (ULift.up x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem exists_cos_eq_zero : 0 ∈ cos '' Icc (1 : ℝ) 2
-- Mathlib/CategoryTheory/Preadditive/Projective.lean
theorem map_projective_iff (P : C) : Projective (F.functor.obj P) ↔ Projective P
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive (attr := simp)]
theorem mem_top (x : M) : x ∈ (⊤ : Submonoid M)
-- Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean
@[simp]
theorem pointwise_smul_toSubring {R' R A : Type*} [Semiring R'] [CommRing R] [Ring A]
    [MulSemiringAction R' A] [Algebra R A] [SMulCommClass R' R A] (m : R') (S : Subalgebra R A) :
    (m • S).toSubring = m • S.toSubring
-- Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean
theorem measurableSet_lineDifferentiableAt_uncurry (hf : Continuous f) :
    MeasurableSet {p : E × E | LineDifferentiableAt 𝕜 f p.1 p.2}
-- Mathlib/AlgebraicGeometry/Spec.lean
/-- Spec, as a contravariant functor from commutative rings to sheafed spaces.
-/
@[simps]
def Spec.toSheafedSpace : CommRingCat.{u}ᵒᵖ ⥤ SheafedSpace CommRingCat
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_lt_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b < a * c ↔ b < c
-- Mathlib/Algebra/Squarefree/Basic.lean
@[simp]
theorem Irreducible.squarefree [CommMonoid R] {x : R} (h : Irreducible x) : Squarefree x
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- Prefer putting constants to the left of `X ^ n`.

This lemma is the loop-avoiding `simp` version of `X_pow_mul_assoc`. -/
@[simp]
theorem X_pow_mul_assoc_C {n : ℕ} (r : R) : p * X ^ n * C r = p * C r * X ^ n
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem exists_of_set {l : List α} (h : n < l.length) :
    ∃ l₁ a l₂, l = l₁ ++ a :: l₂ ∧ l₁.length = n ∧ l.set n a' = l₁ ++ a' :: l₂
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
/-- A presheaf `P` is a sheaf for the Grothendieck topology `J` iff for every covering sieve
    `S` of `J`, the natural cone associated to `P` and `S` is a limit cone. -/
theorem isSheaf_iff_isLimit :
    IsSheaf J P ↔
      ∀ ⦃X : C⦄ (S : Sieve X), S ∈ J X → Nonempty (IsLimit (P.mapCone S.arrows.cocone.op))
-- Mathlib/Algebra/Homology/ComplexShape.lean
/-- The `ComplexShape` appropriate for homology, so `d : X i ⟶ X j` only when `i = j + 1`.
-/
@[simps!]
def down (α : Type*) [AddRightCancelSemigroup α] [One α] : ComplexShape α
-- Mathlib/Algebra/Quaternion.lean
/-- The equivalence between a quaternion algebra over `R` and `R × R × R × R`. -/
@[simps]
def equivProd {R : Type*} (c₁ c₂ : R) : ℍ[R,c₁,c₂] ≃ R × R × R × R
-- Mathlib/Data/Set/Function.lean
theorem SurjOn.subset_range (h : SurjOn f s t) : t ⊆ range f
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
lemma stalkMap_id (X : Scheme.{u}) (x : X) :
    (𝟙 X : X ⟶ X).stalkMap x = 𝟙 (X.presheaf.stalk x)
-- Mathlib/Data/Analysis/Topology.lean
theorem LocallyFinite.Realizer.to_locallyFinite [TopologicalSpace α] {F : Ctop.Realizer α}
    {f : β → Set α} (R : LocallyFinite.Realizer F f) : LocallyFinite f
-- Mathlib/Algebra/Lie/Weights/Linear.lean
lemma toEnd_eq (x : L) :
    toEnd R L (shiftedWeightSpace R L M χ) x =
    (shift R L M χ).conj (toEnd R L (weightSpace M χ) x - χ x • LinearMap.id)
-- Mathlib/Data/Real/Archimedean.lean
/-- As `0` is the default value for `Real.sInf` of the empty set, it suffices to show that `f i` is
bounded below by `0` to show that `0 ≤ iInf f`.
-/
theorem iInf_nonneg {ι} {f : ι → ℝ} (hf : ∀ i, 0 ≤ f i) : 0 ≤ iInf f
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
protected theorem succ : IsFundamentalSequence (succ o) 1 fun _ _ => o
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := measurability)]
theorem Multiset.aemeasurable_prod' (l : Multiset (α → M)) (hl : ∀ f ∈ l, AEMeasurable f μ) :
    AEMeasurable l.prod μ
-- Mathlib/Data/Finset/Powerset.lean
theorem powersetCard_one (s : Finset α) :
    s.powersetCard 1 = s.map ⟨_, Finset.singleton_injective⟩
-- Mathlib/SetTheory/Game/Domineering.lean
theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem ofDual_sup' [SemilatticeInf α] {s : Finset ι} (hs : s.Nonempty) (f : ι → αᵒᵈ) :
    ofDual (s.sup' hs f) = s.inf' hs (ofDual ∘ f)
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The opposite `ShortComplex` in `Cᵒᵖ` associated to a short complex in `C`. -/
@[simps]
def op : ShortComplex Cᵒᵖ
-- Mathlib/Analysis/Convex/Extreme.lean
/-- x is an extreme point to A iff {x} is an extreme set of A. -/
@[simp] lemma isExtreme_singleton : IsExtreme 𝕜 A {x} ↔ x ∈ A.extremePoints 𝕜
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
/-- If `f` and `g` are two torus integrable functions, then so is `f - g`. -/
protected nonrec theorem sub (hf : TorusIntegrable f c R) (hg : TorusIntegrable g c R) :
    TorusIntegrable (f - g) c R
-- Mathlib/Analysis/NormedSpace/MazurUlam.lean
@[simp]
theorem coe_toRealLinearIsometryEquivOfMapZero_symm (f : E ≃ᵢ F) (h0 : f 0 = 0) :
    ⇑(f.toRealLinearIsometryEquivOfMapZero h0).symm = f.symm
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive AddMonoid.exp_eq_one_iff]
theorem exp_eq_one_iff : exponent G = 1 ↔ Subsingleton G
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
@[simp]
theorem bind₁_xInTermsOfW_wittPolynomial [Invertible (p : R)] (k : ℕ) :
    bind₁ (xInTermsOfW p R) (W_ R k) = X k
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem IsRadical.comap (hK : K.IsRadical) : (comap f K).IsRadical
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
@[simp]
theorem inv_pow' (A : M) (n : ℕ) : A⁻¹ ^ n = (A ^ n)⁻¹
-- Mathlib/CategoryTheory/Endofunctor/Algebra.lean
theorem left_inv : strInv h ≫ A.str = 𝟙 _
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
/-- The elliptic curve over `R` induced by an admissible linear change of variables
$(X, Y) \mapsto (u^2X + r, u^3Y + u^2sX + t)$ for some $u \in R^\times$ and some $r, s, t \in R$.
When `R` is a field, any two Weierstrass equations isomorphic to `E` are related by this. -/
@[simps (config := { rhsMd := .default }) a₁ a₂ a₃ a₄ a₆ Δ' toWeierstrassCurve]
def variableChange : EllipticCurve R
-- Mathlib/Data/Set/Card.lean
theorem Finite.encard_eq_coe_toFinset_card (h : s.Finite) : s.encard = h.toFinset.card
-- Mathlib/Data/Set/Card.lean
theorem ncard_exchange' {a b : α} (ha : a ∉ s) (hb : b ∈ s) :
    (insert a s \ {b}).ncard = s.ncard