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
circumcenter. -/
theorem circumcenter_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₁.circumcenter = sx₂.circumcenter
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem nonempty_iUnion : (⋃ i, s i).Nonempty ↔ ∃ i, (s i).Nonempty
-- Mathlib/Order/Ideal.lean
@[simp]
theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem actRight_one' : (_ ◁ T.one) ≫ actRight P Q = (ρ_ _).hom
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
/-- # mem -/

theorem mem_data {a : α} {l : Array α} : a ∈ l.data ↔ a ∈ l
-- Mathlib/Order/SupClosed.lean
lemma IsUpperSet.supClosed (hs : IsUpperSet s) : SupClosed s
-- Mathlib/Topology/Compactness/SigmaCompact.lean
@[mono, gcongr]
theorem compactCovering_subset ⦃m n : ℕ⦄ (h : m ≤ n) : compactCovering X m ⊆ compactCovering X n
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumAssoc_apply_inr (c) : sumAssoc α β γ (inr c) = inr (inr c)
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem mk'_eq_coe (l : Filter α) (f : α → β) :
    @Quotient.mk' _ (germSetoid _ _) f = (f : Germ l β)
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem conformalAt {f : X → Y} (h : Conformal f) (x : X) : ConformalAt f x
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- There exists a non-null vector with respect to any symmetric, nonzero bilinear form `B`
on a module `M` over a ring `R` with invertible `2`, i.e. there exists some
`x : M` such that `B x x ≠ 0`. -/
theorem exists_bilinForm_self_ne_zero [htwo : Invertible (2 : R)] {B : BilinForm R M}
    (hB₁ : B ≠ 0) (hB₂ : B.IsSymm) : ∃ x, ¬B.IsOrtho x x
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem val_eq_one_iff (v : Valuation K Γ₀) {x : K} : v x = 1 ↔ v x⁻¹ = 1
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem map_eq_map_iff {f : G →* N} {H K : Subgroup G} :
    H.map f = K.map f ↔ H ⊔ f.ker = K ⊔ f.ker
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem ratio_le_opNorm (x : V₁) : ‖f x‖ / ‖x‖ ≤ ‖f‖
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
@[reassoc]
theorem comp_P_eq_self {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) :
    φ ≫ (P q).f (n + 1) = φ
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem map_ne {x y : F} (h : x ≠ y) : f₁ x ≠ f₁ y
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- Monoidal functors commute with left tensoring up to isomorphism -/
@[simps!]
noncomputable def commTensorLeft (X : C) :
    F.toFunctor ⋙ tensorLeft (F.toFunctor.obj X) ≅ tensorLeft X ⋙ F.toFunctor
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem dvd_emod_sub_self {x : Int} {m : Nat} : (m : Int) ∣ x % m - x
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem subset_lowerBounds_mul (s t : Set M) :
    lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t)
-- Mathlib/Data/Rat/Floor.lean
@[simp, norm_cast]
theorem round_cast (x : ℚ) : round (x : α) = round x
-- Mathlib/Topology/Maps/Basic.lean
theorem Function.Injective.embedding_induced [t : TopologicalSpace Y] (hf : Injective f) :
    @_root_.Embedding X Y (t.induced f) t f
-- Mathlib/Analysis/Convex/Side.lean
theorem isConnected_setOf_sOppSide {s : AffineSubspace ℝ P} {x : P} (hx : x ∉ s)
    (h : (s : Set P).Nonempty) : IsConnected { y | s.SOppSide x y }
-- Mathlib/RingTheory/TensorProduct/MvPolynomial.lean
lemma rTensor_apply (t : MvPolynomial σ S ⊗[R] N) (d : σ →₀ ℕ) :
    rTensor t d = ((lcoeff S d).restrictScalars R).rTensor N t
-- Mathlib/Order/Max.lean
@[simp]
theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_restrict {a : α} (s : Set α) {t : Set α} (h₀ : a ∈ t) (h₁ : IsOpen t) :
    𝓝[s] a = 𝓝[s ∩ t] a
