ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem toUniformSpace_eq :
    ‹PseudoMetricSpace α›.toUniformSpace = .ofDist dist dist_self dist_comm dist_triangle
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.pos_part {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun a => max (f a) 0) μ
-- Mathlib/ModelTheory/Satisfiability.lean
theorem empty_infinite_Theory_isComplete : Language.empty.infiniteTheory.IsComplete
-- Mathlib/Algebra/Module/Basic.lean
lemma indicator_smul_apply (s : Set α) (r : α → R) (f : α → M) (a : α) :
    indicator s (fun a ↦ r a • f a) a = r a • indicator s f a
-- Mathlib/Data/Fintype/Card.lean
theorem exists_unique_iff_card_one {α} [Fintype α] (p : α → Prop) [DecidablePred p] :
    (∃! a : α, p a) ↔ (Finset.univ.filter p).card = 1
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negY_of_Z_ne_zero {P : Fin 3 → F} (hPz : P z ≠ 0) :
    W.negY P / P z ^ 3 = W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3)
-- Mathlib/Analysis/Analytic/IsolatedZeros.lean
theorem locally_ne_zero (hp : HasFPowerSeriesAt f p z₀) (h : p ≠ 0) : ∀ᶠ z in 𝓝[≠] z₀, f z ≠ 0
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasDerivAt_lineMap :  HasDerivAt (lineMap a b) (b - a) x
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma generateFrom_memPartition_le_range (t : ℕ → Set α) (n : ℕ) :
    generateFrom (memPartition t n) ≤ generateFrom (range t)
-- Mathlib/Analysis/Normed/Module/Span.lean
@[simp]
theorem toSpanNonzeroSingleton_coord {x : E} (h : x ≠ 0) (y : 𝕜 ∙ x) :
    toSpanNonzeroSingleton 𝕜 x h (coord 𝕜 x h y) = y
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_subtype_le {α : Type u} (p : α → Prop) : #(Subtype p) ≤ #α
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_ge_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω}
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem torsionBy.mk_ideal_smul (a b : R) (x : torsionBy R M a) :
    (Ideal.Quotient.mk (Ideal.span {a})) b • x = b • x
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem natAdd_subNat_cast {i : Fin (n + m)} (h : n ≤ i) :
    natAdd n (subNat n (cast (Nat.add_comm ..) i) h) = i
-- Mathlib/Algebra/Associated/Basic.lean
theorem unit_associated_one [Monoid α] {u : αˣ} : (u : α) ~ᵤ 1
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem mem_resolventSet_of_norm_lt_mul {a : A} {k : 𝕜} (h : ‖a‖ * ‖(1 : A)‖ < ‖k‖) : k ∈ ρ a
-- Mathlib/CategoryTheory/Limits/Indization/IndObject.lean
theorem map {A B : Cᵒᵖ ⥤ Type v} (η : A ⟶ B) [IsIso η] : IsIndObject A → IsIndObject B
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- **Markov's inequality** also known as **Chebyshev's first inequality**. -/
theorem mul_meas_ge_le_integral_of_nonneg {f : α → ℝ} (hf_nonneg : 0 ≤ᵐ[μ] f)
    (hf_int : Integrable f μ) (ε : ℝ) : ε * (μ { x | ε ≤ f x }).toReal ≤ ∫ x, f x ∂μ
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
/-- The volume form is invariant under pullback by a positively-oriented isometric automorphism. -/
theorem volumeForm_comp_linearIsometryEquiv (φ : E ≃ₗᵢ[ℝ] E)
    (hφ : 0 < LinearMap.det (φ.toLinearEquiv : E →ₗ[ℝ] E)) (x : Fin n → E) :
    o.volumeForm (φ ∘ x) = o.volumeForm x
-- Mathlib/Algebra/CharP/Defs.lean
/-- Characteristic `≠ 2` and nontrivial implies that `-1 ≠ 1`. -/
lemma Ring.neg_one_ne_one_of_char_ne_two {R : Type*} [NonAssocRing R] [Nontrivial R]
    (hR : ringChar R ≠ 2) : (-1 : R) ≠ 1
