ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Complex/Hadamard.lean
/--
**Hadamard three-line theorem** on `re ⁻¹' [0,1]`: If `f` is a bounded function, continuous on the
closed strip `re ⁻¹' [0,1]` and differentiable on open strip `re ⁻¹' (0,1)`, then for
`M(x) := sup ((norm ∘ f) '' (re ⁻¹' {x}))` we have that for all `z` in the closed strip
`re ⁻¹' [0,1]` the inequality `‖f(z)‖ ≤ M(0) ^ (1 - z.re) * M(1) ^ z.re` holds. -/
lemma norm_le_interpStrip_of_mem_verticalClosedStrip (f : ℂ → E) {z : ℂ}
    (hz : z ∈ verticalClosedStrip 0 1) (hd : DiffContOnCl ℂ f (verticalStrip 0 1))
    (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :
    ‖f z‖ ≤ ‖interpStrip f z‖
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
protected theorem dist : LipschitzWith 2 (Function.uncurry <| @dist α _)
-- Mathlib/Init/Algebra/Classes.lean
theorem incomp_iff_eq {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] [IsIrrefl α lt] (a b) :
    ¬lt a b ∧ ¬lt b a ↔ a = b
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem row_empty : row ι (vecEmpty : Fin 0 → α) = of fun _ => vecEmpty
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma natCast_le_ofReal {n : ℕ} {p : ℝ} (hn : n ≠ 0) : n ≤ ENNReal.ofReal p ↔ n ≤ p
-- Mathlib/Data/Nat/Choose/Central.lean
theorem centralBinom_eq_two_mul_choose (n : ℕ) : centralBinom n = (2 * n).choose n
-- Mathlib/Probability/Distributions/Uniform.lean
theorem absolutelyContinuous {X : Ω → E} {s : Set E} (hu : IsUniform X s ℙ μ) : map X ℙ ≪ μ
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_mono' {s : ι → Set α} {t : ι' → Set α} (h : ∀ j, ∃ i, s i ⊆ t j) :
    ⋂ i, s i ⊆ ⋂ j, t j
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
/-- The tangent of a complex number is equal to zero
iff this number is equal to `k * π / 2` for an integer `k`.

Note that this lemma takes into account that we use zero as the junk value for division by zero.
See also `Complex.tan_eq_zero_iff'`.  -/
theorem tan_eq_zero_iff {θ : ℂ} : tan θ = 0 ↔ ∃ k : ℤ, k * π / 2 = θ
-- Mathlib/SetTheory/Ordinal/Exponential.lean
@[simp]
theorem opow_one (a : Ordinal) : a ^ (1 : Ordinal) = a
-- Mathlib/Topology/PartitionOfUnity.lean
/-- If `X` is a paracompact normal topological space and `U` is an open covering of a closed set
`s`, then there exists a `BumpCovering ι X s` that is subordinate to `U`. -/
theorem exists_isSubordinate [NormalSpace X] [ParacompactSpace X] (hs : IsClosed s) (U : ι → Set X)
    (ho : ∀ i, IsOpen (U i)) (hU : s ⊆ ⋃ i, U i) : ∃ f : BumpCovering ι X s, f.IsSubordinate U
-- Mathlib/Topology/Basic.lean
theorem frontier_interior_subset : frontier (interior s) ⊆ frontier s
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_false_left  : ∀(c f : Bool), cond c false f = (!c && f)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem bot_prod_bot : (⊥ : UpperSet α) ×ˢ (⊥ : UpperSet β) = ⊥
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem image_ball (h : α ≃ᵢ β) (x : α) (r : ℝ) : h '' Metric.ball x r = Metric.ball (h x) r
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp] lemma addLeft_zero : Equiv.addLeft (0 : α) = 1
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem summable_of_locally_summable_norm {ι : Type*} {F : ι → C(X, E)}
    (hF : ∀ K : Compacts X, Summable fun i => ‖(F i).restrict K‖) : Summable F
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem polar_self (x : M) : polar Q x x = 2 • Q x
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
theorem IsInitial.isIso_to (hI : IsInitial I) {A : C} (f : A ⟶ I) : IsIso f
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma isClosed_iff_isLower : IsClosed s ↔ IsLowerSet s
-- Mathlib/Data/Nat/PartENat.lean
/-- Alias of `Nat.cast_le` specialized to `PartENat` --/
theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
/-- The composition in the opposite direction is equal to the identity if and only if `F` preserves
    the biproduct, see `preservesBiproduct_of_monoBiproductComparison`.  -/
