ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Combinatorics/SimpleGraph/Finite.lean
theorem IsRegularOfDegree.degree_eq {d : ℕ} (h : G.IsRegularOfDegree d) (v : V) : G.degree v = d
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem ramificationIdx_ne_zero (hp0 : map f p ≠ ⊥) (hP : P.IsPrime) (le : map f p ≤ P) :
    ramificationIdx f p P ≠ 0
-- Mathlib/Topology/Order.lean
theorem setOf_isOpen_sup (t₁ t₂ : TopologicalSpace α) :
    { s | IsOpen[t₁ ⊔ t₂] s } = { s | IsOpen[t₁] s } ∩ { s | IsOpen[t₂] s }
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem span_union (s t : Set L) : lieSpan R L (s ∪ t) = lieSpan R L s ⊔ lieSpan R L t
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.eq_of_subset_indep (hI : M.Basis I X) (hJ : M.Indep J) (hIJ : I ⊆ J) (hJX : J ⊆ X) :
    I = J
-- Mathlib/SetTheory/Game/PGame.lean
@[trans]
protected theorem Equiv.trans {x y z : PGame} : (x ≈ y) → (y ≈ z) → (x ≈ z)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem smul_apply (a : G) (f : CauSeq β abv) (i : ℕ) : (a • f) i = a • f i
-- Mathlib/GroupTheory/Perm/Support.lean
theorem disjoint_conj (h : Perm α) : Disjoint (h * f * h⁻¹) (h * g * h⁻¹) ↔ Disjoint f g
-- Mathlib/Topology/Bornology/Basic.lean
/-- A constructor for bornologies by specifying the bounded sets,
and showing that they satisfy the appropriate conditions. -/
@[simps! cobounded]
def Bornology.ofBounded' {α : Type*} (B : Set (Set α))
    (empty_mem : ∅ ∈ B)
    (subset_mem : ∀ s₁ ∈ B, ∀ s₂ ⊆ s₁, s₂ ∈ B)
    (union_mem : ∀ s₁ ∈ B, ∀ s₂ ∈ B, s₁ ∪ s₂ ∈ B)
    (sUnion_univ : ⋃₀ B = univ) :
    Bornology α
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem integral_prod_mul {L : Type*} [RCLike L] (f : α → L) (g : β → L) :
    ∫ z, f z.1 * g z.2 ∂μ.prod ν = (∫ x, f x ∂μ) * ∫ y, g y ∂ν
-- Mathlib/Tactic/NormNum/NatFib.lean
theorem isFibAux_zero : IsFibAux 0 0 1
-- Mathlib/Order/Directed.lean
protected theorem IsMin.isBot [IsDirected α (· ≥ ·)] (h : IsMin a) : IsBot a
-- Mathlib/RingTheory/WittVector/Verschiebung.lean
/-- `WittVector.verschiebung` is a polynomial function. -/
@[is_poly]
theorem verschiebung_isPoly : IsPoly p fun R _Rcr => @verschiebung p R hp _Rcr
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
theorem homEquiv_id (X : C) : adj.homEquiv X _ (𝟙 _) = adj.unit.app X
-- Mathlib/CategoryTheory/Generator.lean
theorem isCoseparator_prod_of_isCoseparator_left (G H : C) [HasBinaryProduct G H]
    (hG : IsCoseparator G) : IsCoseparator (G ⨯ H)
-- Mathlib/Algebra/Ring/Equiv.lean
/-- A ring isomorphism preserves addition. -/
protected theorem map_add (e : R ≃+* S) (x y : R) : e (x + y) = e x + e y
-- Mathlib/Data/Analysis/Topology.lean
/-- A `Ctop` realizer for the topological space `T` is a `Ctop`
  which generates `T`. -/
structure Ctop.Realizer (α) [T : TopologicalSpace α] where
  σ : Type*
  F : Ctop α σ
  eq : F.toTopsp = T
-- Mathlib/Order/Basic.lean
theorem le_of_strongLT (h : a ≺ b) : a ≤ b
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem _root_.MeasurableEmbedding.integrableAtFilter_iff_comap [MeasurableSpace β] {e : α → β}
    (he : MeasurableEmbedding e) {f : β → E} {μ : Measure β} :
    IntegrableAtFilter f (l.map e) μ ↔ IntegrableAtFilter (f ∘ e) l (μ.comap e)
