ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/BoundedOrder.lean
theorem min_top_right [OrderTop α] (a : α) : min a ⊤ = a
-- Mathlib/Logic/Relation.lean
theorem comp_iff {r : α → Prop → Prop} : r ∘r (· ↔ ·) = r
-- Mathlib/Analysis/Convex/Jensen.lean
/-- Convex **Jensen's inequality**, `Finset.centerMass` version. -/
theorem ConvexOn.map_centerMass_le (hf : ConvexOn 𝕜 s f) (h₀ : ∀ i ∈ t, 0 ≤ w i)
    (h₁ : 0 < ∑ i ∈ t, w i) (hmem : ∀ i ∈ t, p i ∈ s) :
    f (t.centerMass w p) ≤ t.centerMass w (f ∘ p)
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
theorem mul_inv' (u : G₀ˣ) : u * (u : G₀)⁻¹ = 1
-- Mathlib/CategoryTheory/Abelian/Opposite.lean
/-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_subset_Ioc_union_Ioo : Ioo a c ⊆ Ioc a b ∪ Ioo b c
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem zero_divInt (n) : 0 /. n = 0
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuous_ciInf {f : ι → α → δ'} (bdd : ∀ x, BddBelow (range fun i => f i x))
    (h : ∀ i, UpperSemicontinuous (f i)) : UpperSemicontinuous fun x' => ⨅ i, f i x'
-- Mathlib/Analysis/Calculus/Deriv/Shift.lean
/-- Translation in the domain does not change the derivative. -/
lemma deriv_comp_const_add {𝕜 : Type*} [NontriviallyNormedField 𝕜] (a x : 𝕜) {𝕜' : Type*}
    [NormedAddCommGroup 𝕜'] [NormedSpace 𝕜 𝕜'] {h : 𝕜 → 𝕜'}
    (hh : DifferentiableAt 𝕜 h (a + x)) :
    deriv (fun x ↦ h (a + x)) x = deriv h (a + x)
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- Let `R` be a topological ring such that zero is not an isolated point (e.g., a nontrivially
normed field, see `NormedField.punctured_nhds_neBot`). Let `M` be a nontrivial module over `R`
such that `c • x = 0` implies `c = 0 ∨ x = 0`. Then `M` has no isolated points. We formulate this
using `NeBot (𝓝[≠] x)`.

This lemma is not an instance because Lean would need to find `[ContinuousSMul ?m_1 M]` with
unknown `?m_1`. We register this as an instance for `R = ℝ` in `Real.punctured_nhds_module_neBot`.
One can also use `haveI := Module.punctured_nhds_neBot R M` in a proof.
-/
theorem Module.punctured_nhds_neBot [Nontrivial M] [NeBot (𝓝[≠] (0 : R))] [NoZeroSMulDivisors R M]
    (x : M) : NeBot (𝓝[≠] x)
-- Mathlib/Data/Real/Hyperreal.lean
theorem IsSt.mul {x y : ℝ*} {r s : ℝ} (hxr : IsSt x r) (hys : IsSt y s) : IsSt (x * y) (r * s)
-- Mathlib/Data/List/Infix.lean
theorem prefix_iff_eq_append : l₁ <+: l₂ ↔ l₁ ++ drop (length l₁) l₂ = l₂
-- Mathlib/Data/List/InsertNth.lean
theorem getElem_insertNth_add_succ (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length)
    (hk : n + k + 1 < (insertNth n x l).length := (by
      rwa [length_insertNth _ _ (by omega), Nat.succ_lt_succ_iff])) :
    (insertNth n x l)[n + k + 1] = l[n + k]
-- Mathlib/Algebra/Star/Subalgebra.lean
@[aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_adjoin (s : Set A) : s ⊆ adjoin R s
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem whiskerRight_comp_symm {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d) :
    η ▷ g ▷ h = (α_ f g h).hom ≫ η ▷ (g ≫ h) ≫ (α_ f' g h).inv
-- Mathlib/Topology/MetricSpace/PiNat.lean
/-- Given a closed nonempty subset `s` of `Π (n : ℕ), E n`, there exists a Lipschitz retraction
onto this set, i.e., a Lipschitz map with range equal to `s`, equal to the identity on `s`. -/
theorem exists_lipschitz_retraction_of_isClosed {s : Set (∀ n, E n)} (hs : IsClosed s)
    (hne : s.Nonempty) :
    ∃ f : (∀ n, E n) → ∀ n, E n, (∀ x ∈ s, f x = x) ∧ range f = s ∧ LipschitzWith 1 f
-- Mathlib/Order/Filter/Basic.lean
theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp]
theorem stalkToFiberRingHom_germ (U : Opens (PrimeSpectrum.Top R)) (x : U)
    (s : (structureSheaf R).1.obj (op U)) :
    stalkToFiberRingHom R x ((structureSheaf R).presheaf.germ x s) = s.1 x
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem WalkingPair.equivBool_apply_left : WalkingPair.equivBool left = true
-- Mathlib/Order/Heyting/Regular.lean
theorem isRegular_compl (a : α) : IsRegular aᶜ
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- Symmetric entourages form a basis of `𝓤 α` -/
theorem UniformSpace.hasBasis_symmetric :
    (𝓤 α).HasBasis (fun s : Set (α × α) => s ∈ 𝓤 α ∧ SymmetricRel s) id
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem one_le_inv₀ (ha : a ≠ 0) : 1 ≤ a⁻¹ ↔ a ≤ 1
-- Mathlib/Data/Finset/Sum.lean
theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem DifferentiableOn.exp (hc : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => Real.exp (f x)) s
-- Mathlib/Order/Bounds/Basic.lean
theorem lub_Iio_eq_self_or_Iio_eq_Iic [PartialOrder γ] {j : γ} (i : γ) (hj : IsLUB (Iio i) j) :
    j = i ∨ Iio i = Iic j
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/Deriv.lean
/-- If a function has a non-zero strict derivative at all points, then it is an open map. -/
theorem isOpenMap_of_hasStrictDerivAt {f' : 𝕜 → 𝕜}
    (hf : ∀ x, HasStrictDerivAt f (f' x) x) (h0 : ∀ x, f' x ≠ 0) : IsOpenMap f
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem lcm_dvd_lcm_mul_right_right [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm m (n * k)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem reindex_trans {l₂ o₂ : Type*} (eₘ : m ≃ l) (eₙ : n ≃ o) (eₘ₂ : l ≃ l₂) (eₙ₂ : o ≃ o₂) :
    (reindex eₘ eₙ).trans (reindex eₘ₂ eₙ₂) =
      (reindex (eₘ.trans eₘ₂) (eₙ.trans eₙ₂) : Matrix m n α ≃ _)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succRecOn_zero {motive : ∀ n, Fin n → Sort _} {zero succ} (n) :
    @Fin.succRecOn (n + 1) 0 motive zero succ = zero n
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
@[reassoc (attr := simp)]
theorem diagonalObjPullbackFstIso_inv_fst_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (diagonalObjPullbackFstIso f g).inv ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
      pullback.fst _ _ ≫ pullback.fst _ _
-- Mathlib/Data/Set/Function.lean
theorem EqOn.congr_antitoneOn (h : s.EqOn f₁ f₂) : AntitoneOn f₁ s ↔ AntitoneOn f₂ s
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma preimage_coe_Ico_top (x : ℝ) : Real.toEReal ⁻¹' Ico x ⊤ = Ici x
-- Mathlib/Order/WellFounded.lean
protected theorem lt_succ {r : α → α → Prop} (wf : WellFounded r) {x : α} (h : ∃ y, r x y) :
    r x (wf.succ x)
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
lemma Triangle.isIso_of_isIsos {A B : Triangle C} (f : A ⟶ B)
    (h₁ : IsIso f.hom₁) (h₂ : IsIso f.hom₂) (h₃ : IsIso f.hom₃) : IsIso f
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem negSucc_not_pos (n : Nat) : 0 < -[n+1] ↔ False
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The natural transformation `π₁ ⟶ π₂` induced by `S.f` for all `S : ShortComplex C`. -/
@[simps] def π₁Toπ₂ : (π₁ : _ ⥤ C) ⟶ π₂
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem inl_mul_eq_smul [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M]
    (r : R) (x : tsze R M) :
    inl r * x = r •> x
-- Mathlib/Topology/Irreducible.lean
theorem Subtype.irreducibleSpace (h : IsIrreducible s) : IrreducibleSpace s
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem not_isSome_iff_eq_none : ¬o.isSome ↔ o = none
-- Mathlib/Data/Finset/Basic.lean
theorem mem_union_left (t : Finset α) (h : a ∈ s) : a ∈ s ∪ t
-- Mathlib/RingTheory/IntegralClosure/Algebra/Basic.lean
/-- If `S` is a sub-`R`-algebra of `A` and `S` is finitely-generated as an `R`-module,
  then all elements of `S` are integral over `R`. -/
theorem IsIntegral.of_mem_of_fg {A} [Ring A] [Algebra R A] (S : Subalgebra R A)
    (HS : S.toSubmodule.FG) (x : A) (hx : x ∈ S) : IsIntegral R x
-- Mathlib/Order/Filter/Bases.lean
@[simp]
theorem compl_diagonal_mem_prod {l₁ l₂ : Filter α} : (diagonal α)ᶜ ∈ l₁ ×ˢ l₂ ↔ Disjoint l₁ l₂
-- Mathlib/SetTheory/Game/Nim.lean
theorem moveRight_nim {o : Ordinal} (i) : (nim o).moveRight (toRightMovesNim i) = nim i
-- Mathlib/Analysis/Convex/Strict.lean
theorem IsOpen.strictConvex_iff (h : IsOpen s) : StrictConvex 𝕜 s ↔ Convex 𝕜 s
-- Mathlib/Data/Set/Basic.lean
theorem compl_setOf {α} (p : α → Prop) : { a | p a }ᶜ = { a | ¬p a }
-- Mathlib/RingTheory/EuclideanDomain.lean
theorem gcd_ne_zero_of_right (hp : q ≠ 0) : GCDMonoid.gcd p q ≠ 0
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. An integrable function is smaller than its mean on a set of positive
measure. -/
theorem measure_le_setAverage_pos (hμ : μ s ≠ 0) (hμ₁ : μ s ≠ ∞) (hf : IntegrableOn f s μ) :
    0 < μ ({x ∈ s | f x ≤ ⨍ a in s, f a ∂μ})
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
    (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxOn f s a) {g : α → γ}
    (hg : IsMaxOn g s a) : IsMaxOn (fun x => op (f x) (g x)) s a
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem ext' : A = ⟨A.1, ⟨A.e, A.2.2⟩⟩
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The composition of `C^n` functions on domains is `C^n`. -/
theorem ContDiffOn.comp' {s : Set E} {t : Set F} {g : F → G} {f : E → F} (hg : ContDiffOn 𝕜 n g t)
    (hf : ContDiffOn 𝕜 n f s) : ContDiffOn 𝕜 n (g ∘ f) (s ∩ f ⁻¹' t)
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps] -- porting note (#10618): was `simp`
theorem normSq_inv (z : K) : normSq z⁻¹ = (normSq z)⁻¹
-- Mathlib/Order/Sublattice.lean
@[simp] lemma supClosed (L : Sublattice α) : SupClosed (L : Set α)
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma sub_mem {x y} (hx : x ∈ I) (hy : y ∈ I) : x - y ∈ I
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem Continuous.integrableAt_nhds [TopologicalSpace α] [SecondCountableTopologyEither α E]
    [OpensMeasurableSpace α] {μ : Measure α} [IsLocallyFiniteMeasure μ] {f : α → E}
    (hf : Continuous f) (a : α) : IntegrableAtFilter f (𝓝 a) μ
-- Mathlib/Data/Set/Function.lean
theorem StrictAntiOn.comp [Preorder α] [Preorder β] [Preorder γ] {g : β → γ} {f : α → β} {s : Set α}
    {t : Set β} (hg : StrictAntiOn g t) (hf : StrictAntiOn f s) (hs : Set.MapsTo f s t) :
    StrictMonoOn (g ∘ f) s
-- Mathlib/Order/GaloisConnection.lean
@[simp]
theorem bddAbove_image (e : α ≃o β) {s : Set α} : BddAbove (e '' s) ↔ BddAbove s
-- Mathlib/Data/Seq/WSeq.lean
theorem get?_mem {s : WSeq α} {a n} : some a ∈ get? s n → a ∈ s
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_add_zsmul' (a b : α) (m : ℤ) :
    toIcoDiv hp (a + m • p) b = toIcoDiv hp a b - m
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- Rescaling a set by a factor `r` multiplies its measure by `abs (r ^ dim)`. -/
@[simp]
theorem addHaar_smul (r : ℝ) (s : Set E) :
    μ (r • s) = ENNReal.ofReal (abs (r ^ finrank ℝ E)) * μ s
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem Metric.uniformity_eq_comap_nhds_zero :
    𝓤 α = comap (fun p : α × α => dist p.1 p.2) (𝓝 (0 : ℝ))
-- Mathlib/Data/Sigma/Interval.lean
theorem card_Icc : (Icc a b).card = if h : a.1 = b.1 then (Icc (h.rec a.2) b.2).card else 0
-- Mathlib/Topology/Separation.lean
theorem eq_of_nhds_neBot [T2Space X] {x y : X} (h : NeBot (𝓝 x ⊓ 𝓝 y)) : x = y
-- Mathlib/Topology/Order.lean
theorem continuous_sSup_rng {t₁ : TopologicalSpace α} {t₂ : Set (TopologicalSpace β)}
    {t : TopologicalSpace β} (h₁ : t ∈ t₂) (hf : Continuous[t₁, t] f) :
    Continuous[t₁, sSup t₂] f
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_extract (hi lo : Nat) (x : BitVec n) (i : Nat) :
    getLsb (extractLsb hi lo x) i = (i ≤ (hi-lo) && getLsb x (lo+i))
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[simp]
theorem _root_.aemeasurable_union_iff {s t : Set α} :
    AEMeasurable f (μ.restrict (s ∪ t)) ↔
      AEMeasurable f (μ.restrict s) ∧ AEMeasurable f (μ.restrict t)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true
-- Mathlib/ModelTheory/Substructures.lean
/-- A substructure of a structure `M` is a set closed under application of function symbols. -/
structure Substructure where
  carrier : Set M
  fun_mem : ∀ {n}, ∀ f : L.Functions n, ClosedUnder f carrier
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem ι_normNoninc : (ι f g).NormNoninc
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem eq_zero_or_opow_omega_le_of_mul_eq_right {a b : Ordinal} (hab : a * b = b) :
    b = 0 ∨ (a^omega.{u}) ≤ b
-- Mathlib/ModelTheory/Encoding.lean
theorem card_sigma : #(Σn, L.Term (α ⊕ (Fin n))) = max ℵ₀ #(α ⊕ (Σi, L.Functions i))
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_subtype : ⇑(s.subtype) = ((↑) : s → K)
-- Mathlib/Topology/Sheaves/Stalks.lean
@[reassoc (attr := simp)]
lemma pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
    (f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : U) (V : Opens Y)
    (hV : U ≤ (Opens.map f).obj V) :
    ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
      ((pullback C f).obj F).map (homOfLE hV).op ≫ germToPullbackStalk C f F U x =
        F.germ ⟨f x, hV x.2⟩
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem map_int_add [AddCommGroupWithOne G] [AddGroupWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℤ) (x : G) : f (↑n + x) = f x + n
-- Mathlib/Order/Cover.lean
theorem CovBy.unique_right (hb : a ⋖ b) (hc : a ⋖ c) : b = c
-- Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean
/-- In finite dimensions, over an algebraically closed field, every linear endomorphism has an
eigenvalue. -/
theorem exists_eigenvalue [IsAlgClosed K] [FiniteDimensional K V] [Nontrivial V] (f : End K V) :
    ∃ c : K, f.HasEigenvalue c
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast]
theorem coe_finset_inf (f : ι → Closeds α) (s : Finset ι) :
    (↑(s.inf f) : Set α) = s.inf ((↑) ∘ f)
-- Mathlib/Data/List/Intervals.lean
@[simp]
theorem succ_singleton {n : ℕ} : Ico n (n + 1) = [n]
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiffAt_transDiffeomorph_right {f : M' → M} {x} :
    ContMDiffAt I' (I.transDiffeomorph e) n f x ↔ ContMDiffAt I' I n f x
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem DifferentiableAt.const_cpow (hf : DifferentiableAt ℂ f x) (h0 : c ≠ 0 ∨ f x ≠ 0) :
    DifferentiableAt ℂ (fun x => c ^ f x) x
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem exists_lt_of_lt_ciSup' {f : ι → α} {a : α} (h : a < ⨆ i, f i) : ∃ i, a < f i
-- Mathlib/Order/Bounded.lean
theorem unbounded_le_inter_lt [LinearOrder α] (a : α) :
    Unbounded (· ≤ ·) (s ∩ { b | a < b }) ↔ Unbounded (· ≤ ·) s
-- Mathlib/Algebra/Lie/CartanMatrix.lean
private theorem adF_of_eq_eq_zero (i : B) (h : A i i = 2) : adF R A ⟨i, i⟩ = 0
-- Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
theorem le_orthogonal_orthogonal (b : B.IsRefl) : N ≤ B.orthogonal (B.orthogonal N)
-- Mathlib/CategoryTheory/Enriched/Basic.lean
@[simp]
theorem ForgetEnrichment.of_to (X : ForgetEnrichment W C) :
    ForgetEnrichment.of W (ForgetEnrichment.to W X) = X
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toBotHom (f : SupBotHom α β) : ⇑f.toBotHom = f
-- .lake/packages/lean4/src/lean/Init/Core.lean
/--
The analogue of `Quot.sound`: If `a` and `b` are related by the equivalence relation,
then they have equal equivalence classes.
-/
theorem sound {α : Sort u} {s : Setoid α} {a b : α} : a ≈ b → Quotient.mk s a = Quotient.mk s b
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- If `μ` is a finite measure and the indicators of measurable sets `Aᵢ` tend pointwise
almost everywhere to the indicator of a measurable set `A`, then the measures `μ Aᵢ` tend to
the measure `μ A`. -/
lemma tendsto_measure_of_ae_tendsto_indicator_of_isFiniteMeasure [IsCountablyGenerated L]
    {μ : Measure α} [IsFiniteMeasure μ] (A_mble : MeasurableSet A)
    (As_mble : ∀ i, MeasurableSet (As i)) (h_lim : ∀ᵐ x ∂μ, ∀ᶠ i in L, x ∈ As i ↔ x ∈ A) :
    Tendsto (fun i ↦ μ (As i)) L (𝓝 (μ A))
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem inf_eq_inter : (Inf.inf : Finset α → Finset α → Finset α) = Inter.inter
-- Mathlib/Algebra/Associated/Basic.lean
theorem eq_of_prime_pow_eq' (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₂)
    (h : p₁ ^ k₁ = p₂ ^ k₂) : p₁ = p₂
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
theorem inclusion.coe_eq (s : SubMulAction M α) :
    ⇑s.inclusion = Subtype.val
-- Mathlib/Order/Bounds/Basic.lean
theorem nonempty_of_not_bddAbove [ha : Nonempty α] (h : ¬BddAbove s) : s.Nonempty
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem equiv_trans (f : α ≃ₜ β) (g : β ≃ₜ γ) :
    Compacts.equiv (f.trans g) = (Compacts.equiv f).trans (Compacts.equiv g)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mul_mem_mul {r s} (hr : r ∈ I) (hs : s ∈ J) : r * s ∈ I * J
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_not_le {a b : Nat} (h : ¬ b ≤ a) : a ≤ b
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem mul_integral_comp_mul_left : (c * ∫ x in a..b, f (c * x)) = ∫ x in c * a..c * b, f x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem findIdx_get {xs : List α} {w : xs.findIdx p < xs.length} :
    p (xs.get ⟨xs.findIdx p, w⟩)
-- Mathlib/Topology/MetricSpace/GromovHausdorff.lean
theorem GHSpace.toGHSpace_rep (p : GHSpace) : toGHSpace p.Rep = p
-- Mathlib/Algebra/GroupWithZero/Commute.lean
@[simp]
theorem inv_right_iff₀ : Commute a b⁻¹ ↔ Commute a b
-- Mathlib/Algebra/Ring/Defs.lean
theorem neg_eq_neg_one_mul (a : α) : -a = -1 * a
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem right_assoc' :
    (_ ◁ T.mul) ≫ actRight P Q =
      (α_ _ T.X T.X).inv ≫ (actRight P Q ▷ T.X) ≫ actRight P Q
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem surjective_of_iterate_surjective {n : ℕ} (hn : n ≠ 0) (h : Surjective (f' ^ n)) :
    Surjective f'
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_subset_of_mem {S : Set (Set α)} {t : Set α} (tS : t ∈ S) : ⋂₀ S ⊆ t
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
@[simp]
theorem mapMono_δ₀ {n : ℕ} : mapMono K (δ (0 : Fin (n + 2))) = K.d (n + 1) n
-- Mathlib/Topology/Irreducible.lean
theorem IsPreirreducible.interior (ht : IsPreirreducible t) : IsPreirreducible (interior t)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If a set of functions is equicontinuous at some `x₀`, its closure for the product topology is
also equicontinuous at `x₀`. -/
protected theorem Set.EquicontinuousAt.closure {A : Set (X → α)} {x₀ : X}
    (hA : A.EquicontinuousAt x₀) : (closure A).EquicontinuousAt x₀
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem degree_C_mul_T_le (n : ℤ) (a : R) : degree (C a * T n) ≤ n
-- Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean
/-- Lower bound for `γ`. (The true value is about 0.57.) -/
lemma one_half_lt_eulerMascheroniConstant : 1 / 2 < eulerMascheroniConstant
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem not_differentiableAt_abs_zero : ¬ DifferentiableAt ℝ (abs : ℝ → ℝ) 0
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
@[reassoc (attr := simp)]
lemma associator_inv_fst (X Y Z : C) :
    (α_ X Y Z).inv ≫ fst _ _ ≫ fst _ _ = fst _ _
-- Mathlib/Data/Nat/BitIndices.lean
theorem not_mem_bitIndices_self (n : ℕ) : n ∉ n.bitIndices
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_subset_biInter_left {s s' : Set α} {t : α → Set β} (h : s' ⊆ s) :
    ⋂ x ∈ s, t x ⊆ ⋂ x ∈ s', t x
-- Mathlib/Algebra/Lie/Classical.lean
theorem indefiniteDiagonal_assoc :
    indefiniteDiagonal (Unit ⊕ l) l R =
      Matrix.reindexLieEquiv (Equiv.sumAssoc Unit l l).symm
        (Matrix.fromBlocks 1 0 0 (indefiniteDiagonal l l R))
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_sub_le (a b c : α) : |a - c| ≤ |a - b| + |b - c|
-- Mathlib/Tactic/NormNum/Pow.lean
theorem isInt_zpow_pos {α : Type*} [DivisionRing α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsInt (a ^ nb) (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp] lemma length_tail_add_one {p : G.Walk x y} (hp : ¬ p.Nil) :
    (p.tail hp).length + 1 = p.length
-- Mathlib/Algebra/Ring/Defs.lean
theorem mul_add_one [LeftDistribClass α] (a b : α) : a * (b + 1) = a * b + a
-- Mathlib/GroupTheory/Complement.lean
theorem coe_transferFunction (q : G ⧸ H) : ↑(transferFunction H g q) = q
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mdifferentiableAt_atlas (h : e ∈ atlas H M) {x : M} (hx : x ∈ e.source) :
    MDifferentiableAt I I e x
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem piPremeasure_pi {s : ∀ i, Set (α i)} (hs : (pi univ s).Nonempty) :
    piPremeasure m (pi univ s) = ∏ i, m i (s i)
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem comp_codRestrict (f : M ↪[L] N) (g : N ↪[L] P) (p : L.Substructure P) (h : ∀ b, g b ∈ p) :
    ((codRestrict p g h).comp f : M ↪[L] p) = codRestrict p (g.comp f) fun _ => h _
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem Continuous.prod_map {f : Z → X} {g : W → Y} (hf : Continuous f) (hg : Continuous g) :
    Continuous fun p : Z × W => (f p.1, g p.2)
-- Mathlib/Order/Monotone/Basic.lean
lemma antitone_iff_apply₂ : Antitone f ↔ ∀ i, Antitone (f · i)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_extract_loop_ge (as bs : Array α) (size start : Nat) (hge : i ≥ bs.size)
    (h : i < (extract.loop as size start bs).size)
    (h' := get_extract_loop_ge_aux as bs size start hge h) :
    (extract.loop as size start bs)[i] = as[start + i - bs.size]
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma norm_term_le {f g : ℕ → ℂ} (s : ℂ) {n : ℕ} (h : ‖f n‖ ≤ ‖g n‖) :
    ‖term f s n‖ ≤ ‖term g s n‖
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem Measurable.ccosh : Measurable fun x => Complex.cosh (f x)
-- Mathlib/Analysis/Convex/Basic.lean
/-- Alternative definition of set convexity, using division. -/
theorem convex_iff_div :
    Convex 𝕜 s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s →
      ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b → (a / (a + b)) • x + (b / (a + b)) • y ∈ s
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@[simp high, mfld_simps]
theorem coordChange_model_space (b b' x : F) :
    (tangentBundleCore 𝓘(𝕜, F) F).coordChange (achart F b) (achart F b') x = 1
-- Mathlib/CategoryTheory/Endomorphism.lean
theorem Aut_mul_def (f g : Aut X) : f * g = g.trans f
-- Mathlib/RingTheory/RootsOfUnity/Complex.lean
theorem IsPrimitiveRoot.arg_eq_pi_iff {n : ℕ} {ζ : ℂ} (hζ : IsPrimitiveRoot ζ n) (hn : n ≠ 0) :
    ζ.arg = Real.pi ↔ ζ = -1
-- Mathlib/Order/Filter/Lift.lean
@[simp]
theorem lift_top (g : Set α → Filter β) : (⊤ : Filter α).lift g = g univ
-- Mathlib/RingTheory/Ideal/Maps.lean
/-- If the target is not the zero ring, then one is not in the kernel. -/
theorem not_one_mem_ker [Nontrivial S] (f : F) : (1 : R) ∉ ker f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_inter_Iio : Iio a ∩ Iio b = Iio (a ⊓ b)
-- Mathlib/Order/Minimal.lean
theorem minimals_union : minimals r (s ∪ t) ⊆ minimals r s ∪ minimals r t
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem concat_xor_concat (x y : BitVec w) (a b : Bool) :
    (concat x a) ^^^ (concat y b) = concat (x ^^^ y) (xor a b)
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma _root_.AEMeasurable.singularPart {β : Type*} {_ : MeasurableSpace β} {f : α → β}
    (hf : AEMeasurable f μ) (ν : Measure α) :
    AEMeasurable f (μ.singularPart ν)
-- Mathlib/SetTheory/Game/Impartial.lean
/-- This lemma doesn't require `H` to be impartial. -/
theorem equiv_iff_add_equiv_zero (H : PGame) : (H ≈ G) ↔ (H + G ≈ 0)
-- Mathlib/Logic/Basic.lean
@[simp] theorem xor_false : Xor' False = id
-- Mathlib/Order/Atoms.lean
@[simp] lemma isCoatom_compl : IsCoatom aᶜ ↔ IsAtom a
-- Mathlib/Order/Filter/Basic.lean
theorem mem_iInf_finite {ι : Type*} {f : ι → Filter α} (s) :
    s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i
-- Mathlib/Logic/Basic.lean
@[simp] theorem eq_iff_eq_cancel_right {a b : α} : (∀ {c}, a = c ↔ b = c) ↔ a = b
-- Mathlib/RingTheory/Ideal/Basic.lean
/-- All ideals in a division (semi)ring are trivial. -/
theorem eq_bot_or_top : I = ⊥ ∨ I = ⊤
-- Mathlib/Data/Fintype/Units.lean
@[simp]
theorem Fintype.card_units_int : Fintype.card ℤˣ = 2
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem id_comp : (CoalgHom.id R B).comp φ = φ