@[reassoc (attr := simp)]
theorem biproductComparison'_comp_biproductComparison :
    biproductComparison' F f ≫ biproductComparison F f = 𝟙 (⨁ F.obj ∘ f)
-- Mathlib/AlgebraicTopology/KanComplex.lean
/-- A simplicial set `S` is a *Kan complex* if it satisfies the following horn-filling condition:
for every `n : ℕ` and `0 ≤ i ≤ n`,
every map of simplicial sets `σ₀ : Λ[n, i] → S` can be extended to a map `σ : Δ[n] → S`. -/
class KanComplex (S : SSet) : Prop where
  hornFilling : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+1)⦄ (σ₀ : Λ[n, i] ⟶ S),
    ∃ σ : Δ[n] ⟶ S, σ₀ = hornInclusion n i ≫ σ
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
@[simp] -- Porting note: new attr
theorem cycleType_one : (1 : Perm α).cycleType = 0
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]
theorem coe_toEquiv : ⇑(e.toEquiv) = e
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem lipschitz_evalx (x : α) : LipschitzWith 1 fun f : α →ᵇ β => f x
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem toNat_eq_one_iff_unique : toNat #α = 1 ↔ Subsingleton α ∧ Nonempty α
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem continuous_CC'₀ : Continuous (CC'₀ C ho)
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[deprecated smul_mono_right (since := "2024-03-31")]
theorem set_smul_mono_right {p q : Submodule R M} (le : p ≤ q) :
    s • p ≤ s • q
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
lemma mem_descSet_singleton {x : lc.pt} {j : J} {y : K.obj j} :
    c.ι.app j y ∈ descSet hc {x} ↔ lc.ι.app j ⟨y⟩ = x