-- Mathlib/Tactic/CC/Lemmas.lean
theorem iff_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ↔ b) = a
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem _root_.Measurable.lintegral_kernel_prod_left {f : β → α → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun y => ∫⁻ x, f x y ∂κ y
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem smul_eq_map [SMul K β] (k : K) (f : α →ₛ β) : k • f = f.map (k • ·)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem countP_add (s t) : countP p (s + t) = countP p s + countP p t
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem fin_map {n} {s : Finset ℕ} : (s.fin n).map Fin.valEmbedding = s.filter (· < n)
-- Mathlib/FieldTheory/RatFunc/Defs.lean
theorem liftOn_mk {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ p, f p 0 = f 0 1)
    (H' : ∀ {p q p' q'} (_hq : q ≠ 0) (_hq' : q' ≠ 0), q' * p = q * p' → f p q = f p' q')
    (H : ∀ {p q p' q'} (_hq : q ∈ K[X]⁰) (_hq' : q' ∈ K[X]⁰), q' * p = q * p' → f p q = f p' q' :=
      fun {p q p' q'} hq hq' h => H' (nonZeroDivisors.ne_zero hq) (nonZeroDivisors.ne_zero hq') h) :
    (RatFunc.mk p q).liftOn f @H = f p q
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem eventually_norm_pow_le (a : α) : ∀ᶠ n : ℕ in atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
theorem add_coe_eq_top_iff {x : WithTop α} {y : α} : x + y = ⊤ ↔ x = ⊤
-- Mathlib/Order/LiminfLimsup.lean
theorem blimsup_monotone_filter (h : f ≤ g) : blimsup u f p ≤ blimsup u g p
-- Mathlib/Data/Matroid/Closure.lean
lemma Indep.base_of_ground_subset_closure (hI : M.Indep I) (h : M.E ⊆ M.closure I) : M.Base I
-- Mathlib/Data/Nat/Count.lean
theorem count_strict_mono {m n : ℕ} (hm : p m) (hmn : m < n) : count p m < count p n
-- Mathlib/Analysis/Analytic/Basic.lean
/-- For `r` strictly smaller than the radius of `p`, then `‖pₙ‖ rⁿ` is bounded. -/
theorem norm_mul_pow_le_of_lt_radius (p : FormalMultilinearSeries 𝕜 E F) {r : ℝ≥0}
    (h : (r : ℝ≥0∞) < p.radius) : ∃ C > 0, ∀ n, ‖p n‖ * (r : ℝ) ^ n ≤ C
-- Mathlib/Analysis/Convex/Star.lean
theorem StarConvex.linear_preimage {s : Set F} (f : E →ₗ[𝕜] F) (hs : StarConvex 𝕜 (f x) s) :
    StarConvex 𝕜 x (f ⁻¹' s)
-- Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean
lemma homologyShiftIso_hom_app (n a a' : ℤ) (ha' : n + a = a') (K : CochainComplex C ℤ) :
    ((homologyFunctor C (ComplexShape.up ℤ) 0).shiftIso n a a' ha').hom.app
      ((quotient _ _).obj K) =
    (homologyFunctor _ _ a).map (((quotient _ _).commShiftIso n).inv.app K) ≫
      (homologyFunctorFactors _ _ a).hom.app (K⟦n⟧) ≫
      ((HomologicalComplex.homologyFunctor _ _ 0).shiftIso n a a' ha').hom.app K ≫
      (homologyFunctorFactors _ _ a').inv.app K
-- Mathlib/Algebra/GroupWithZero/Hom.lean
@[simp]
lemma coe_copy {_ : MulZeroOneClass α} {_ : MulZeroOneClass β} (f : α →*₀ β) (f' : α → β) (h) :
    (f.copy f' h) = f'
-- Mathlib/Data/W/Cardinal.lean
/-- If, for any `a : α`, `β a` is finite, then the cardinality of `WType β`
  is at most the maximum of the cardinality of `α` and `ℵ₀`  -/
theorem cardinal_mk_le_max_aleph0_of_finite [∀ a, Finite (β a)] : #(WType β) ≤ max #α ℵ₀
-- Mathlib/Analysis/MellinTransform.lean
/-- If `f` is a locally integrable real-valued function which is `O(x ^ (-a))` at `∞`, then for any
`s < a`, its Mellin transform converges on some neighbourhood of `+∞`. -/
theorem mellin_convergent_top_of_isBigO {f : ℝ → ℝ}
    (hfc : AEStronglyMeasurable f <| volume.restrict (Ioi 0)) {a s : ℝ}
    (hf : f =O[atTop] (· ^ (-a))) (hs : s < a) :
    ∃ c : ℝ, 0 < c ∧ IntegrableOn (fun t : ℝ => t ^ (s - 1) * f t) (Ioi c)
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem star_eq_adjoint (A : E →L[𝕜] E) : star A = A†
-- Mathlib/Analysis/LocallyConvex/Basic.lean
protected theorem Balanced.closure (hA : Balanced 𝕜 A) : Balanced 𝕜 (closure A)
-- Mathlib/Algebra/Polynomial/Div.lean
theorem divByMonic_eq_zero_iff [Nontrivial R] (hq : Monic q) : p /ₘ q = 0 ↔ degree p < degree q
-- Mathlib/Algebra/GradedMonoid.lean
/-- The linter message "error: SetLike.GradeZero.coe_mul.{u_3, u_2, u_1} Left-hand side does
  not simplify, when using the simp lemma on itself." is wrong. The LHS does simplify. -/
@[nolint simpNF, simp, norm_cast] theorem coe_mul (a b : A 0) : ↑(a * b) = (↑a * ↑b : R)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContinuousLinearEquiv.contDiff (f : E ≃L[𝕜] F) : ContDiff 𝕜 n f
-- Mathlib/Data/ENNReal/Basic.lean
@[simp]
theorem iUnion_Iic_coe_nat : ⋃ n : ℕ, Iic (n : ℝ≥0∞) = {∞}ᶜ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem testBit_to_div_mod {x : Nat} : testBit x i = decide (x / 2^i % 2 = 1)
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
theorem ind : AffineIndependent k b
-- Mathlib/Topology/Constructions.lean
@[simp]
theorem inducing_prod_const {y : Y} {f : X → Z} : (Inducing fun x => (f x, y)) ↔ Inducing f
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousOn.finset_inf (hs : ∀ i ∈ s, ContinuousOn (f i) t) :
    ContinuousOn (s.inf f) t
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem signBijAux_injOn {n : ℕ} {f : Perm (Fin n)} :
    (finPairsLT n : Set (Σ _, Fin n)).InjOn (signBijAux f)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem limit.isLimit_lift {F : J ⥤ C} [HasLimit F] (c : Cone F) :
    (limit.isLimit F).lift c = limit.lift F c
-- Mathlib/Analysis/Normed/Module/Dual.lean
@[simp]
theorem polar_univ : polar 𝕜 (univ : Set E) = {(0 : Dual 𝕜 E)}
-- Mathlib/Order/CompactlyGenerated/Basic.lean
protected theorem DirectedOn.disjoint_sSup_left (h : DirectedOn (· ≤ ·) s) :
    Disjoint (sSup s) a ↔ ∀ ⦃b⦄, b ∈ s → Disjoint b a
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousAt.continuousOn {f : α → β} {s : Set α} (hcont : ∀ x ∈ s, ContinuousAt f x) :
    ContinuousOn f s
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp] protected theorem one : IsSelfAdjoint (1 : R)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addMap_of_Y_eq {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2)
    (hy' : P y * Q z ^ 3 = W.negY Q * P z ^ 3) : W.addMap ⟦P⟧ ⟦Q⟧ = ⟦![1, 1, 0]⟧
-- Mathlib/Order/Irreducible.lean
/-- In a well-founded lattice, any element is the supremum of finitely many sup-irreducible
elements. This is the order-theoretic analogue of prime factorisation. -/
theorem exists_supIrred_decomposition (a : α) :
    ∃ s : Finset α, s.sup id = a ∧ ∀ ⦃b⦄, b ∈ s → SupIrred b
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem baseChange_smul : (r • f).baseChange A = r • f.baseChange A
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.right {s l x r o₁ o₂} (H : Valid' o₁ (@Ordnode.node α s l x r) o₂) : Valid' x r o₂
-- Mathlib/Data/List/Sigma.lean
theorem Perm.kerase {a : α} {l₁ l₂ : List (Sigma β)} (nd : l₁.NodupKeys) :
    l₁ ~ l₂ → kerase a l₁ ~ kerase a l₂
-- Mathlib/GroupTheory/PGroup.lean
theorem of_bot : IsPGroup p (⊥ : Subgroup G)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem Differentiable.continuousMultilinear_apply_const (hc : Differentiable 𝕜 c) (u : ∀ i, M i) :
    Differentiable 𝕜 fun y ↦ (c y) u
-- Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
@[simp] theorem nnnorm_inr (m : M) : ‖(inr m : tsze R M)‖₊ = ‖m‖₊
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasDerivAt_rpow_const {x p : ℝ} (h : x ≠ 0 ∨ 1 ≤ p) :
    HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
-- Mathlib/ModelTheory/Basic.lean
theorem toHom_injective : @Function.Injective (M ↪[L] N) (M →[L] N) (·.toHom)
-- Mathlib/Order/Lattice.lean
theorem sup_right_comm (a b c : α) : a ⊔ b ⊔ c = a ⊔ c ⊔ b
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem AEMeasurable.isGLB {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α} {g : δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hg : ∀ᵐ b ∂μ, IsGLB { a | ∃ i, f i b = a } (g b)) :
    AEMeasurable g μ
-- Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean
/-- Variant of Hahn-Banach, eliminating the hypothesis that `x` be nonzero, and choosing
    the dual element arbitrarily when `x = 0`. -/
theorem exists_dual_vector' [Nontrivial E] (x : E) : ∃ g : E →L[𝕜] 𝕜, ‖g‖ = 1 ∧ g x = ‖x‖
-- Mathlib/Tactic/NormNum/Prime.lean
theorem minFacHelper_3 {n k k' : ℕ} (e : k + 2 = k') (nk : (n % k).beq 0 = false)
    (h : MinFacHelper n k) : MinFacHelper n k'
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_div_le (a b : Ordinal) : b * (a / b) ≤ a
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Ioo : (some : α → WithBot α) ⁻¹' Ioo a b = Ioo a b
-- Mathlib/Init/Algebra/Classes.lean
/-- `IsTrans X r` means the binary relation `r` on `X` is transitive. -/
class IsTrans (α : Sort u) (r : α → α → Prop) : Prop where
  trans : ∀ a b c, r a b → r b c → r a c
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem indicator_ae_eq_restrict (hs : MeasurableSet s) : indicator s f =ᵐ[μ.restrict s] f
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem congr_mul (f : M ≃ₗ[R] M) (g : N ≃ₗ[R] N) (f' : M ≃ₗ[R] M) (g' : N ≃ₗ[R] N) :
    congr (f * f') (g * g') = congr f g * congr f' g'
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps, norm_cast]
theorem ofReal_natCast (n : ℕ) : ((n : ℝ) : K) = n
-- Mathlib/Data/Nat/ChineseRemainder.lean
theorem chineseRemainderOfFinset_lt_prod {t : Finset ι}
    (hs : ∀ i ∈ t, s i ≠ 0) (pp : Set.Pairwise t (Coprime on s)) :
    chineseRemainderOfFinset a s t hs pp < ∏ i ∈ t, s i
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
theorem toFun_eq_coe : X.toFun = ⇑X
-- Mathlib/Data/Matrix/Block.lean
theorem toSquareBlockProp_def (M : Matrix m m α) (p : m → Prop) :
    -- Porting note: added missing `of`
    toSquareBlockProp M p = of (fun i j : { a // p a } => M ↑i ↑j)
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousWithinAt_iInf {f : ι → α → δ}
    (h : ∀ i, UpperSemicontinuousWithinAt (f i) s x) :
    UpperSemicontinuousWithinAt (fun x' => ⨅ i, f i x') s x
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem add_apply (f g : SlashInvariantForm Γ k) (z : ℍ) : (f + g) z = f z + g z
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
theorem commutator_apply : ⁅X, Y⁆ f = X (Y f) - Y (X f)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
nonrec theorem RingHom.IsIntegral.tower_bot (hg : Function.Injective g)
    (hfg : (g.comp f).IsIntegral) : f.IsIntegral
-- Mathlib/Order/Chain.lean
theorem IsMaxChain.top_mem [LE α] [OrderTop α] (h : IsMaxChain (· ≤ ·) s) : ⊤ ∈ s
-- Mathlib/Data/Complex/Module.lean
@[simp]
theorem imLm_coe : ⇑imLm = im
-- Mathlib/Data/Finset/Basic.lean
theorem erase_ne_self : s.erase a ≠ s ↔ a ∈ s
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
@[simp]
theorem mk_factors_iff {X Y Z : C} (f : Y ⟶ X) [Mono f] (g : Z ⟶ X) :
    (Subobject.mk f).Factors g ↔ (MonoOver.mk' f).Factors g
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem innerRegular_measurable [WeaklyRegular μ] :
    InnerRegularWRT μ IsClosed fun s => MeasurableSet s ∧ μ s ≠ ∞
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
lemma exp_nmul (x : EReal) (n : ℕ) : exp (n * x) = (exp x) ^ n
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem zero_def : (0 : PerfectClosure K p) = mk K p (0, 0)
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_eq : x \ y = x ⊓ yᶜ
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The first projection within a domain at a point in a product is `C^∞`. -/
theorem contDiffWithinAt_fst {s : Set (E × F)} {p : E × F} :
    ContDiffWithinAt 𝕜 n (Prod.fst : E × F → E) s p
-- Mathlib/Probability/Variance.lean
theorem _root_.MeasureTheory.Memℒp.ofReal_variance_eq [IsFiniteMeasure μ] (hX : Memℒp X 2 μ) :
    ENNReal.ofReal (variance X μ) = evariance X μ
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem add_mem_Ioo_iff_right : a + b ∈ Set.Ioo c d ↔ b ∈ Set.Ioo (c - a) (d - a)
-- Mathlib/CategoryTheory/Bicategory/Free.lean
@[simp]
theorem mk_associator_inv : Quot.mk _ (Hom₂.associator_inv f g h) = (α_ f g h).inv
-- Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean
@[simp]
theorem map_vadd (f : P →ᴬ[R] Q) (p : P) (v : V) : f (v +ᵥ p) = f.contLinear v +ᵥ f p
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem eps_pow_five_pos (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) : ↑0 < ε ^ 5
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem getD_some : getD (some a) b = a
-- Mathlib/RingTheory/HahnSeries/Addition.lean
/-- Extending the domain of Hahn series is a linear map. -/
@[simps]
def embDomainLinearMap (f : Γ ↪o Γ') : HahnSeries Γ R →ₗ[R] HahnSeries Γ' R
-- Mathlib/Order/Monotone/Monovary.lean
@[simp]
theorem antivaryOn_toDual_right : AntivaryOn f (toDual ∘ g) s ↔ MonovaryOn f g s
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem mk'_toAddSubmonoid {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubmonoid R}
    (ha : ↑sa = s) : (Subsemiring.mk' s sm hm sa ha).toAddSubmonoid = sa
-- Mathlib/AlgebraicGeometry/Scheme.lean
theorem inv_app_top {X Y : Scheme} (f : X ⟶ Y) [IsIso f] :
    (inv f).app ⊤ = inv (f.app ⊤)
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem preimage_image_eq {f : α → β} (s : Set α) (h : Injective f) : f ⁻¹' (f '' s) = s
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem ediv_le_ediv {a b c : Int} (H : 0 < c) (H' : a ≤ b) : a / c ≤ b / c
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- To bound the Hausdorff measure of a set, one may use coverings with maximum diameter tending
to `0`, indexed by any sequence of countable types. -/
theorem hausdorffMeasure_le_liminf_tsum {β : Type*} {ι : β → Type*} [∀ n, Countable (ι n)]
    (d : ℝ) (s : Set X) {l : Filter β} (r : β → ℝ≥0∞) (hr : Tendsto r l (𝓝 0))
    (t : ∀ n : β, ι n → Set X) (ht : ∀ᶠ n in l, ∀ i, diam (t n i) ≤ r n)
    (hst : ∀ᶠ n in l, s ⊆ ⋃ i, t n i) : μH[d] s ≤ liminf (fun n => ∑' i, diam (t n i) ^ d) l
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean
@[ext]
lemma ext {F G : OplaxFunctor B C} {α β : F ⟶ G} {m n : α ⟶ β} (w : ∀ b, m.app b = n.app b) :
    m = n
-- Mathlib/Data/List/Chain.lean
theorem chain'_iff_get {R} : ∀ {l : List α}, Chain' R l ↔
    ∀ (i : ℕ) (h : i < length l - 1),
      R (get l ⟨i, by omega⟩) (get l ⟨i + 1, by omega⟩)
-- Mathlib/Logic/Pairwise.lean
theorem pairwise_of_forall (s : Set α) (r : α → α → Prop) (h : ∀ a b, r a b) : s.Pairwise r
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.of_mul_left_right (H : IsRelPrime (x * y) z) : IsRelPrime y z
-- Mathlib/AlgebraicGeometry/Properties.lean
@[simp]
theorem basicOpen_eq_bot_iff {X : Scheme} [IsReduced X] {U : X.Opens}
    (s : Γ(X, U)) : X.basicOpen s = ⊥ ↔ s = 0
-- Mathlib/Order/Max.lean
theorem IsMax.not_lt (h : IsMax a) : ¬a < b
-- Mathlib/RingTheory/Nakayama.lean
lemma eq_bot_of_eq_ideal_smul_of_le_jacobson_annihilator {I : Ideal R}
    {N : Submodule R M} (hN : FG N) (hIN : N = I • N)
    (hIjac : I ≤ N.annihilator.jacobson) : N = ⊥
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[simp]
theorem uncurry_curry (f : A ⊗ X ⟶ Y) : uncurry (curry f) = f
-- Mathlib/Data/Set/Basic.lean
theorem sep_true : { x ∈ s | True } = s
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem exists_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y)
    (X : C) (S : J.Cover X) (s : Meq (J.plusObj P) S) :
    ∃ t : (J.plusObj P).obj (op X), Meq.mk S t = s
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem le_mkMetric (m : ℝ≥0∞ → ℝ≥0∞) (μ : OuterMeasure X) (r : ℝ≥0∞) (h0 : 0 < r)
    (hr : ∀ s, diam s ≤ r → μ s ≤ m (diam s)) : μ ≤ mkMetric m
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1
-- Mathlib/Data/Real/ENatENNReal.lean
@[simp, norm_cast]
theorem toENNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
protected theorem iff (hk : 0 < k) :
    IsPrimitiveRoot ζ k ↔ ζ ^ k = 1 ∧ ∀ l : ℕ, 0 < l → l < k → ζ ^ l ≠ 1
-- Mathlib/Data/Rel.lean
theorem inv_id : inv (@Eq α) = @Eq α
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma shiftFunctor_op_map (n m : ℤ) (hnm : n + m = 0) {K L : Cᵒᵖ} (φ : K ⟶ L) :
    (shiftFunctor Cᵒᵖ n).map φ =
      (shiftFunctorOpIso C n m hnm).hom.app K ≫ ((shiftFunctor C m).map φ.unop).op ≫
        (shiftFunctorOpIso C n m hnm).inv.app L
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem uIcc_of_le (h : a ≤ b) : [[a, b]] = Icc a b
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma w_spec : S.c = λ ^ S.multiplicity * S.w
-- Mathlib/LinearAlgebra/Projection.lean
theorem isCompl_of_proj {f : E →ₗ[R] p} (hf : ∀ x : p, f x = x) : IsCompl p (ker f)
-- Mathlib/CategoryTheory/Closed/FunctorCategory.lean
/-- Auxiliary definition for `CategoryTheory.Functor.closed`.
The counit for the adjunction `(tensorLeft F) ⊣ (ihom F)`. -/
@[simps]
def closedCounit (F : D ⥤ C) : closedIhom F ⋙ tensorLeft F ⟶ 𝟭 (D ⥤ C)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
/-- Alternate phrasing of `Polynomial.Monic.irreducible_iff_natDegree'` where we only have to check
one divisor at a time. -/
theorem Monic.irreducible_iff_lt_natDegree_lt {p : R[X]} (hp : p.Monic) (hp1 : p ≠ 1) :
    Irreducible p ↔ ∀ q, Monic q → natDegree q ∈ Finset.Ioc 0 (natDegree p / 2) → ¬ q ∣ p
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGreatest.isLUB (h : IsGreatest s a) : IsLUB s a
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem map_int_of_map_zero (n : ℤ) : f n = f 0 + n
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem MonotoneOn.monovaryOn (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
    MonovaryOn f g s
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_map_apply_image {f : α → β} (hf : AEMeasurable f μ) (s : Set α) :
    μ s ≤ μ.map f (f '' s)
-- Mathlib/Topology/Order/Basic.lean
/-- The order topology on an ordered type is the topology generated by open intervals. We register
it on a preorder, but it is mostly interesting in linear orders, where it is also order-closed.
We define it as a mixin. If you want to introduce the order topology on a preorder, use
`Preorder.topology`. -/
class OrderTopology (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  /-- The topology is generated by open intervals `Set.Ioi _` and `Set.Iio _`. -/
  topology_eq_generate_intervals : t = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a }
-- Mathlib/Order/Interval/Set/Basic.lean
theorem _root_.IsMin.Iio_eq (h : IsMin a) : Iio a = ∅
-- Mathlib/Data/Set/Basic.lean
theorem eq_univ_of_subset {s t : Set α} (h : s ⊆ t) (hs : s = univ) : t = univ
-- Mathlib/ModelTheory/Complexity.lean
theorem realize_toPrenexImp {φ ψ : L.BoundedFormula α n} (hφ : IsPrenex φ) (hψ : IsPrenex ψ)
    {v : α → M} {xs : Fin n → M} : (φ.toPrenexImp ψ).Realize v xs ↔ (φ.imp ψ).Realize v xs
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem shiftLeft_add (m n : Nat) : ∀ k, m <<< (n + k) = (m <<< n) <<< k
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem coe_bot : ((⊥ : Subsemiring R) : Set R) = Set.range ((↑) : ℕ → R)
-- Mathlib/Analysis/Convex/Basic.lean
theorem Set.OrdConnected.convex_of_chain [OrderedSemiring 𝕜] [OrderedAddCommMonoid E] [Module 𝕜 E]
    [OrderedSMul 𝕜 E] {s : Set E} (hs : s.OrdConnected) (h : IsChain (· ≤ ·) s) : Convex 𝕜 s
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- The same-universe version of `lift_rank_le_of_surjective_injective`. -/
theorem rank_le_of_surjective_injective (i : ZeroHom R R') (j : M →+ M₁)
    (hi : Surjective i) (hj : Injective j)
    (hc : ∀ (r : R) (m : M), j (r • m) = i r • j m) :
    Module.rank R M ≤ Module.rank R' M₁
-- Mathlib/LinearAlgebra/Prod.lean
theorem sup_range_inl_inr : (range <| inl R M M₂) ⊔ (range <| inr R M M₂) = ⊤
-- Mathlib/Data/Set/Lattice.lean
theorem bijOn_iInter_of_directed [Nonempty ι] {s : ι → Set α} (hs : Directed (· ⊆ ·) s)
    {t : ι → Set β} {f : α → β} (H : ∀ i, BijOn f (s i) (t i)) : BijOn f (⋂ i, s i) (⋂ i, t i)
-- Mathlib/Data/Part.lean
theorem bind_defined {f : Part α} {g : α → Part β} :
    ∀ h : f.Dom, (g (f.get h)).Dom → (f.bind g).Dom
-- Mathlib/Algebra/Lie/Submodule.lean
theorem le_ker_iff : I ≤ f.ker ↔ ∀ x, x ∈ I → f x = 0
-- Mathlib/Topology/Connected/Basic.lean
/-- Theorem of bark and tree: if a set is within a connected set and its closure, then it is
connected as well. See also `IsPreconnected.subset_closure`. -/
protected theorem IsConnected.subset_closure {s : Set α} {t : Set α} (H : IsConnected s)
    (Kst : s ⊆ t) (Ktcs : t ⊆ closure s) : IsConnected t