-- Mathlib/Data/List/ReduceOption.lean
theorem reduceOption_length_le (l : List (Option α)) : l.reduceOption.length ≤ l.length
-- Mathlib/Computability/Partrec.lean
theorem option_casesOn {o : α → Option β} {f : α → σ} {g : α → β → σ} (ho : Computable o)
    (hf : Computable f) (hg : Computable₂ g) :
    @Computable _ σ _ _ fun a => Option.casesOn (o a) (f a) (g a)
-- Mathlib/Order/Filter/Basic.lean
theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f
-- Mathlib/ModelTheory/Substructures.lean
theorem le_comap_of_map_le {T : L.Substructure N} {f : M →[L] N} : S.map f ≤ T → S ≤ T.comap f
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Expressing locally uniform convergence using `edist`. -/
theorem tendstoLocallyUniformly_iff {ι : Type*} [TopologicalSpace β] {F : ι → β → α} {f : β → α}
    {p : Filter ι} :
    TendstoLocallyUniformly F f p ↔
      ∀ ε > 0, ∀ x : β, ∃ t ∈ 𝓝 x, ∀ᶠ n in p, ∀ y ∈ t, edist (f y) (F n y) < ε
-- Mathlib/Algebra/Module/LocalizedModule.lean
@[elab_as_elim, induction_eliminator, cases_eliminator]
theorem induction_on {β : LocalizedModule S M → Prop} (h : ∀ (m : M) (s : S), β (mk m s)) :
    ∀ x : LocalizedModule S M, β x
-- Mathlib/Data/Rat/Defs.lean
@[simp]
theorem den_one : (1 : ℚ).den = 1
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
theorem Ordered.ins : ∀ {path : Path α} {t : RBNode α},
    t.Ordered cmp → path.Ordered cmp → t.All (path.RootOrdered cmp) → (path.ins t).Ordered cmp
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem SuperpolynomialDecay.trans_eventuallyLE (hk : 0 ≤ᶠ[l] k) (hg : SuperpolynomialDecay l k g)
    (hg' : SuperpolynomialDecay l k g') (hfg : g ≤ᶠ[l] f) (hfg' : f ≤ᶠ[l] g') :
    SuperpolynomialDecay l k f
-- Mathlib/LinearAlgebra/Finsupp.lean
/-- The span of a subset `s` is the union over all `n` of the set of linear combinations of at most
`n` terms belonging to `s`. -/
lemma span_eq_iUnion_nat (s : Set M) :
    (Submodule.span R s : Set M) = ⋃ (n : ℕ),
      (fun (f : Fin n → (R × M)) ↦ ∑ i, (f i).1 • (f i).2) '' ({f | ∀ i, (f i).2 ∈ s})
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_mul_of_not_infinitesimal_pos_infinitePos {x y : ℝ*} :
    ¬Infinitesimal x → 0 < x → InfinitePos y → InfinitePos (x * y)
-- .lake/packages/lean4/src/lean/Init/Control/ExceptCps.lean
@[simp] theorem run_pure [Monad m] : run (pure x : ExceptCpsT ε m α) = pure (Except.ok x)
-- Mathlib/RingTheory/Ideal/Operations.lean
protected theorem mul_comm : I * J = J * I
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- To bound the Hausdorff measure (or, more generally, for a measure defined using
`MeasureTheory.Measure.mkMetric`) of a set, one may use coverings with maximum diameter tending to
`0`, indexed by any sequence of finite types. -/
theorem mkMetric_le_liminf_sum {β : Type*} {ι : β → Type*} [hι : ∀ n, Fintype (ι n)] (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) (m : ℝ≥0∞ → ℝ≥0∞) :
    mkMetric m s ≤ liminf (fun n => ∑ i, m (diam (t n i))) l
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
theorem isPrefixOf_cons₂ [BEq α] {a : α} :
    isPrefixOf (a::as) (b::bs) = (a == b && isPrefixOf as bs)
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Iio_filter_lt {α} [LinearOrder α] [LocallyFiniteOrderBot α] (a b : α) :
    (Iio a).filter (· < b) = Iio (min a b)
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesOnBall.sub (hf : HasFPowerSeriesOnBall f pf x r)
    (hg : HasFPowerSeriesOnBall g pg x r) : HasFPowerSeriesOnBall (f - g) (pf - pg) x r
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem edist_lt_of_edist_lt_div (hf : LipschitzWith K f) {x y : α} {d : ℝ≥0∞}
    (h : edist x y < d / K) : edist (f x) (f y) < d
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mk'_surjective : Function.Surjective (Function.uncurry <| mk' f : M × S → M')
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioo_inter_Ioc_of_left_le (h : b₁ ≤ b₂) : Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioo (max a₁ a₂) b₁
-- Mathlib/Data/Prod/Basic.lean
lemma mk_inj_right {a₁ a₂ : α} {b : β} : (a₁, b) = (a₂, b) ↔ a₁ = a₂
-- Mathlib/Algebra/Homology/ImageToKernel.lean
theorem imageToKernel_comp_left {Z : V} (h : Z ⟶ A) (w : f ≫ g = 0) :
    imageToKernel (h ≫ f) g (by simp [w]) =
      Subobject.ofLE _ _ (imageSubobject_comp_le h f) ≫ imageToKernel f g w
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem span_singleton_lt_span_singleton [IsDomain α] {x y : α} :
    span ({x} : Set α) < span ({y} : Set α) ↔ DvdNotUnit y x
