ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive (attr := simp)]
theorem inv_ae : (ae μ)⁻¹ = ae μ
-- Mathlib/Combinatorics/Additive/Corner/Roth.lean
/-- **Roth's theorem** for `ℕ` as an asymptotic statement.

The maximum density of a 3AP-free set in `{1, ..., n}` goes to zero as `n` tends to infinity. -/
theorem rothNumberNat_isLittleO_id :
    IsLittleO atTop (fun N ↦ (rothNumberNat N : ℝ)) (fun N ↦ (N : ℝ))
-- Mathlib/Topology/Algebra/ConstMulAction.lean
/-- Class `ProperlyDiscontinuousVAdd Γ T` says that the additive action `(+ᵥ) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousVAdd (Γ : Type*) (T : Type*) [TopologicalSpace T] [VAdd Γ T] :
  Prop where
  /-- Given two compact sets `K` and `L`, `γ +ᵥ K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ +ᵥ ·) '' K ∩ L ≠ ∅ }
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_nil_iff (a : α) : a ∈ ([] : List α) ↔ False
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_add_zsmul (a b : α) (m : ℤ) : toIocDiv hp a (b + m • p) = toIocDiv hp a b + m
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_ne_zero_of_pos_of_ne_one {x : ℝ} (hx_pos : 0 < x) (hx : x ≠ 1) : log x ≠ 0
-- Mathlib/Analysis/Calculus/TangentCone.lean
/-- The real interval `[0, 1]` is a set of unique differentiability. -/
theorem uniqueDiffOn_Icc_zero_one : UniqueDiffOn ℝ (Icc (0 : ℝ) 1)
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem isOpen_ball {x : E} {r : ℝ} : IsOpen (ball x r)
-- Mathlib/Computability/Partrec.lean
theorem list_cons : Computable₂ (@List.cons α)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitesimal_iff_infinite_inv {x : ℝ*} (h : x ≠ 0) : Infinitesimal x ↔ Infinite x⁻¹
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem convs'Aux_succ_some {s : Stream'.Seq (Pair K)} {p : Pair K} (h : s.head = some p)
    (n : ℕ) : convs'Aux s (n + 1) = p.a / (p.b + convs'Aux s.tail n)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem mem_srange_self (f : F) (x : R) : f x ∈ srange f
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem map_isPath_of_injective (hinj : Function.Injective f) (hp : p.IsPath) :
    (p.map f).IsPath
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_smul_non_comm [Star R] [Star α] [SMul R α] [SMul Rᵐᵒᵖ α] (c : R)
    (M : Matrix m n α) (h : ∀ (r : R) (a : α), star (r • a) = MulOpposite.op (star r) • star a) :
    (c • M)ᴴ = MulOpposite.op (star c) • Mᴴ
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
@[simp]
theorem ascPochhammer_map (f : S →+* T) (n : ℕ) :
    (ascPochhammer S n).map f = ascPochhammer T n
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@[simp, reassoc]
lemma comp_hom (f : P ⟶ Q) (g : Q ⟶ T) : (f ≫ g).hom = f.hom ≫ g.hom
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem ext_iff' (v w : VectorMeasure α M) : v = w ↔ ∀ i : Set α, v i = w i
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem ExpChar.neg_one_pow_expChar_pow [Ring R] (q n : ℕ) [hR : ExpChar R q] :
    (-1 : R) ^ q ^ n = -1
-- Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean
theorem prime_of_isIntegrallyClosed {x : S} (hx : IsIntegral R x) : Prime (minpoly R x)
-- Mathlib/Order/SuccPred/Limit.lean
@[simp]
theorem _root_.SuccOrder.limitRecOn_succ (ha : ¬ IsMax a) :
    SuccOrder.limitRecOn (succ a) H_succ H_lim
      = H_succ a ha (SuccOrder.limitRecOn a H_succ H_lim)
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- Similar to `prod`, but both functors start from the same category `A` -/
@[simps]
def prod' (F : A ⥤ B) (G : A ⥤ C) : A ⥤ B × C
-- Mathlib/MeasureTheory/Integral/MeanInequalities.lean
/-- Hölder's inequality for functions `α → ℝ≥0`. The integral of the product of two functions
is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are conjugate
exponents. -/
theorem NNReal.lintegral_mul_le_Lp_mul_Lq {p q : ℝ} (hpq : p.IsConjExponent q) {f g : α → ℝ≥0}
    (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    (∫⁻ a, (f * g) a ∂μ) ≤
      (∫⁻ a, (f a : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) * (∫⁻ a, (g a : ℝ≥0∞) ^ q ∂μ) ^ (1 / q)
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
@[simp]
theorem mapPresheaf_obj_X (F : C ⥤ D) (X : PresheafedSpace C) :
    (F.mapPresheaf.obj X : TopCat) = (X : TopCat)
-- Mathlib/FieldTheory/Adjoin.lean
theorem AdjoinSimple.algebraMap_gen : algebraMap F⟮α⟯ E (AdjoinSimple.gen F α) = α
-- Mathlib/GroupTheory/Torsion.lean
/-- The torsion submonoid of an abelian group equals the torsion subgroup as a submonoid. -/
@[to_additive add_torsion_eq_add_torsion_submonoid
      "The additive torsion submonoid of an abelian group equals the torsion
      subgroup as a submonoid."]
theorem torsion_eq_torsion_submonoid : CommMonoid.torsion G = (torsion G).toSubmonoid
-- Mathlib/CategoryTheory/EqToHom.lean
/-- Proving equality between functors using heterogeneous equality. -/
theorem hext {F G : C ⥤ D} (h_obj : ∀ X, F.obj X = G.obj X)
    (h_map : ∀ (X Y) (f : X ⟶ Y), HEq (F.map f) (G.map f)) : F = G
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
private theorem derivativeFun_coe_mul_coe (f g : R[X]) : derivativeFun (f * g : R⟦X⟧) =
    f * derivative g + g * derivative f
-- Mathlib/Tactic/Rify.lean
@[rify_simps] lemma ratCast_ne (a b : ℚ) : a ≠ b ↔ (a : ℝ) ≠ (b : ℝ)
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma mk₄_surjective (X : ComposableArrows C 4) :
    ∃ (X₀ X₁ X₂ X₃ X₄ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃) (f₃ : X₃ ⟶ X₄),
      X = mk₄ f₀ f₁ f₂ f₃
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_symm_of {i : ι} (x : ℳ i) : (decompose ℳ).symm (DirectSum.of _ i x) = x
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- A Dedekind domain is equal to the intersection of its localizations at all its height one
non-zero prime ideals viewed as subalgebras of its field of fractions. -/
theorem iInf_localization_eq_bot [Algebra R K] [hK : IsFractionRing R K] :
    (⨅ v : HeightOneSpectrum R,
        Localization.subalgebra.ofField K _ v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem dualCoannihilator_top (W : Subspace K V) :
    (⊤ : Subspace K (Module.Dual K W)).dualCoannihilator = ⊥
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
@[reassoc (attr := simp)]
lemma whiskerLeft_fst (X : C) {Y₁ Y₂ : C} (g : Y₁ ⟶ Y₂) :
    (X ◁ g) ≫ fst _ _ = fst _ _
-- Mathlib/Algebra/Lie/Basic.lean
theorem id_apply (x : M) : (id : M →ₗ⁅R,L⁆ M) x = x
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
theorem NormedAddGroupHom.completion_add (f g : NormedAddGroupHom G H) :
    (f + g).completion = f.completion + g.completion
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem not_neBot {f : Filter α} : ¬f.NeBot ↔ f = ⊥
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem repr_inj {a b} [NF a] [NF b] : repr a = repr b ↔ a = b
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isLocallySurjective_of_isLocallySurjective_fac
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} {f₁ : F₁ ⟶ F₂} {f₂ : F₂ ⟶ F₃} {f₃ : F₁ ⟶ F₃} (fac : f₁ ≫ f₂ = f₃)
    [IsLocallySurjective J f₃] : IsLocallySurjective J f₂
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_fiberwise' (s : Finset ι) (g : ι → κ) (f : κ → α) :
    ∏ j, ∏ _i ∈ s.filter fun i ↦ g i = j, f j = ∏ i ∈ s, f (g i)
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- If `ξ` is an integer, all its convergents equal `ξ`. -/
@[simp]
theorem convergent_of_int {ξ : ℤ} (n : ℕ) : convergent ξ n = ξ
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `ins` function preserves the ordering invariants. -/
protected theorem Ordered.ins : ∀ {t : RBNode α}, t.Ordered cmp → (ins cmp x t).Ordered cmp
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem d_eq_three_roots (ha : P.a ≠ 0) (h3 : (map φ P).roots = {x, y, z}) :
    φ P.d = φ P.a * -(x * y * z)
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem apply_eq_zero_of_not_le_supDegree {a : A} (hlt : ¬ D a ≤ p.supDegree D) : p a = 0
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem frobenius_sub : frobenius R p (x - y) = frobenius R p x - frobenius R p y
-- Mathlib/Data/Finset/Image.lean
theorem map_toFinset [DecidableEq α] [DecidableEq β] {s : Multiset α} :
    s.toFinset.map f = (s.map f).toFinset
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem Finite.toFinset_smul_set (hs : s.Finite) (hf : (a • s).Finite := hs.smul_set) :
    hf.toFinset = a • hs.toFinset
-- Mathlib/Algebra/Group/ULift.lean
@[simp]
theorem up_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    up (no_index (OfNat.ofNat n : α)) = OfNat.ofNat n
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- The radius of the circumsphere is the circumradius. -/
@[simp]
theorem circumsphere_radius {n : ℕ} (s : Simplex ℝ P n) : s.circumsphere.radius = s.circumradius
-- Mathlib/Data/Int/Defs.lean
lemma dvd_of_mul_dvd_mul_left (ha : a ≠ 0) (h : a * m ∣ a * n) : m ∣ n
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem differentiableAt_snd : DifferentiableAt 𝕜 Prod.snd p
-- Mathlib/Algebra/Homology/QuasiIso.lean
lemma quasiIsoAt_iff_exactAt (f : K ⟶ L) (i : ι) [K.HasHomology i] [L.HasHomology i]
    (hK : K.ExactAt i) :
    QuasiIsoAt f i ↔ L.ExactAt i
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- Angles are translation invariant -/
@[simp]
theorem angle_vsub_const (p₁ p₂ p₃ p : P) : ∠ (p₁ -ᵥ p) (p₂ -ᵥ p) (p₃ -ᵥ p) = ∠ p₁ p₂ p₃
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lTensor_comp : (g.comp f).lTensor M = (g.lTensor M).comp (f.lTensor M)
-- Mathlib/Combinatorics/SimpleGraph/Hasse.lean
theorem pathGraph_adj {n : ℕ} {u v : Fin n} :
    (pathGraph n).Adj u v ↔ u.val + 1 = v.val ∨ v.val + 1 = u.val
-- Mathlib/Data/Vector/Basic.lean
theorem not_empty_toList (v : Vector α (n + 1)) : ¬v.toList.isEmpty
-- Mathlib/Topology/Order/Bornology.lean
/-- Predicate for a preorder to be equipped with its order-bornology, namely for its bounded sets
to be the ones that are bounded both above and below. -/
class IsOrderBornology : Prop where
  protected isBounded_iff_bddBelow_bddAbove (s : Set α) : IsBounded s ↔ BddBelow s ∧ BddAbove s
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
@[simp]
theorem NatTrans.mapHomotopyCategory_id (c : ComplexShape ι) (F : V ⥤ W) [F.Additive] :
    NatTrans.mapHomotopyCategory (𝟙 F) c = 𝟙 (F.mapHomotopyCategory c)
-- Mathlib/Topology/Algebra/ConstMulAction.lean
nonrec theorem isOpenMap_smul (hc : IsUnit c) : IsOpenMap fun x : α => c • x
-- Mathlib/Topology/Order.lean
theorem coinduced_mono (h : t₁ ≤ t₂) : t₁.coinduced f ≤ t₂.coinduced f
-- Mathlib/Algebra/Group/Conj.lean
@[refl]
theorem IsConj.refl (a : α) : IsConj a a
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem iUnion_inter_closedBall_nat (s : Set α) (x : α) : ⋃ n : ℕ, s ∩ closedBall x n = s
-- Mathlib/Analysis/Asymptotics/Theta.lean
theorem IsTheta.smul [NormedSpace 𝕜 E'] [NormedSpace 𝕜' F'] {f₁ : α → 𝕜} {f₂ : α → 𝕜'} {g₁ : α → E'}
    {g₂ : α → F'} (hf : f₁ =Θ[l] f₂) (hg : g₁ =Θ[l] g₂) :
    (fun x ↦ f₁ x • g₁ x) =Θ[l] fun x ↦ f₂ x • g₂ x
-- Mathlib/Analysis/MellinTransform.lean
/-- If `f` is a locally integrable real-valued function which is `O(x ^ (-b))` at `0`, then for any
`b < s`, its Mellin transform converges on some right neighbourhood of `0`. -/
theorem mellin_convergent_zero_of_isBigO {b : ℝ} {f : ℝ → ℝ}
    (hfc : AEStronglyMeasurable f <| volume.restrict (Ioi 0))
    (hf :  f =O[𝓝[>] 0] (· ^ (-b))) {s : ℝ} (hs : b < s) :
    ∃ c : ℝ, 0 < c ∧ IntegrableOn (fun t : ℝ => t ^ (s - 1) * f t) (Ioc 0 c)
-- Mathlib/SetTheory/Lists.lean
theorem mem_of_subset' {a} : ∀ {l₁ l₂ : Lists' α true} (_ : l₁ ⊆ l₂) (_ : a ∈ l₁.toList), a ∈ l₂
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
@[simp]
theorem pure_bindOnSupport (a : α) (f : ∀ (a' : α) (_ : a' ∈ (pure a).support), PMF β) :
    (pure a).bindOnSupport f = f a ((mem_support_pure_iff a a).mpr rfl)
-- Mathlib/LinearAlgebra/Orientation.lean
@[simp]
protected theorem Orientation.reindex_neg {ι ι' : Type*} (e : ι ≃ ι') (x : Orientation R M ι) :
    Orientation.reindex R M e (-x) = -Orientation.reindex R M e x
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_union_Icc_eq_Iic (h : a ≤ b) : Iio a ∪ Icc a b = Iic b
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem MeasurableSet.exists_measurable_proj {_ : MeasurableSpace α}
    (hs : MeasurableSet s) (hne : s.Nonempty) : ∃ f : α → s, Measurable f ∧ ∀ x : s, f x = x
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem vadd_im : (x +ᵥ z).im = z.im
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand the square -/
theorem norm_sub_mul_self_real (x y : F) :
    ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem length_mul_ge_length_sub_length (w₁ w₂ : W) :
    ℓ w₁ - ℓ w₂ ≤ ℓ (w₁ * w₂)
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If a function is `C^n` with `1 ≤ n` around a point, then the derivative of `f` at this point
is also a strict derivative. -/
theorem ContDiffAt.hasStrictDerivAt {f : 𝕂 → F'} {x : 𝕂} (hf : ContDiffAt 𝕂 n f x) (hn : 1 ≤ n) :
    HasStrictDerivAt f (deriv f x) x
-- Mathlib/Topology/Basic.lean
theorem interior_setOf_eq {p : X → Prop} : interior { x | p x } = { x | ∀ᶠ y in 𝓝 x, p y }
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
theorem measurable_mapNatBool [MeasurableSpace α] [CountablyGenerated α] :
    Measurable (mapNatBool α)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem apply_lineMap (e : P₁ ≃ᵃ[k] P₂) (a b : P₁) (c : k) :
    e (AffineMap.lineMap a b c) = AffineMap.lineMap (e a) (e b) c
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem isPreconnected_Ico : IsPreconnected (Ico a b)
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem Matrix.toBilin'_toMatrix' (B : BilinForm R₂ (n → R₂)) :
    Matrix.toBilin' (BilinForm.toMatrix' B) = B
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_is_bilimit' {b : BinaryBicone X Y} (h : b.IsBilimit) :
    IsPullback (0 : 0 ⟶ X) (0 : 0 ⟶ Y) b.inl b.inr
-- Mathlib/Algebra/GroupWithZero/Commute.lean
theorem Commute.ring_inverse_ring_inverse {a b : M₀} (h : Commute a b) :
    Commute (Ring.inverse a) (Ring.inverse b)
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
/-- When the second map `S.g` is zero, this is the homology data on `S` given by
the chosen `cokernel S.f` -/
@[simps]
noncomputable def ofHasCokernel (hg : S.g = 0) [HasCokernel S.f] :
    S.HomologyData
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem map_neg_one : f (-1) = 1
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem lt_addChar (p : Pos) (c : Char) : p < p + c
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_apply (e : Trivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e.symm b y = cast (congr_arg E (e.symm_coe_proj hb)) (e.toPartialHomeomorph.symm (b, y)).2
-- Mathlib/Deprecated/Submonoid.lean
/-- A subset of a monoid is contained in the submonoid it generates. -/
@[to_additive
    "A subset of an `AddMonoid` is contained in the `AddSubmonoid` it generates."]
theorem subset_closure {s : Set M} : s ⊆ Closure s
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem ext [Inhabited (M F)] (x y : M F) (H : ∀ ps : Path F, iselect ps x = iselect ps y) :
    x = y
-- Mathlib/Data/ZMod/Basic.lean
theorem valMinAbs_mul_two_eq_iff {n : ℕ} (a : ZMod n) : a.valMinAbs * 2 = n ↔ 2 * a.val = n
-- Mathlib/Data/ENNReal/Operations.lean
theorem sub_mul (h : 0 < b → b < a → c ≠ ∞) : (a - b) * c = a * c - b * c
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem comp_id (f : α →ᵈ β) : f.comp (Dilation.id α) = f
-- Mathlib/Topology/MetricSpace/PartitionOfUnity.lean
/-- Let `X` be an extended metric space. Let `K : ι → Set X` be a locally finite family of closed
sets, let `U : ι → Set X` be a family of open sets such that `K i ⊆ U i` for all `i`. Then there
exists a positive continuous function `δ : C(X, ℝ≥0∞)` such that for any `i` and `x ∈ K i`,
we have `EMetric.closedBall x (δ x) ⊆ U i`. -/
theorem exists_continuous_eNNReal_forall_closedBall_subset (hK : ∀ i, IsClosed (K i))
    (hU : ∀ i, IsOpen (U i)) (hKU : ∀ i, K i ⊆ U i) (hfin : LocallyFinite K) :
    ∃ δ : C(X, ℝ≥0∞), (∀ x, 0 < δ x) ∧ ∀ (i), ∀ x ∈ K i, closedBall x (δ x) ⊆ U i
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
theorem image_inversion_sphere_dist_center (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R '' sphere y (dist y c) = insert c (perpBisector c (inversion c R y) : Set P)
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- The intersection of a Lindelöf set and a closed set is a Lindelöf set. -/
theorem IsLindelof.inter_right (hs : IsLindelof s) (ht : IsClosed t) : IsLindelof (s ∩ t)
-- Mathlib/Data/Multiset/Sym.lean
@[simp]
theorem sym2_eq_zero_iff {m : Multiset α} : m.sym2 = 0 ↔ m = 0
-- Mathlib/Data/Prod/Basic.lean
theorem map_snd' (f : α → γ) (g : β → δ) : Prod.snd ∘ map f g = g ∘ Prod.snd
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_prod_le (s : Set A) (t : Set B) :
    adjoin R (s ×ˢ t) ≤ (adjoin R s).prod (adjoin R t)
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[continuity, fun_prop]
theorem continuous_circleMap (c : ℂ) (R : ℝ) : Continuous (circleMap c R)
-- Mathlib/Algebra/GCDMonoid/Multiset.lean
theorem gcd_dvd {s : Multiset α} {a : α} (h : a ∈ s) : s.gcd ∣ a
-- Mathlib/Analysis/Convex/Exposed.lean
theorem exposedPoints_subset_extremePoints : A.exposedPoints 𝕜 ⊆ A.extremePoints 𝕜
-- Mathlib/Order/OmegaCompletePartialOrder.lean
@[simp] theorem coe_mk (f : α →o β) (hf : Continuous f) : ⇑(mk f hf) = f
-- Mathlib/Data/Nat/Squarefree.lean
theorem Squarefree.ext_iff {n m : ℕ} (hn : Squarefree n) (hm : Squarefree m) :
    n = m ↔ ∀ p, Prime p → (p ∣ n ↔ p ∣ m)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Ioi_mem_atTop [Preorder α] [NoMaxOrder α] (x : α) : Ioi x ∈ (atTop : Filter α)
-- Mathlib/Data/Multiset/Sym.lean
theorem sym2_cons (a : α) (m : Multiset α) :
    (m.cons a).sym2 = ((m.cons a).map <| fun b => s(a, b)) + m.sym2
-- Mathlib/Geometry/Manifold/WhitneyEmbedding.lean
theorem comp_embeddingPiTangent_mfderiv (x : M) (hx : x ∈ s) :
    ((ContinuousLinearMap.fst ℝ E ℝ).comp
            (@ContinuousLinearMap.proj ℝ _ ι (fun _ => E × ℝ) _ _ (fun _ => inferInstance)
              (f.ind x hx))).comp
        (mfderiv I 𝓘(ℝ, ι → E × ℝ) f.embeddingPiTangent x) =
      mfderiv I I (chartAt H (f.c (f.ind x hx))) x
-- Mathlib/CategoryTheory/Sites/SheafHom.lean
lemma exists_app :
    ∃ (φ : F.obj (op Y) ⟶ G.obj (op Y)),
      ∀ {Z : C} (p : Z ⟶ Y) (hp : S (p ≫ g)), φ ≫ G.map p.op =
        F.map p.op ≫ (x (p ≫ g) hp).app ⟨Over.mk (𝟙 Z)⟩
-- Mathlib/Algebra/Order/Ring/WithTop.lean
theorem bot_lt_mul' [LT α] {a b : WithBot α} (ha : ⊥ < a) (hb : ⊥ < b) : ⊥ < a * b
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `E` is a strictly convex normed space and `f : α → E` is a function such that `‖f x‖ ≤ C`
a.e., then either this function is a.e. equal to its average value, or the norm of its integral is
strictly less than `(μ univ).toReal * C`. -/
theorem ae_eq_const_or_norm_integral_lt_of_norm_le_const [StrictConvexSpace ℝ E] [IsFiniteMeasure μ]
    (h_le : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    f =ᵐ[μ] const α (⨍ x, f x ∂μ) ∨ ‖∫ x, f x ∂μ‖ < (μ univ).toReal * C
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem idealFactorsFunOfQuotHom_comp {f : R ⧸ I →+* A ⧸ J} {g : A ⧸ J →+* B ⧸ L}
    (hf : Function.Surjective f) (hg : Function.Surjective g) :
    (idealFactorsFunOfQuotHom hg).comp (idealFactorsFunOfQuotHom hf) =
      idealFactorsFunOfQuotHom (show Function.Surjective (g.comp f) from hg.comp hf)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem Monic.comp (hp : p.Monic) (hq : q.Monic) (h : q.natDegree ≠ 0) : (p.comp q).Monic
-- Mathlib/Probability/Moments.lean
@[simp]
theorem mgf_zero' : mgf X μ 0 = (μ Set.univ).toReal
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
lemma prob_compl_lt_one_sub_of_lt_prob {p : ℝ≥0∞} (hμs : p < μ s) (s_mble : MeasurableSet s) :
    μ sᶜ < 1 - p
-- Mathlib/Data/Set/Basic.lean
theorem not_mem_empty (x : α) : ¬x ∈ (∅ : Set α)
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem swap_swap_eq : swap ∘ swap = @id (α × β)
-- Mathlib/Order/Filter/Basic.lean
theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun _ : α => x) g = ⊤
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.preimage [FunLike F β α] [SupHomClass F β α] (hs : SupClosed s) (f : F) :
    SupClosed (f ⁻¹' s)
-- Mathlib/Data/Finset/Grade.lean
lemma isAtom_iff : IsAtom s ↔ ∃ a, s = {a}
-- Mathlib/Dynamics/PeriodicPts.lean
theorem IsPeriodicPt.minimalPeriod_pos (hn : 0 < n) (hx : IsPeriodicPt f n x) :
    0 < minimalPeriod f x
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem card_Icc [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    (Finset.Icc p q).card = (Finset.Icc p.1 q.1).card * (Finset.Icc p.2 q.2).card
-- Mathlib/Topology/Hom/Open.lean
@[simp]
theorem id_comp (f : α →CO β) : (ContinuousOpenMap.id β).comp f = f
-- Mathlib/Topology/Order.lean
theorem isClosed_induced_iff' {f : α → β} {s : Set α} :
    IsClosed[t.induced f] s ↔ ∀ a, f a ∈ closure (f '' s) → a ∈ s
-- Mathlib/Data/List/Duplicate.lean
theorem Duplicate.elim_singleton {y : α} (h : x ∈+ [y]) : False
-- Mathlib/Data/Set/Function.lean
@[deprecated (since := "2023-12-25")]
theorem maps_univ_to (f : α → β) (s : Set β) : MapsTo f univ s ↔ ∀ a, f a ∈ s
-- Mathlib/Data/ZMod/Basic.lean
theorem natCast_self (n : ℕ) : (n : ZMod n) = 0
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- See note [comp_of_eq lemmas] -/
theorem ContMDiffWithinAt.comp_of_eq {t : Set M'} {g : M' → M''} {x : M} {y : M'}
    (hg : ContMDiffWithinAt I' I'' n g t y) (hf : ContMDiffWithinAt I I' n f s x)
    (st : MapsTo f s t) (hx : f x = y) : ContMDiffWithinAt I I'' n (g ∘ f) s x
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma bot_lt_Iic : ⊥ < Iic a
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma lift_f_snd_v (p q : ℤ) (hpq : p + 0 = q) :
    (lift φ α β eq).f p ≫ (snd φ).v p q hpq = β.v p q hpq
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProd_apply_eq_compProdFun (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] (a : α) (hs : MeasurableSet s) :
    (κ ⊗ₖ η) a s = compProdFun κ η a s
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_extract_aux {as : Array α} {start stop : Nat} (h : i < (as.extract start stop).size) :
    start + i < as.size
-- Mathlib/Data/Vector/Basic.lean
/-- The underlying `List` of a `Vector` after a `scanl` is the `List.scanl`
of the underlying `List` of the original `Vector`.
-/
@[simp]
theorem scanl_val : ∀ {v : Vector α n}, (scanl f b v).val = List.scanl f b v.val
-- Mathlib/Analysis/Convex/Contractible.lean
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s
-- Mathlib/Combinatorics/Enumerative/DoubleCounting.lean
@[simp]
theorem mem_bipartiteBelow {a : α} : a ∈ s.bipartiteBelow r b ↔ a ∈ s ∧ r a b
-- Mathlib/FieldTheory/PurelyInseparable.lean
theorem IsPurelyInseparable.pow_mem (q : ℕ) [ExpChar F q] [IsPurelyInseparable F E] (x : E) :
    ∃ n : ℕ, x ^ q ^ n ∈ (algebraMap F E).range
-- Mathlib/Algebra/Lie/Free.lean
@[simp]
theorem of_comp_lift (f : X → L) : lift R f ∘ of R = f
-- .lake/packages/batteries/Batteries/Data/HashMap/WF.lean
theorem WF_iff [BEq α] [Hashable α] {m : Imp α β} :
    m.WF ↔ m.size = m.buckets.size ∧ m.buckets.WF
-- Mathlib/Data/List/Permutation.lean
theorem map_permutationsAux2' {α' β'} (g : α → α') (g' : β → β') (t : α) (ts ys : List α)
    (r : List β) (f : List α → β) (f' : List α' → β') (H : ∀ a, g' (f a) = f' (map g a)) :
    map g' (permutationsAux2 t ts r ys f).2 =
      (permutationsAux2 (g t) (map g ts) (map g' r) (map g ys) f').2
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
@[simp]
theorem norm_half_period_eq : ‖(↑(p / 2) : AddCircle p)‖ = |p| / 2