-- Mathlib/Algebra/CharP/Basic.lean
theorem add_pow_char_of_commute [Semiring R] {p : ℕ} [hp : Fact p.Prime] [CharP R p] (x y : R)
    (h : Commute x y) : (x + y) ^ p = x ^ p + y ^ p
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem map_think (f : α → β) (s) : map f (think s) = think (map f s)
-- Mathlib/RingTheory/DedekindDomain/Basic.lean
/-- An integral domain is a Dedekind domain if and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. -/
theorem isDedekindRing_iff (K : Type*) [CommRing K] [Algebra A K] [IsFractionRing A K] :
    IsDedekindRing A ↔
      IsNoetherianRing A ∧ DimensionLEOne A ∧
        ∀ {x : K}, IsIntegral A x → ∃ y, algebraMap A K y = x
-- Mathlib/LinearAlgebra/QuotientPi.lean
theorem left_inv : Function.LeftInverse (invFun p) (toFun p)
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isRelPrime_mul_unit_left : IsRelPrime (x * y) (x * z) ↔ IsRelPrime y z
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem swap_eq_refl_iff {x y : α} : swap x y = Equiv.refl _ ↔ x = y
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem natCoe_one [AddMonoidWithOne R] :
    ((1 : ArithmeticFunction ℕ) : ArithmeticFunction R) = 1
-- Mathlib/Data/Setoid/Partition.lean
theorem IsPartition.pairwiseDisjoint {c : Set (Set α)} (hc : IsPartition c) :
    c.PairwiseDisjoint id
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem map_map (g : β →o γ) (f : α →o β) (a : NonemptyInterval α) :
    (a.map f).map g = a.map (g.comp f)
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem natCast_imK (n : ℕ) : (n : ℍ[R]).imK = 0
-- Mathlib/Topology/Order.lean
theorem discreteTopology_iff_forall_isClosed [TopologicalSpace α] :
    DiscreteTopology α ↔ ∀ s : Set α, IsClosed s
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma shortExact_iff_op : S.ShortExact ↔ S.op.ShortExact
-- Mathlib/MeasureTheory/PiSystem.lean
@[ext]
theorem ext : ∀ {d₁ d₂ : DynkinSystem α}, (∀ s : Set α, d₁.Has s ↔ d₂.Has s) → d₁ = d₂
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem equivFunOnFinite_single [DecidableEq α] [Finite α] (x : α) (m : M) :
    Finsupp.equivFunOnFinite (Finsupp.single x m) = Pi.single x m
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem not_inseparable_coe_infty {x : X} : ¬Inseparable (x : OnePoint X) ∞
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a compact topological space, `α` a uniform space, and `F : ι → (X → α)` an
equicontinuous family. Then, the uniform structures of uniform convergence and pointwise
convergence induce the same uniform structure on `ι`.

In other words, pointwise convergence and uniform convergence coincide on an equicontinuous
subset of `X → α`.

This is a version of `Equicontinuous.comap_uniformFun_eq` stated in terms of `UniformInducing`
for convenuence. -/
lemma Equicontinuous.uniformInducing_uniformFun_iff_pi [UniformSpace ι] [CompactSpace X]
    (F_eqcont : Equicontinuous F) :
    UniformInducing (UniformFun.ofFun ∘ F) ↔ UniformInducing F