-- Mathlib/NumberTheory/Modular.lean
@[simp]
theorem lcRow0_apply (p : Fin 2 → ℤ) (g : Matrix (Fin 2) (Fin 2) ℝ) :
    lcRow0 p g = p 0 * g 0 0 + p 1 * g 0 1
-- Mathlib/Topology/Category/TopCat/Opens.lean
theorem map_iSup (f : X ⟶ Y) {ι : Type*} (U : ι → Opens Y) :
    (map f).obj (iSup U) = iSup ((map f).obj ∘ U)
-- Mathlib/Algebra/Module/LinearMap/End.lean
@[simp]
protected theorem smul_def (f : Module.End R M) (a : M) : f • a = f a
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
@[simp]
theorem isVonNBounded_vadd (x : E) : IsVonNBounded 𝕜 (x +ᵥ s) ↔ IsVonNBounded 𝕜 s
-- Mathlib/Algebra/Category/MonCat/Basic.lean
@[to_additive (attr := simp)]
lemma coe_id {X : CommMonCat} : (𝟙 X : X → X) = id
-- Mathlib/Algebra/Order/Module/Defs.lean
@[simp]
lemma le_smul_iff_one_le_left [SMulPosMono α β] [SMulPosReflectLE α β] (hb : 0 < b) :
    b ≤ a • b ↔ 1 ≤ a
-- Mathlib/Logic/Lemmas.lean
theorem dite_ite_distrib_right {a : p → α} {b : p → α} {c : ¬p → α} :
    dite p (fun hp ↦ ite q (a hp) (b hp)) c = ite q (dite p a c) (dite p b c)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : M₁ →SL[σ₁₂] M₂) : M₁ →ₛₗ[σ₁₂] M₂) = 0
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem trNat_zero : trNat 0 = []
-- Mathlib/Data/Vector/MapLemmas.lean
theorem map₂_flip (f : α → β → γ) :
    map₂ f xs ys = map₂ (flip f) ys xs
-- Mathlib/CategoryTheory/Comma/Arrow.lean
@[reassoc (attr := simp)]
lemma inv_hom_id_left (e : f ≅ g) : e.inv.left ≫ e.hom.left = 𝟙 _
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem HasSum.mul (hf : HasSum f s) (hg : HasSum g t)
    (hfg : Summable fun x : ι × κ ↦ f x.1 * g x.2) :
    HasSum (fun x : ι × κ ↦ f x.1 * g x.2) (s * t)
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafify.lean
/-- The canonical morphism from a presheaf of modules to its associated sheaf. -/
@[simps]
def toSheafify : M₀ ⟶ (restrictScalars α).obj (sheafify α φ).val
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem L1.SimpleFunc.toLp_one_eq_toL1 (f : α →ₛ E) (hf : Integrable f μ) :
    (Lp.simpleFunc.toLp f (memℒp_one_iff_integrable.2 hf) : α →₁[μ] E) = hf.toL1 f