-- Mathlib/NumberTheory/MulChar/Lemmas.lean
/-- Two multiplicative characters on a monoid whose unit group is generated by `g`
are equal if and only if they agree on `g`. -/
lemma eq_iff {R R' : Type*} [CommMonoid R] [CommMonoidWithZero R'] {g : Rˣ}
    (hg : ∀ x, x ∈ Subgroup.zpowers g) (χ₁ χ₂ : MulChar R R') :
    χ₁ = χ₂ ↔ χ₁ g.val = χ₂ g.val
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma sinKernel_undef (a : UnitAddCircle) {x : ℝ} (hx : x ≤ 0) : sinKernel a x = 0
-- Mathlib/Order/InitialSeg.lean
theorem InitialSeg.ltOrEq_apply_right [IsWellOrder β s] (f : r ≼i s) (g : r ≃r s) (a : α) :
    g a = f a
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
/-- A version of `MeasureTheory.OuterMeasure.ext` that assumes `μ₁ s = μ₂ s` on all *nonempty*
sets `s`, and gets `μ₁ ∅ = μ₂ ∅` from `MeasureTheory.OuterMeasure.empty'`. -/
theorem ext_nonempty {μ₁ μ₂ : OuterMeasure α} (h : ∀ s : Set α, s.Nonempty → μ₁ s = μ₂ s) :
    μ₁ = μ₂
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_union_Ico_eq_Ico (h₁ : a ≤ b) (h₂ : b ≤ c) : Ico a b ∪ Ico b c = Ico a c
-- Mathlib/Data/Set/Finite.lean
theorem Finite.inter_of_left {s : Set α} (hs : s.Finite) (t : Set α) : (s ∩ t).Finite
-- Mathlib/Order/Filter/AtTopBot.lean
theorem strictMono_subseq_of_id_le {u : ℕ → ℕ} (hu : ∀ n, n ≤ u n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ StrictMono (u ∘ φ)
-- Mathlib/FieldTheory/Minpoly/Field.lean
theorem eq_of_irreducible_of_monic [Nontrivial B] {p : A[X]} (hp1 : Irreducible p)
    (hp2 : Polynomial.aeval x p = 0) (hp3 : p.Monic) : p = minpoly A x
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
lemma LieSubmodule.lowerCentralSeries_tensor_eq_baseChange (k : ℕ) :
    lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) k =
    (lowerCentralSeries R L M k).baseChange A
-- Mathlib/Order/SupIndep.lean
/-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f
-- Mathlib/Algebra/Polynomial/Bivariate.lean
lemma map_evalRingHom_eval (x y : R) (p : R[X][Y]) :
    (p.map <| evalRingHom x).eval y = p.evalEval x y
-- Mathlib/Logic/Relation.lean
theorem Equivalence.eqvGen_eq (h : Equivalence r) : EqvGen r = r
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_toAffineEquiv (e : V₁ ≃ₗ[k] V₂) : ⇑e.toAffineEquiv = e
-- Mathlib/Topology/EMetricSpace/Basic.lean
@[to_additive]
theorem edist_unop (x y : αᵐᵒᵖ) : edist (unop x) (unop y) = edist x y
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma homologyMap'_neg :
    homologyMap' (-φ) h₁ h₂ = -homologyMap' φ h₁ h₂
-- Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean
@[simp]
lemma d_add (b b' : B) : D.d (b + b') = D.d b + D.d b'
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem mem_singleton {a b : α} : b ∈ ({a} : Multiset α) ↔ b = a
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem signAux3_symm_trans_trans [Finite α] [DecidableEq β] [Finite β] (f : Perm α) (e : α ≃ β)
    {s : Multiset α} {t : Multiset β} (hs : ∀ x, x ∈ s) (ht : ∀ x, x ∈ t) :
    signAux3 ((e.symm.trans f).trans e) ht = signAux3 f hs
-- Mathlib/Topology/Spectral/Hom.lean
@[simp]
theorem cancel_left {g : SpectralMap β γ} {f₁ f₂ : SpectralMap α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Order/Compare.lean
theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
/-- A linearly ordered commutative monoid with a zero element. -/
class LinearOrderedCommMonoidWithZero (α : Type*) extends LinearOrderedCommMonoid α,
  CommMonoidWithZero α where
  /-- `0 ≤ 1` in any linearly ordered commutative monoid. -/
  zero_le_one : (0 : α) ≤ 1
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive (attr := elab_as_elim)]
theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
    (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem map_think (f : α → β) : ∀ s, map f (think s) = think (map f s)
-- Mathlib/ModelTheory/Syntax.lean
theorem distinctConstantsTheory_eq_iUnion (s : Set α) :
    L.distinctConstantsTheory s =
      ⋃ t : Finset s,
        L.distinctConstantsTheory (t.map (Function.Embedding.subtype fun x => x ∈ s))
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_erase (h : a ∈ s) : s \ t.erase a = insert a (s \ t)
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.diff_right {l₁ l₂ : List α} (h : l₁ <+~ l₂) (t : List α) :
    l₁.diff t <+~ l₂.diff t
-- Mathlib/Data/List/Basic.lean
theorem map₂Left_eq_zipWith :
    ∀ as bs, length as ≤ length bs → map₂Left f as bs = zipWith (fun a b => f a (some b)) as bs
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_univ {f : β → α} : ⨆ x ∈ (univ : Set β), f x = ⨆ x, f x
-- Mathlib/Order/RelClasses.lean
theorem IsTotalPreorder.swap (r) [IsTotalPreorder α r] : IsTotalPreorder α (swap r)
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
lemma levyProkhorovEDist_ne_top (μ ν : Measure Ω) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    levyProkhorovEDist μ ν ≠ ∞
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem mem_nhdsWithin_Ioi_iff_exists_mem_Ioc_Ioo_subset {a u' : α} {s : Set α} (hu' : a < u') :
    s ∈ 𝓝[>] a ↔ ∃ u ∈ Ioc a u', Ioo a u ⊆ s
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem toComplex_mul (x y : ℤ[i]) : ((x * y : ℤ[i]) : ℂ) = x * y
-- Mathlib/Computability/Primrec.lean
theorem vector_head {n} : Primrec (@Vector.head α n)
-- Mathlib/Data/Multiset/Fold.lean
@[simp]
theorem coe_fold_r (b : α) (l : List α) : fold op b l = l.foldr op b
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem one_snd : (1 : 𝓜(𝕜, A)).snd = 1
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_diff_Ioi : Ioc a b \ Ioi c = Ioc a (min b c)
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
theorem Subpresheaf.to_sheafifyLift (f : G.toPresheaf ⟶ F') (h : Presieve.IsSheaf J F') :
    Subpresheaf.homOfLe (G.le_sheafify J) ≫ G.sheafifyLift f h = f
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma setIntegral_densityProcess_of_mem (hκν : fst κ ≤ ν) [hν : IsFiniteKernel ν]
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {u : Set γ}
    (hu : u ∈ countablePartition γ n) :
    ∫ x in u, densityProcess κ ν n a x s ∂(ν a) = (κ a (u ×ˢ s)).toReal
-- Mathlib/Data/Analysis/Filter.lean
theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁ : l₁.Realizer)
    (L₂ : l₂.Realizer) : Tendsto f l₁ l₂ ↔ ∀ b, ∃ a, ∀ x ∈ L₁.F a, f x ∈ L₂.F b
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma Affine.CoordinateRing.mk_φ (n : ℤ) : mk W (W.φ n) = mk W (C <| W.Φ n)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem concat_inj_left {l l' : List α} (a : α) : concat l a = concat l' a ↔ l = l'
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- Distances `r₁` `r₂` of `p` from two different points `c₁` `c₂` determine at
most two points `p₁` `p₂` in a two-dimensional subspace containing those points
(two circles intersect in at most two points). -/
theorem eq_of_dist_eq_of_dist_eq_of_mem_of_finrank_eq_two {s : AffineSubspace ℝ P}
    [FiniteDimensional ℝ s.direction] (hd : finrank ℝ s.direction = 2) {c₁ c₂ p₁ p₂ p : P}
    (hc₁s : c₁ ∈ s) (hc₂s : c₂ ∈ s) (hp₁s : p₁ ∈ s) (hp₂s : p₂ ∈ s) (hps : p ∈ s) {r₁ r₂ : ℝ}
    (hc : c₁ ≠ c₂) (hp : p₁ ≠ p₂) (hp₁c₁ : dist p₁ c₁ = r₁) (hp₂c₁ : dist p₂ c₁ = r₁)
    (hpc₁ : dist p c₁ = r₁) (hp₁c₂ : dist p₁ c₂ = r₂) (hp₂c₂ : dist p₂ c₂ = r₂)
    (hpc₂ : dist p c₂ = r₂) : p = p₁ ∨ p = p₂
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
theorem isoIsPullback_hom_snd (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').hom ≫ snd' = snd
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem contDiffAt_sqrt {x : ℝ} {n : ℕ∞} (hx : x ≠ 0) : ContDiffAt ℝ n (√·) x
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem flip (n ν : ℕ) (h : ν ≤ n) :
    (bernsteinPolynomial R n ν).comp (1 - X) = bernsteinPolynomial R n (n - ν)
-- Mathlib/CategoryTheory/Generator.lean
theorem isCoseparator_iff_mono (G : C) [∀ A : C, HasProduct fun _ : A ⟶ G => G] :
    IsCoseparator G ↔ ∀ A : C, Mono (Pi.lift fun f : A ⟶ G => f)
-- Mathlib/Order/CompleteLattice.lean
lemma isGLB_iff_sInf_eq : IsGLB s a ↔ sInf s = a
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_top_of_nonneg {x : ℝ≥0∞} {y : ℝ} (hy0 : 0 ≤ y) (h : x ≠ ⊤) : x ^ y < ⊤
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformInducing_id : UniformInducing (@id α)
-- Mathlib/LinearAlgebra/DFinsupp.lean
/-- A family of submodules over an additive group are independent if and only iff `DFinsupp.lsum`
applied with `Submodule.subtype` is injective.

Note that this is not generally true for `[Semiring R]`; see
`CompleteLattice.Independent.dfinsupp_lsum_injective` for details. -/
theorem independent_iff_dfinsupp_lsum_injective (p : ι → Submodule R N) :
    Independent p ↔ Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype)
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem finset_inf_coe {ι} (s : Finset ι) (p : ι → Submodule R M) :
    (↑(s.inf p) : Set M) = ⋂ i ∈ s, ↑(p i)
-- Mathlib/Analysis/Fourier/RiemannLebesgueLemma.lean
/-- The Riemann-Lebesgue lemma for functions on `ℝ`, formulated via `Real.fourierIntegral`. -/
theorem Real.zero_at_infty_fourierIntegral (f : ℝ → E) : Tendsto (𝓕 f) (cocompact ℝ) (𝓝 0)
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, `M'` and `N'` are submodules of `M` and `N`,
respectively, such that `N` and `M'` are flat, then `M'` and `N'` are also linearly disjoint. -/
theorem of_le_of_flat_right (H : M.LinearDisjoint N) {M' N' : Submodule R S}
    (hm : M' ≤ M) (hn : N' ≤ N) [Module.Flat R N] [Module.Flat R M'] :
    M'.LinearDisjoint N'
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
lemma natDegree_eq_of_natDegree_add_eq_zero (p q : R[X])
    (H : natDegree (p + q) = 0) : natDegree p = natDegree q
-- Mathlib/Algebra/BigOperators/Group/List.lean
lemma countP_join (p : α → Bool) : ∀ L : List (List α), countP p L.join = (L.map (countP p)).sum
-- Mathlib/Algebra/Module/Defs.lean
lemma smul_ne_zero_iff_right (hc : c ≠ 0) : c • x ≠ 0 ↔ x ≠ 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem norm_eq_sqrt_inner (x : E) : ‖x‖ = √(re ⟪x, x⟫)
-- Mathlib/Algebra/Order/Hom/Basic.lean
/-- `NonarchimedeanHomClass F α β` states that `F` is a type of non-archimedean morphisms. -/
class NonarchimedeanHomClass (F α β : Type*) [Add α] [LinearOrder β] [FunLike F α β] : Prop where
  /-- the image of a sum is less or equal than the maximum of the images. -/
  map_add_le_max (f : F) : ∀ a b, f (a + b) ≤ max (f a) (f b)
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem subset_toCone : s ⊆ hs.toCone s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp]
theorem emod_bmod_congr (x : Int) (n : Nat) : Int.bmod (x%n) n = Int.bmod x n
-- Mathlib/Order/FixedPoints.lean
@[simp]
theorem map_lfp : f (lfp f) = lfp f
-- Mathlib/Order/Filter/SmallSets.lean
@[simp]
theorem eventually_smallSets_eventually {p : α → Prop} :
    (∀ᶠ s in l.smallSets, ∀ᶠ x in l', x ∈ s → p x) ↔ ∀ᶠ x in l ⊓ l', p x
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem toNat_manyOneEquiv {p : Set α} : ManyOneEquiv (toNat p) p
-- Mathlib/RingTheory/Polynomial/Dickson.lean
theorem dickson_one_one_eq_chebyshev_T [Invertible (2 : R)] :
    ∀ n, dickson 1 (1 : R) n = 2 * (Chebyshev.T R n).comp (C (⅟ 2) * X)
-- Mathlib/LinearAlgebra/Semisimple.lean
@[simp]
lemma isSemisimple_sub_algebraMap_iff {μ : R} :
    (f - algebraMap R (End R M) μ).IsSemisimple ↔ f.IsSemisimple
-- Mathlib/Topology/Maps/Basic.lean
theorem openEmbedding_id : OpenEmbedding (@id X)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem norm_eq_zero_iff {d : ℤ} (hd : d < 0) (z : ℤ√d) : z.norm = 0 ↔ z = 0
-- Mathlib/LinearAlgebra/QuadraticForm/IsometryEquiv.lean
/-- An isometric equivalence between two quadratic spaces `M₁, Q₁` and `M₂, Q₂` over a ring `R`,
is a linear equivalence between `M₁` and `M₂` that commutes with the quadratic forms. -/
-- Porting note(#5171): linter not ported yet @[nolint has_nonempty_instance]
structure IsometryEquiv (Q₁ : QuadraticMap R M₁ N) (Q₂ : QuadraticMap R M₂ N)
    extends M₁ ≃ₗ[R] M₂ where
  map_app' : ∀ m, Q₂ (toFun m) = Q₁ m
-- Mathlib/ModelTheory/LanguageMap.lean
theorem comp_sumElim {L3 : Language} (θ : L' →ᴸ L3) :
    θ ∘ᴸ ϕ.sumElim ψ = (θ ∘ᴸ ϕ).sumElim (θ ∘ᴸ ψ)
-- Mathlib/Topology/Basic.lean
theorem dense_iff_closure_eq : Dense s ↔ closure s = univ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- The weights in the centroid sum to 1, if the number of points,
converted to `k`, is not zero. -/
theorem sum_centroidWeights_eq_one_of_cast_card_ne_zero (h : (card s : k) ≠ 0) :
    ∑ i ∈ s, s.centroidWeights k i = 1
-- Mathlib/Data/Num/Lemmas.lean
theorem to_int_eq_succ_pred (n : PosNum) : (n : ℤ) = (n.pred' : ℕ) + 1
-- Mathlib/Topology/Basic.lean
@[ext]
protected theorem TopologicalSpace.ext :
    ∀ {f g : TopologicalSpace X}, IsOpen[f] = IsOpen[g] → f = g
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem toOrderMonoidWithZeroHom_eq_coe (f : α →+*o β) : f.toOrderMonoidWithZeroHom = f
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_union_Ici_of_le (h : a ≤ b) : Iic b ∪ Ici a = univ
-- Mathlib/Algebra/Star/Subalgebra.lean
theorem ext_adjoin_singleton {a : A} [FunLike F (adjoin R ({a} : Set A)) B]
    [AlgHomClass F R (adjoin R ({a} : Set A)) B] [StarAlgHomClass F R (adjoin R ({a} : Set A)) B]
    {f g : F} (h : f ⟨a, self_mem_adjoin_singleton R a⟩ = g ⟨a, self_mem_adjoin_singleton R a⟩) :
    f = g
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma hasEigenvalueAt (χ : Weight R L M) (x : L) :
    (toEnd R L M x).HasEigenvalue (χ x)
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : M} (ha : a ≠ 0) (S : Subsemiring R) (x : R) :
    x ∈ a • S ↔ a⁻¹ • x ∈ S
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem posDef_iff_nonneg {Q : QuadraticMap R₂ M N} : PosDef Q ↔ (∀ x, 0 ≤ Q x) ∧ Q.Anisotropic
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
@[simp]
lemma tensorQuotEquivQuotSMul_tmul_mk (I : Ideal R) (x : M) (r : R) :
    tensorQuotEquivQuotSMul M I (x ⊗ₜ[R] Ideal.Quotient.mk I r) =
      Submodule.Quotient.mk (r • x)
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_mono : Monotone (ceil : α → ℕ)
-- Mathlib/CategoryTheory/Closed/FunctorCategory.lean
/-- If `C` is a monoidal closed category and `D` is groupoid, then the functor category `D ⥤ C`,
with the pointwise monoidal structure, is monoidal closed. -/
@[simps! closed_adj]
instance monoidalClosed : MonoidalClosed (D ⥤ C)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
theorem prod_div_distrib : ∏ x ∈ s, f x / g x = (∏ x ∈ s, f x) / ∏ x ∈ s, g x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
theorem RCLike.uniqueNonUnitalContinuousFunctionalCalculus_of_compactSpace_quasispectrum
    [TopologicalSpace A] [T2Space A] [NonUnitalRing A] [StarRing A] [Module 𝕜 A]
    [IsScalarTower 𝕜 A A] [SMulCommClass 𝕜 A A] [h : ∀ a : A, CompactSpace (quasispectrum 𝕜 a)] :
    UniqueNonUnitalContinuousFunctionalCalculus 𝕜 A
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem comap_exp_atTop : comap exp atTop = atTop
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem addVal_eq_top_iff {a : R} : addVal R a = ⊤ ↔ a = 0
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp]
theorem val_zero : (0 : HomogeneousLocalization 𝒜 x).val = 0
-- Mathlib/Algebra/Algebra/Operations.lean
@[simp]
theorem toSubMulAction_one : (1 : Submodule R A).toSubMulAction = 1
-- Mathlib/Data/Fin/Tuple/Curry.lean
lemma curry_two_eq_curry {p : Fin 2 → Type u} {τ : Type u}
    (f : ((i : Fin 2) → p i) → τ) :
    curry f = Function.curry (f ∘ (piFinTwoEquiv p).symm)
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem one_mem_one : (1 : Set α) ∈ (1 : Filter α)
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem coe_subtype : (S.subtype : S → A) = Subtype.val
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- If `‖f n‖ ≤ C * r ^ n` for all `n : ℕ` and some `r < 1`, then the partial sums of `f` form a
Cauchy sequence. This lemma does not assume `0 ≤ r` or `0 ≤ C`. -/
theorem cauchySeq_finset_of_geometric_bound (hr : r < 1) (hf : ∀ n, ‖f n‖ ≤ C * r ^ n) :
    CauchySeq fun s : Finset ℕ ↦ ∑ x ∈ s, f x
-- Mathlib/Topology/Separation.lean
/-- In a (weakly) locally compact R₁ space, compact closed neighborhoods of a point `x`
form a basis of neighborhoods of `x`. -/
theorem isCompact_isClosed_basis_nhds (x : X) :
    (𝓝 x).HasBasis (fun K => K ∈ 𝓝 x ∧ IsCompact K ∧ IsClosed K) (·)
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem coe_isComplEquivProj_symm_apply (f : { f : E →ₗ[R] p // ∀ x : p, f x = x }) :
    (p.isComplEquivProj.symm f : Submodule R E) = ker (f : E →ₗ[R] p)
-- Mathlib/Topology/Bornology/Basic.lean
theorem ext_iff' {t t' : Bornology α} :
    t = t' ↔ ∀ s, s ∈ @cobounded α t ↔ s ∈ @cobounded α t'
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
/-- If a function converges along a filter to a limit `a`, is integrable along this filter, and
all elements of the filter have infinite measure, then the limit has to vanish. -/
lemma IntegrableAtFilter.eq_zero_of_tendsto
    (h : IntegrableAtFilter f l μ) (h' : ∀ s ∈ l, μ s = ∞) {a : E}
    (hf : Tendsto f l (𝓝 a)) : a = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
/-- If `f,g` is coreflexive, then `g,f` is coreflexive. -/
theorem IsCoreflexivePair.swap [IsCoreflexivePair f g] : IsCoreflexivePair g f
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem sup_comm (a b : α) : a ⊔ b = b ⊔ a
-- Mathlib/RingTheory/WittVector/InitTail.lean
theorem coeff_select (x : 𝕎 R) (n : ℕ) :
    (select P x).coeff n = aeval x.coeff (selectPoly P n)
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem pointed_zero : (0 : ConvexCone 𝕜 E).Pointed
-- Mathlib/Topology/MetricSpace/Gluing.lean
/-- The right injection of a space in a disjoint union is an isometry -/
theorem isometry_inr : Isometry (Sum.inr : Y → X ⊕ Y)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem reverseOpEquiv_opComm :
    AlgEquiv.opComm (reverseOpEquiv (Q := Q)) = reverseOpEquiv.symm