-- Mathlib/Data/Set/Lattice.lean
theorem Iic_iInf (f : ι → α) : Iic (⨅ i, f i) = ⋂ i, Iic (f i)
-- Mathlib/CategoryTheory/Limits/Cones.lean
@[ext]
theorem ConeMorphism.ext {c c' : Cone F} (f g : c ⟶ c') (w : f.hom = g.hom) : f = g
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem empty_eq : (∅ : AssocList α β) = nil
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive MeasureTheory.IsAddFundamentalDomain.measure_addFundamentalInterior]
theorem measure_fundamentalInterior : μ (fundamentalInterior G s) = μ s
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_id (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin id s x = 1
-- Mathlib/MeasureTheory/Covering/Vitali.lean
/-- Vitali covering theorem, closed balls version: given a family `t` of closed balls, one can
extract a disjoint subfamily `u ⊆ t` so that all balls in `t` are covered by the τ-times
dilations of balls in `u`, for some `τ > 3`. -/
theorem exists_disjoint_subfamily_covering_enlargment_closedBall [MetricSpace α] (t : Set ι)
    (x : ι → α) (r : ι → ℝ) (R : ℝ) (hr : ∀ a ∈ t, r a ≤ R) (τ : ℝ) (hτ : 3 < τ) :
    ∃ u ⊆ t,
      (u.PairwiseDisjoint fun a => closedBall (x a) (r a)) ∧
        ∀ a ∈ t, ∃ b ∈ u, closedBall (x a) (r a) ⊆ closedBall (x b) (τ * r b)
-- Mathlib/Topology/Semicontinuous.lean
theorem UpperSemicontinuous.upperSemicontinuousWithinAt (h : UpperSemicontinuous f) (s : Set α)
    (x : α) : UpperSemicontinuousWithinAt f s x
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem map_piecewise_add [DecidableEq ι] (m m' : ι → M) (t : Finset ι) :
    f (t.piecewise (m + m') m') = ∑ s ∈ t.powerset, f (s.piecewise m m')
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
theorem preservesEpimorphisms.of_iso {F G : C ⥤ D} [PreservesEpimorphisms F] (α : F ≅ G) :
    PreservesEpimorphisms G
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxFilter.comp_tendsto {g : δ → α} {l' : Filter δ} {b : δ} (hf : IsMaxFilter f l (g b))
    (hg : Tendsto g l' l) : IsMaxFilter (f ∘ g) l' b
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem mk_eq_top_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : mk f = ⊤
-- Mathlib/GroupTheory/SemidirectProduct.lean
lemma mul_def (a b : SemidirectProduct N G φ) : a * b = ⟨a.1 * φ a.2 b.1, a.2 * b.2⟩
-- Mathlib/Computability/Primrec.lean
protected theorem id : Primrec (@id α)
-- Mathlib/Algebra/Lie/OfAssociative.lean
theorem of_associative_ring_bracket (x y : A) : ⁅x, y⁆ = x * y - y * x
-- Mathlib/Data/Finset/Preimage.lean
theorem monotone_preimage {f : α → β} (h : Injective f) :
    Monotone fun s => preimage s f h.injOn
-- Mathlib/Algebra/Regular/SMul.lean
/-- An element is `M`-regular if and only if multiplying it on the left by an `M`-regular element
is `M`-regular. -/
@[simp]
theorem smul_iff (b : S) (ha : IsSMulRegular M a) : IsSMulRegular M (a • b) ↔ IsSMulRegular M b
-- Mathlib/Data/Fin/VecNotation.lean
theorem empty_eq (v : Fin 0 → α) : v = ![]
-- Mathlib/Geometry/Euclidean/Basic.lean
theorem eq_orthogonalProjection_of_eq_subspace {s s' : AffineSubspace ℝ P} [Nonempty s]
    [Nonempty s'] [HasOrthogonalProjection s.direction] [HasOrthogonalProjection s'.direction]
    (h : s = s') (p : P) : (orthogonalProjection s p : P) = (orthogonalProjection s' p : P)
-- Mathlib/Order/Filter/Cocardinal.lean
theorem compl_mem_cocardinal_of_card_lt {s : Set α} (hs : #s < c) :
    sᶜ ∈ cocardinal α hreg
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_eq_iff' (hn : n ≠ 0) : ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1
-- Mathlib/Algebra/Group/Nat.lean
lemma addUnits_eq_zero (u : AddUnits ℕ) : u = 0
-- Mathlib/Data/ZMod/IntUnitsPower.lean
@[simp] lemma one_uzpow (x : R) : (1 : ℤˣ) ^ x = 1
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma neg {f : 𝕜 → E} {x : 𝕜} (hf : MeromorphicAt f x) : MeromorphicAt (-f) x
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem jacobson_radical_eq_jacobson : I.radical.jacobson = I.jacobson
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem linearIndependent_rows_of_invertible (A : Matrix m m K) [Invertible A] :
    LinearIndependent K (fun i ↦ A i)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Or.resolve_left  (h: Or a b) (na : Not a) : b
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
lemma _root_.rootsOfUnityEquivOfPrimitiveRoots_symm_apply
    {S F} [CommRing S] [IsDomain S] [FunLike F R S] [MonoidHomClass F R S]
    {n : ℕ+} {f : F} (hf : Function.Injective f) (hζ : (primitiveRoots n R).Nonempty) (η) :
    f ((rootsOfUnityEquivOfPrimitiveRoots hf hζ).symm η : Rˣ) = (η : Sˣ)
-- Mathlib/FieldTheory/Separable.lean
theorem separable_or {f : F[X]} (hf : Irreducible f) :
    f.Separable ∨ ¬f.Separable ∧ ∃ g : F[X], Irreducible g ∧ expand F p g = f
-- Mathlib/Combinatorics/Additive/ErdosGinzburgZiv.lean
/-- The **Erdős–Ginzburg–Ziv theorem** for `ℤ` for multiset.

Any multiset of at least `2 * n - 1` elements of `ℤ` contains a submultiset of `n` elements whose
sum is divisible by `n`. -/
theorem Int.erdos_ginzburg_ziv_multiset (s : Multiset ℤ) (hs : 2 * n - 1 ≤ Multiset.card s) :
    ∃ t ≤ s, Multiset.card t = n ∧ ↑n ∣ t.sum
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem Monotone.const_mul_of_nonpos [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Monotone f) (ha : a ≤ 0) : Antitone fun x => a * f x
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem dom_zero : (0 : PartENat).Dom
-- Mathlib/LinearAlgebra/Dual.lean
theorem range_dualMap_eq_dualAnnihilator_ker (f : V₁ →ₗ[K] V₂) :
    LinearMap.range f.dualMap = f.ker.dualAnnihilator
-- Mathlib/Data/Fintype/Card.lean
/-- The strong pigeonhole principle for infinitely many pigeons in
finitely many pigeonholes.  If there are infinitely many pigeons in
finitely many pigeonholes, then there is a pigeonhole with infinitely
many pigeons.

See also: `Finite.exists_ne_map_eq_of_infinite`
-/
theorem Finite.exists_infinite_fiber [Infinite α] [Finite β] (f : α → β) :
    ∃ y : β, Infinite (f ⁻¹' {y})
-- Mathlib/Order/SymmDiff.lean
theorem himp_bihimp : a ⇨ b ⇔ c = (a ⊓ c ⇨ b) ⊓ (a ⊓ b ⇨ c)
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem I_mul_I : I * I = -1
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[ext]
theorem hom_ext {W : C} (i j : W ⟶ multiequalizer I)
    (h : ∀ a, i ≫ Multiequalizer.ι I a = j ≫ Multiequalizer.ι I a) : i = j
-- Mathlib/MeasureTheory/Function/Jacobian.lean
theorem addHaar_image_le_lintegral_abs_det_fderiv_aux1 (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) {ε : ℝ≥0} (εpos : 0 < ε) :
    μ (f '' s) ≤ (∫⁻ x in s, ENNReal.ofReal |(f' x).det| ∂μ) + 2 * ε * μ s
-- Mathlib/Topology/Sheaves/Stalks.lean
@[simp]
theorem stalkFunctor_obj (ℱ : X.Presheaf C) (x : X) : (stalkFunctor C x).obj ℱ = ℱ.stalk x
-- Mathlib/LinearAlgebra/Quotient.lean
protected theorem eq {x y : M} : (mk x : M ⧸ p) = (mk y : M ⧸ p) ↔ x - y ∈ p
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
theorem inner_eq_tsum (f g : lp G 2) : ⟪f, g⟫ = ∑' i, ⟪f i, g i⟫
-- Mathlib/Dynamics/PeriodicPts.lean
theorem left_of_comp {g : α → α} (hco : Commute f g) (hfg : IsPeriodicPt (f ∘ g) n x)
    (hg : IsPeriodicPt g n x) : IsPeriodicPt f n x
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma _root_.AntitoneOn.image_uIcc_subset (hf : AntitoneOn f (uIcc a b)) :
    f '' uIcc a b ⊆ uIcc (f a) (f b)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem toComplex_ofComplex (c : ℂ) : toComplex (ofComplex c) = c
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem div_eq_div_iff_div_eq_div : a / b = c / d ↔ a / c = b / d
-- Mathlib/Data/NNReal/Basic.lean
nonrec theorem half_lt_self {a : ℝ≥0} (h : a ≠ 0) : a / 2 < a
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
/-- If `s : ι → Set α` is a sequence of sets, `S = ⋃ n, s n`, and `m (S \ s n)` tends to zero along
some nontrivial filter (usually `atTop` on `ι = ℕ`), then `m S = ⨆ n, m (s n)`. -/
theorem iUnion_of_tendsto_zero {ι} (m : OuterMeasure α) {s : ι → Set α} (l : Filter ι) [NeBot l]
    (h0 : Tendsto (fun k => m ((⋃ n, s n) \ s k)) l (𝓝 0)) : m (⋃ n, s n) = ⨆ n, m (s n)
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem id_apply (a : α) : OrderRingHom.id α a = a
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem comap_iInf {ι : Sort*} (f : F) (s : ι → Submonoid N) :
    (iInf s).comap f = ⨅ i, (s i).comap f
-- Mathlib/Data/Real/EReal.lean
@[norm_cast]
theorem coe_ennreal_nsmul (n : ℕ) (x : ℝ≥0∞) : (↑(n • x) : EReal) = n • (x : EReal)
-- Mathlib/Analysis/NormedSpace/ENorm.lean
theorem finite_edist_eq (x y : e.finiteSubspace) : edist x y = e (x - y)
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contMDiffWithinAt_iff_target_of_mem_source {x : M} {y : M'}
    (hy : f x ∈ (chartAt H' y).source) :
    ContMDiffWithinAt I I' n f s x ↔
      ContinuousWithinAt f s x ∧ ContMDiffWithinAt I 𝓘(𝕜, E') n (extChartAt I' y ∘ f) s x
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem pred_eq_iff_eq_succ {n : Nat} (i : Fin (n + 1)) (hi : i ≠ 0) (j : Fin n) :
    i.pred hi = j ↔ i = j.succ
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
@[simp] theorem reverse_perm : ∀ l : List α, reverse l ~ l
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- The inner product of a linear combination of a set of orthonormal vectors with one of those
vectors picks out the coefficient of that vector. -/
theorem Orthonormal.inner_right_sum {v : ι → E} (hv : Orthonormal 𝕜 v) (l : ι → 𝕜) {s : Finset ι}
    {i : ι} (hi : i ∈ s) : ⟪v i, ∑ i ∈ s, l i • v i⟫ = l i
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.mul {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} {c₁ c₂ : ℝ} (h₁ : IsBigOWith c₁ l f₁ g₁)
    (h₂ : IsBigOWith c₂ l f₂ g₂) :
    IsBigOWith (c₁ * c₂) l (fun x => f₁ x * f₂ x) fun x => g₁ x * g₂ x
-- Mathlib/Topology/Sets/Closeds.lean
/-- The term of `TopologicalSpace.Closeds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : Closeds α
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_subset (hs : s ⊆ u) (ht : t ⊆ u) (hu : Convex 𝕜 u) : convexJoin 𝕜 s t ⊆ u
-- Mathlib/Computability/Primrec.lean
theorem list_get?₁ : ∀ l : List α, Primrec l.get?
-- Mathlib/Algebra/Quaternion.lean
theorem im_sq : a.im ^ 2 = -normSq a.im
-- Mathlib/Data/Multiset/Basic.lean
theorem lt_iff_cons_le {s t : Multiset α} : s < t ↔ ∃ a, a ::ₘ s ≤ t
-- Mathlib/Tactic/NormNum/Pow.lean
theorem IsNatPowT.bit1 :
    IsNatPowT (Nat.pow a b = c) a (nat_lit 2 * b + nat_lit 1) (Nat.mul c (Nat.mul c a))
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem univ_subset_iff {s : Finset α} : univ ⊆ s ↔ s = univ
-- Mathlib/Data/Sum/Interval.lean
theorem Icc_inl_inl : Icc (inl a₁ : α ⊕ β) (inl a₂) = (Icc a₁ a₂).map Embedding.inl
-- Mathlib/Analysis/BoundedVariation.lean
theorem comp_ofDual (f : α → E) (s : Set α) :
    eVariationOn (f ∘ ofDual) (ofDual ⁻¹' s) = eVariationOn f s
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem dist_lt_iff_of_compact [CompactSpace α] (C0 : (0 : ℝ) < C) :
    dist f g < C ↔ ∀ x : α, dist (f x) (g x) < C
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
@[reassoc (attr := simp)]
theorem pullbackIsoProdSubtype_inv_fst (f : X ⟶ Z) (g : Y ⟶ Z) :
    (pullbackIsoProdSubtype f g).inv ≫ pullback.fst _ _ = pullbackFst f g
-- Mathlib/Data/Finset/Pairwise.lean
theorem PairwiseDisjoint.image_finset_of_le [DecidableEq ι] {s : Finset ι} {f : ι → α}
    (hs : (s : Set ι).PairwiseDisjoint f) {g : ι → ι} (hf : ∀ a, f (g a) ≤ f a) :
    (s.image g : Set ι).PairwiseDisjoint f
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.isUnit_of_dvd (H : IsCoprime x y) (d : x ∣ y) : IsUnit x
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_nonempty_iff : (image2 f s t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Mathlib/Data/Finset/NoncommProd.lean
@[to_additive]
protected theorem map_noncommProd_aux [MonoidHomClass F α β] (s : Multiset α)
    (comm : { x | x ∈ s }.Pairwise Commute) (f : F) : { x | x ∈ s.map f }.Pairwise Commute
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
theorem sum_lt' {α : Type*} {F : α → ℚ} {t : ℚ} {s : Finset α}
    (hF : ∀ i ∈ s, padicNorm p (F i) < t) (ht : 0 < t) : padicNorm p (∑ i ∈ s, F i) < t
-- Mathlib/Data/Finsupp/Basic.lean
theorem filter_zero : (0 : α →₀ M).filter p = 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating the second of two vectors by `θ` scales their Kahler form by `cos θ + sin θ * I`. -/
@[simp]
theorem kahler_rotation_right (x y : V) (θ : Real.Angle) :
    o.kahler x (o.rotation θ y) = θ.expMapCircle * o.kahler x y
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem mem_carrier : x ∈ p.carrier ↔ x ∈ (p : Set M)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive lt_of_add_lt_add_right]
theorem lt_of_mul_lt_mul_right' [i : ContravariantClass α α (swap (· * ·)) (· < ·)] {a b c : α}
    (bc : b * a < c * a) :
    b < c
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- A version of **Markov's inequality** for two functions. It doesn't follow from the standard
Markov's inequality because we only assume measurability of `g`, not `f`. -/
theorem lintegral_add_mul_meas_add_le_le_lintegral {f g : α → ℝ≥0∞} (hle : f ≤ᵐ[μ] g)
    (hg : AEMeasurable g μ) (ε : ℝ≥0∞) :
    ∫⁻ a, f a ∂μ + ε * μ { x | f x + ε ≤ g x } ≤ ∫⁻ a, g a ∂μ
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
theorem map_comp_apply {f : α → β} {g : β → γ} (x : FreeAbelianGroup α) :
    map (g ∘ f) x = (map g) ((map f) x)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem?_cons_zero {l : List α} : (a::l)[0]? = some a
-- Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean
theorem injective_iff_preservesEpimorphisms_preadditiveYoneda_obj (J : C) :
    Injective J ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_hasBinaryCoproduct [HasBinaryCoproduct X Y] [HasZeroObject C] [HasZeroMorphisms C] :
    IsPushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) coprod.inl coprod.inr
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem map_id : K.map (MonoidHom.id G) = K
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp] theorem domCongr_support (e : G ≃+ H) (f : MonoidAlgebra A G) :
    (domCongr k A e f).support = f.support.map e
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If two functions coincide on a set `s`, then their iterated differentials within this set
coincide. See also `Filter.EventuallyEq.iteratedFDerivWithin_eq` and
`Filter.EventuallyEq.iteratedFDerivWithin`. -/
protected theorem Set.EqOn.iteratedFDerivWithin (hs : EqOn f₁ f s) (n : ℕ) :
    EqOn (iteratedFDerivWithin 𝕜 n f₁ s) (iteratedFDerivWithin 𝕜 n f s) s
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.isBigO_congr_right (h : g' =Θ[l] k') : f =O[l] g' ↔ f =O[l] k'
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformEmbedding_comap {α : Type*} {β : Type*} {f : α → β} [u : UniformSpace β]
    (hf : Function.Injective f) : @UniformEmbedding α β (UniformSpace.comap f u) u f
-- Mathlib/Order/Antichain.lean
theorem image_compl [BooleanAlgebra α] (hs : IsAntichain (· ≤ ·) s) :
    IsAntichain (· ≤ ·) (compl '' s)
-- Mathlib/Topology/MetricSpace/Thickening.lean
@[simp]
theorem thickening_closure : thickening δ (closure s) = thickening δ s
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepSets.union {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α}
    (h₁ : IndepSets s₁ s' κ μ) (h₂ : IndepSets s₂ s' κ μ) :
    IndepSets (s₁ ∪ s₂) s' κ μ
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If a function `f` tends to negative infinity along a filter, then `f` multiplied by
a positive constant (on the left) also tends to negative infinity. -/
theorem Tendsto.const_mul_atBot (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atBot
-- Mathlib/Topology/DenseEmbedding.lean
/-- If the domain of a `DenseInducing` map is a separable space, then so is the codomain. -/
protected theorem separableSpace [SeparableSpace α] : SeparableSpace β
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma colimitHomIsoLimitYoneda'_hom_comp_π [HasLimitsOfShape I (Type u₂)] (A : C) (i : I) :
    (colimitHomIsoLimitYoneda' F A).hom ≫ limit.π (F.rightOp ⋙ yoneda.obj A) i
      = (coyoneda.map (colimit.ι F ⟨i⟩).op).app A
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem subset_compl_singleton_iff {a : α} {s : Set α} : s ⊆ {a}ᶜ ↔ a ∉ s
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma mk_mem_toSpec_base_apply {f} (x : Proj| pbo f)
    (z : NumDenSameDeg 𝒜 (.powers f)) :
    HomogeneousLocalization.mk z ∈ ((toSpec 𝒜 f).1.base x).asIdeal ↔
      z.num.1 ∈ x.1.asHomogeneousIdeal
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_add_left' (T T' T'' : Set α → E →L[ℝ] F)
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) {f : α →ₛ E}
    (hf : Integrable f μ) : setToSimpleFunc T'' f = setToSimpleFunc T f + setToSimpleFunc T' f
-- Mathlib/RingTheory/FinitePresentation.lean
theorem of_surjective (f : A →ₐ[R] B) (hf : Surjective f) (hker : f.toRingHom.ker.FG) :
    f.FinitePresentation