-- Mathlib/Algebra/Homology/Homotopy.lean
/-- the sum of two homotopies is a homotopy between the sum of the respective morphisms. -/
@[simps!]
def add {f₁ g₁ f₂ g₂ : C ⟶ D} (h₁ : Homotopy f₁ g₁) (h₂ : Homotopy f₂ g₂) :
    Homotopy (f₁ + f₂) (g₁ + g₂)
-- Mathlib/Data/ZMod/Parity.lean
theorem eq_one_iff_odd {n : ℕ} : (n : ZMod 2) = 1 ↔ Odd n
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem factorial_lt (hn : 0 < n) : n ! < m ! ↔ n < m
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp] theorem closedBall_zero : closedBall x 0 = {x}
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldr_eq_foldr_list (f : Fin n → α → α) (x) : foldr n f x = (list n).foldr f x
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem one_coeff_zero : (1 : 𝕎 R).coeff 0 = 1
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
theorem add_divOf (x y : k[G]) (g : G) : (x + y) /ᵒᶠ g = x /ᵒᶠ g + y /ᵒᶠ g
-- Mathlib/Algebra/Regular/SMul.lean
theorem isLeftRegular [Mul R] {a : R} (h : IsSMulRegular R a) : IsLeftRegular a
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
theorem measurableSingletonClass_of_countablySeparated
    [MeasurableSpace α] [CountablySeparated α] :
    MeasurableSingletonClass α
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem contDiff_sinh {n} : ContDiff ℂ n sinh
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem powHalf_le_one (n : ℕ) : powHalf n ≤ 1
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem sum_cycleType (σ : Perm α) : σ.cycleType.sum = σ.support.card
-- Mathlib/Order/Circular.lean
theorem compl_cIoo {a b : α} : (cIoo a b)ᶜ = cIcc b a
-- Mathlib/Data/Set/Card.lean
theorem encard_congr (e : s ≃ t) : s.encard = t.encard
-- Mathlib/Geometry/Manifold/VectorBundle/SmoothSection.lean
protected theorem contMDiff (s : Cₛ^n⟮I; F, V⟯) :
    ContMDiff I (I.prod 𝓘(𝕜, F)) n fun x => TotalSpace.mk' F x (s x : V x)
-- Mathlib/LinearAlgebra/Determinant.lean
theorem detAux_def'' {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (tb : Trunc <| Basis ι A M)
    (b' : Basis ι' A M) (f : M →ₗ[A] M) :
    LinearMap.detAux tb f = Matrix.det (LinearMap.toMatrix b' b' f)
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_const (c : β) (hμ : μ ≠ 0) : essSup (fun _ : α => c) μ = c
-- Mathlib/Algebra/Homology/HomologySequence.lean
/-- Exactness of `S.X₃.homology i ⟶ S.X₁.homology j ⟶ S.X₂.homology j`. -/
lemma homology_exact₁ : (ShortComplex.mk _ _ (δ_comp hS i j hij)).Exact
-- Mathlib/Topology/Instances/ENNReal.lean
theorem _root_.ContinuousOn.ennreal_mul [TopologicalSpace α] {f g : α → ℝ≥0∞} {s : Set α}
    (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₁ : ∀ x ∈ s, f x ≠ 0 ∨ g x ≠ ∞)
    (h₂ : ∀ x ∈ s, g x ≠ 0 ∨ f x ≠ ∞) : ContinuousOn (fun x => f x * g x) s
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_intCast_eq_padic_norm (z : ℤ) : ‖(z : ℤ_[p])‖ = ‖(z : ℚ_[p])‖
-- Mathlib/ModelTheory/Satisfiability.lean
/-- The **Upward Löwenheim–Skolem Theorem**: If `κ` is a cardinal greater than the cardinalities of
`L` and an infinite `L`-structure `M`, then `M` has an elementary extension of cardinality `κ`. -/
theorem exists_elementaryEmbedding_card_eq_of_ge (M : Type w') [L.Structure M] [iM : Infinite M]
    (κ : Cardinal.{w}) (h1 : Cardinal.lift.{w} L.card ≤ Cardinal.lift.{max u v} κ)
    (h2 : Cardinal.lift.{w} #M ≤ Cardinal.lift.{w'} κ) :
    ∃ N : Bundled L.Structure, Nonempty (M ↪ₑ[L] N) ∧ #N = κ
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem indexOf_cons_ne {a b : α} (l : List α) : b ≠ a → indexOf a (b :: l) = succ (indexOf a l)
-- Mathlib/MeasureTheory/Integral/VitaliCaratheodory.lean
/-- **Vitali-Carathéodory Theorem**: given an integrable real function `f`, there exists an
integrable function `g > f` which is lower semicontinuous, with integral arbitrarily close
to that of `f`. This function has to be `EReal`-valued in general. -/
theorem exists_lt_lowerSemicontinuous_integral_lt [SigmaFinite μ] (f : α → ℝ) (hf : Integrable f μ)
    {ε : ℝ} (εpos : 0 < ε) :
    ∃ g : α → EReal,
      (∀ x, (f x : EReal) < g x) ∧
      LowerSemicontinuous g ∧
      Integrable (fun x => EReal.toReal (g x)) μ ∧
      (∀ᵐ x ∂μ, g x < ⊤) ∧ (∫ x, EReal.toReal (g x) ∂μ) < (∫ x, f x ∂μ) + ε
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem image_mul_left :
    image (fun b => a * b) t = preimage t (fun b => a⁻¹ * b) (mul_right_injective _).injOn
-- Mathlib/Data/Finite/Card.lean
theorem card_le_of_injective [Finite β] (f : α → β) (hf : Function.Injective f) :
    Nat.card α ≤ Nat.card β
-- Mathlib/Probability/Distributions/Exponential.lean
lemma exponentialPDF_eq (r x : ℝ) :
    exponentialPDF r x = ENNReal.ofReal (if 0 ≤ x then r * exp (-(r * x)) else 0)
-- Mathlib/RingTheory/Trace/Basic.lean
@[simp]
theorem embeddingsMatrix_apply (b : κ → B) (i) (σ : B →ₐ[A] C) :
    embeddingsMatrix A C b i σ = σ (b i)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem lintegral_lt_top {f : α →ₛ ℝ≥0∞} (hm : f.FinMeasSupp μ) (hf : ∀ᵐ a ∂μ, f a ≠ ∞) :
    f.lintegral μ < ∞
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem biUnion_assoc (πi : ∀ J, Prepartition J) (πi' : Box ι → ∀ J : Box ι, Prepartition J) :
    (π.biUnion fun J => (πi J).biUnion (πi' J)) =
      (π.biUnion πi).biUnion fun J => πi' (π.biUnionIndex πi J) J
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[ext]
lemma hom_ext {X Y : StructuredArrow S T} (f g : X ⟶ Y) (h : f.right = g.right) : f = g
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem sub_mem_Ioc_iff_left : a - b ∈ Set.Ioc c d ↔ a ∈ Set.Ioc (c + b) (d + b)
-- Mathlib/Order/Filter/Basic.lean
theorem comap_neBot_iff_frequently {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ ∃ᶠ y in f, y ∈ range m
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem measure_le_lintegral_thickenedIndicator (μ : Measure X) {E : Set X}
    (E_mble : MeasurableSet E) {δ : ℝ} (δ_pos : 0 < δ) :
    μ E ≤ ∫⁻ x, (thickenedIndicator δ_pos E x : ℝ≥0∞) ∂μ
-- Mathlib/Topology/Basic.lean
theorem Set.Finite.isOpen_sInter {s : Set (Set X)} (hs : s.Finite) :
    (∀ t ∈ s, IsOpen t) → IsOpen (⋂₀ s)
-- Mathlib/Order/GaloisConnection.lean
theorem u_l_leftInverse [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) :
    LeftInverse u l
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
theorem mem_edgeSet : s(v, w) ∈ G.edgeSet ↔ G.Adj v w
-- Mathlib/Data/Real/Archimedean.lean
/-- As `0` is the default value for `Real.sInf` of the empty set, it suffices to show that `S` is
bounded below by `0` to show that `0 ≤ sInf S`.
-/
theorem sInf_nonneg (S : Set ℝ) (hS : ∀ x ∈ S, (0 : ℝ) ≤ x) : 0 ≤ sInf S
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_ite (f g : ι → α) :
    ⨆ i, (if p i then f i else g i) = (⨆ (i) (_ : p i), f i) ⊔ ⨆ (i) (_ : ¬p i), g i
-- Mathlib/Topology/Order.lean
@[simp]
theorem nhds_discrete (α : Type*) [TopologicalSpace α] [DiscreteTopology α] : @nhds α _ = pure
-- Mathlib/ModelTheory/Algebra/Ring/Basic.lean
@[simp]
theorem realize_one (v : α → R) : Term.realize v (1 : ring.Term α) = 1
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integrableOn_rpow_mul_exp_neg_rpow {p s : ℝ} (hs : -1 < s) (hp : 1 ≤ p) :
    IntegrableOn (fun x : ℝ => x ^ s * exp (- x ^ p)) (Ioi 0)
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
theorem sublattice_closure_eq_top (L : Set C(X, ℝ)) (nA : L.Nonempty)
    (inf_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊓ g ∈ L)
    (sup_mem : ∀ᵉ (f ∈ L) (g ∈ L), f ⊔ g ∈ L) (sep : L.SeparatesPointsStrongly) :
    closure L = ⊤
-- Mathlib/RingTheory/FractionalIdeal/Norm.lean
theorem absNorm_eq_zero_iff [NoZeroDivisors K] {I : FractionalIdeal R⁰ K} :
    absNorm I = 0 ↔ I = 0
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem Step.cons {x} (H : Red.Step L₁ L₂) : Red.Step (x :: L₁) (x :: L₂)
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
theorem _root_.AlgebraicGeometry.isIso_iff_isOpenImmersion {X Y : Scheme.{u}} (f : X ⟶ Y) :
    IsIso f ↔ IsOpenImmersion f ∧ Epi f.1.base
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- `cyclotomic n` is primitive. -/
theorem cyclotomic.isPrimitive (n : ℕ) (R : Type*) [CommRing R] : (cyclotomic n R).IsPrimitive
-- Mathlib/Algebra/Group/PNatPowAssoc.lean
@[simp]
theorem ppow_one (x : M) : x ^ (1 : ℕ+) = x
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem frobenius_norm_transpose (A : Matrix m n α) : ‖Aᵀ‖ = ‖A‖
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem monomial_injective (n : ℕ) : Function.Injective (monomial n : R → R[X])
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma mul_def : Nat.mul m n = m * n
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem linMulLin_add (f g h : M →ₗ[R] A) : linMulLin f (g + h) = linMulLin f g + linMulLin f h
-- Mathlib/Algebra/Group/Hom/End.lean
/-- The left multiplication map: `(a, b) ↦ a * b`. See also `AddMonoidHom.mulLeft`. -/
@[simps!]
def AddMonoid.End.mulLeft : R →+ AddMonoid.End R
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem IccExtend_of_le_left (f : Icc a b → β) (hx : x ≤ a) :
    IccExtend h f x = f ⟨a, left_mem_Icc.2 h⟩
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem absolutelyContinuous_map_div_left (g : G) : μ ≪ map (fun h => g / h) μ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[bv_toNat] theorem getLsb_last (x : BitVec w) :
    x.getLsb (w-1) = decide (2 ^ (w-1) ≤ x.toNat)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.aemeasurable {β : Type*} [MeasurableSpace β] [l.IsCountablyGenerated] [l.NeBot]
    {f : α → β} {φ : ι → Set α} (hφ : AECover μ l φ)
    (hfm : ∀ i, AEMeasurable f (μ.restrict <| φ i)) : AEMeasurable f μ
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem bot_ne_top : (⊥ : AffineSubspace k P) ≠ ⊤
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_union_Ioo_eq_Ico (h₁ : a ≤ b) (h₂ : b < c) : Icc a b ∪ Ioo b c = Ico a c
-- Mathlib/Order/Category/BddLat.lean
theorem bddLat_dual_comp_forget_to_semilatInfCat :
    BddLat.dual ⋙ forget₂ BddLat SemilatInfCat =
    forget₂ BddLat SemilatSupCat ⋙ SemilatSupCat.dual
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If a monotone function `u : ι → α` tends to `atTop` along *some* non-trivial filter `l`, then
it tends to `atTop` along `atTop`. -/
theorem tendsto_atTop_of_monotone_of_filter [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α}
    (h : Monotone u) [NeBot l] (hu : Tendsto u l atTop) : Tendsto u atTop atTop
-- Mathlib/Order/Lattice.lean
theorem map_inf [SemilatticeInf β] {f : α → β} (hf : Monotone f) (x y : α) :
    f (x ⊓ y) = f x ⊓ f y
-- Mathlib/Data/List/Basic.lean
theorem replicate_subset_singleton (n) (a : α) : replicate n a ⊆ [a]
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
theorem add_mem' (U : (Opens (ProjectiveSpectrum.top 𝒜))ᵒᵖ) (a b : ∀ x : U.unop, at x.1)
    (ha : (isLocallyFraction 𝒜).pred a) (hb : (isLocallyFraction 𝒜).pred b) :
    (isLocallyFraction 𝒜).pred (a + b)
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem mk'_mul (x₁ x₂ : M) (y₁ y₂ : S) : f.mk' (x₁ * x₂) (y₁ * y₂) = f.mk' x₁ y₁ * f.mk' x₂ y₂
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_zero' : IsBigOWith 0 l (fun _x => (0 : E')) g
-- Mathlib/Data/ENNReal/Operations.lean
theorem add_right_inj (h : a ≠ ∞) : a + b = a + c ↔ b = c
-- Mathlib/Data/Finset/Basic.lean
theorem mem_singleton_self (a : α) : a ∈ ({a} : Finset α)
-- Mathlib/NumberTheory/Harmonic/GammaDeriv.lean
lemma eulerMascheroniConstant_eq_neg_deriv : γ = -deriv Gamma 1
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
/-- Down-compressing a family doesn't change its size. -/
@[simp]
theorem card_compression (a : α) (𝒜 : Finset (Finset α)) : (𝓓 a 𝒜).card = 𝒜.card
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem Antitone.quasiconcaveOn (hf : Antitone f) : QuasiconcaveOn 𝕜 univ f
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasStrictFDerivAt.comp_hasStrictDerivAt (hl : HasStrictFDerivAt l l' (f x))
    (hf : HasStrictDerivAt f f' x) : HasStrictDerivAt (l ∘ f) (l' f') x
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem add_compContinuous [TopologicalSpace γ] (h : C(γ, α)) :
    (g + f).compContinuous h = g.compContinuous h + f.compContinuous h
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivCommₐ_toRingEquiv :
    (quotQuotEquivCommₐ R I J : _ ⧸ J.map (Quotient.mkₐ R I) ≃+* _ ⧸ I.map (Quotient.mkₐ R J)) =
      quotQuotEquivComm I J
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The special case of the first cosimplicial identity -/
@[reassoc]
theorem δ_comp_δ_self {n} {i : Fin (n + 2)} :
    X.δ i ≫ X.δ (Fin.castSucc i) = X.δ i ≫ X.δ i.succ
-- Mathlib/Order/Ideal.lean
theorem sequenceOfCofinals.monotone : Monotone (sequenceOfCofinals p 𝒟)
-- Mathlib/CategoryTheory/Abelian/LeftDerived.lean
/-- We can compute a left derived functor on a morphism using a descent of that morphism
to a chain map between chosen projective resolutions.
-/
theorem Functor.leftDerived_map_eq (F : C ⥤ D) [F.Additive] (n : ℕ) {X Y : C} (f : X ⟶ Y)
    {P : ProjectiveResolution X} {Q : ProjectiveResolution Y} (g : P.complex ⟶ Q.complex)
    (w : g ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f) :
    (F.leftDerived n).map f =
      (P.isoLeftDerivedObj F n).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map g ≫
          (Q.isoLeftDerivedObj F n).inv
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem add_def' (a b : Rat) : a + b = mkRat (a.num * b.den + b.num * a.den) (a.den * b.den)
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
theorem compress_mem_compression (ha : a ∈ s) : compress u v a ∈ 𝓒 u v s
-- Mathlib/GroupTheory/Perm/List.lean
theorem support_formPerm_of_nodup' (l : List α) (h : Nodup l) (h' : ∀ x : α, l ≠ [x]) :
    { x | formPerm l x ≠ x } = l.toFinset