ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Logic/Hydra.lean
/-- For any relation `r` on `α`, multiset addition `Multiset α × Multiset α → Multiset α` is a
  fibration between the game sum of `CutExpand r` with itself and `CutExpand r` itself. -/
theorem cutExpand_fibration (r : α → α → Prop) :
    Fibration (GameAdd (CutExpand r) (CutExpand r)) (CutExpand r) fun s ↦ s.1 + s.2
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_le_smul_of_nonpos_left (h : b₁ ≤ b₂) (ha : a ≤ 0) : a • b₂ ≤ a • b₁
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem linearEquivFunOnFintype_lof [Fintype ι] [DecidableEq ι] (i : ι) (m : M i) :
    (linearEquivFunOnFintype R ι M) (lof R ι M i m) = Pi.single i m
-- Mathlib/Algebra/Star/Center.lean
theorem Set.star_mem_center (ha : a ∈ Set.center R) : star a ∈ Set.center R
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem total_surjective (h : Function.Surjective v) :
    Function.Surjective (Finsupp.total α M R v)
-- Mathlib/Topology/Category/CompHausLike/Limits.lean
/--
The explicit pullback cone is a limit cone.
-/
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_lt_tsub_iff_right (hc : AddLECancellable c) (h : c ≤ a) :
    a - c < b - c ↔ a < b
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem coe_vadd (f : E →ₗ[R] F) (g : E →ₗ.[R] F) : ⇑(f +ᵥ g) = ⇑(f.comp g.domain.subtype) + ⇑g
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_rpow_of_exponent_lt {x : ℝ≥0∞} {y z : ℝ} (hx : 1 < x) (hx' : x ≠ ⊤) (hyz : y < z) :
    x ^ y < x ^ z
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem disjoint_finset_sum_left {β : Type*} {i : Finset β} {f : β → Multiset α} {a : Multiset α} :
    Multiset.Disjoint (i.sum f) a ↔ ∀ b ∈ i, Multiset.Disjoint (f b) a
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
/-- If `f` has derivative `f'` within `s` at `x`, then for any `r > ‖f'‖` the ratio
`‖f z - f x‖ / ‖z - x‖` is less than `r` in some neighborhood of `x` within `s`.
In other words, the limit superior of this ratio as `z` tends to `x` along `s`
is less than or equal to `‖f'‖`. -/
theorem HasDerivWithinAt.limsup_norm_slope_le (hf : HasDerivWithinAt f f' s x) (hr : ‖f'‖ < r) :
    ∀ᶠ z in 𝓝[s] x, ‖z - x‖⁻¹ * ‖f z - f x‖ < r
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- There is an induced injective homomorphism of a subgraph of `G` into `G`. -/
@[simps]
protected def hom (x : Subgraph G) : x.coe →g G
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem length_mul (x y : FreeSemigroup α) : (x * y).length = x.length + y.length
-- Mathlib/Data/Finset/Density.lean
@[mono] lemma dens_strictMono : StrictMono (dens : Finset α → ℚ≥0)
-- Mathlib/Logic/Equiv/Option.lean
@[simp]
theorem option_symm_apply_none_iff : e.symm none = none ↔ e none = none
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem mk_smul {s : Finset ι} (c : γ) (x : ∀ i : (↑s : Set ι), β (i : ι)) :
    mk s (c • x) = c • mk s x
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem assoc_tmul (a : A) (b : B) (c : C) :
    Algebra.TensorProduct.assoc R A B C ((a ⊗ₜ b) ⊗ₜ c) = a ⊗ₜ (b ⊗ₜ c)
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem updateColumn_ne [DecidableEq n] {j' : n} (j_ne : j' ≠ j) :
    updateColumn M j c i j' = M i j'
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem mapEvalEquiv_symm_apply (W'' : Submodule R (Dual R (Dual R M))) :
    (mapEvalEquiv R M).symm W'' = W''.comap (Dual.eval R M)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem _root_.Set.Infinite.exists_lt (hs : s.Infinite) : ∀ a, ∃ b ∈ s, b < a
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive] lemma MonovaryOn.mul_left (h₁ : MonovaryOn f₁ g s) (h₂ : MonovaryOn f₂ g s) :
    MonovaryOn (f₁ * f₂) g s
-- Mathlib/GroupTheory/Perm/Basic.lean
@[to_additive existing (attr := simp) inv_addLeft]
lemma inv_mulLeft : (Equiv.mulLeft a)⁻¹ = Equiv.mulLeft a⁻¹
-- Mathlib/Topology/Instances/Nat.lean
theorem pairwise_one_le_dist : Pairwise fun m n : ℕ => 1 ≤ dist m n
-- Mathlib/RingTheory/RingHom/Surjective.lean
theorem surjective_stableUnderBaseChange : StableUnderBaseChange surjective
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
theorem append_ofBool (msbs : BitVec w) (lsb : Bool) :
    msbs ++ ofBool lsb = concat msbs lsb
-- Mathlib/Topology/Category/Profinite/Limits.lean
theorem pullback_fst_eq :
    Profinite.pullback.fst f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.fst f g
-- Mathlib/Order/Chain.lean
theorem IsChain.exists3 (hchain : IsChain r s) [IsTrans α r] {a b c} (mem1 : a ∈ s) (mem2 : b ∈ s)
    (mem3 : c ∈ s) : ∃ (z : _) (_ : z ∈ s), r a z ∧ r b z ∧ r c z
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
/-- This lemma says that `fun x => a ^ x` is strictly differentiable for `a < 0`. Note that these
values of `a` are outside of the "official" domain of `a ^ x`, and we may redefine `a ^ x`
for negative `a` if some other definition will be more convenient. -/
theorem hasStrictDerivAt_const_rpow_of_neg {a x : ℝ} (ha : a < 0) :
    HasStrictDerivAt (fun x => a ^ x) (a ^ x * log a - exp (log a * x) * sin (x * π) * π) x
-- Mathlib/Algebra/Lie/OfAssociative.lean
/-- A Lie module yields a Lie algebra morphism into the linear endomorphisms of the module.

See also `LieModule.toModuleHom`. -/
@[simps]
def LieModule.toEnd : L →ₗ⁅R⁆ Module.End R M
-- Mathlib/LinearAlgebra/Vandermonde.lean
theorem det_vandermonde {n : ℕ} (v : Fin n → R) :
    det (vandermonde v) = ∏ i : Fin n, ∏ j ∈ Ioi i, (v j - v i)
-- Mathlib/Data/Complex/Abs.lean
theorem sq_abs (z : ℂ) : Complex.abs z ^ 2 = normSq z
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_inv_iff : Irrational x⁻¹ ↔ Irrational x
-- Mathlib/Algebra/Module/Equiv/Defs.lean
protected theorem injective : Function.Injective e
-- Mathlib/Init/Logic.lean
theorem ExistsUnique.exists {p : α → Prop} : (∃! x, p x) → ∃ x, p x
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure s) : closure s = S
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of the von Mangoldt function `Λ` converges at `s` when `re s > 1`. -/
lemma LSeriesSummable_vonMangoldt {s : ℂ} (hs : 1 < s.re) : LSeriesSummable ↗Λ s
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem deriv_neg : deriv Neg.neg x = -1
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[ext]
theorem ext {f g : A ≃⋆ₐ[R] B} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_apply_of_not_and {f : R → R} (a : A) (ha : ¬ (p a ∧ ContinuousOn f (spectrum R a))) :
    cfc f a = 0
-- Mathlib/Order/Filter/Curry.lean
theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → Prop} :
    (∀ᶠ x : α × β in f.curry g, p x) ↔ ∀ᶠ x : α in f, ∀ᶠ y : β in g, p (x, y)
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.le_left_of_right_le' (hf : ConvexOn 𝕜 s f) {x y : E} (hx : x ∈ s) (hy : y ∈ s)
    {a b : 𝕜} (ha : 0 < a) (hb : 0 ≤ b) (hab : a + b = 1) (hfy : f y ≤ f (a • x + b • y)) :
    f (a • x + b • y) ≤ f x
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem refl_symm (X : C) : (Iso.refl X).symm = Iso.refl X
-- .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean
theorem size_shrink (a : Array α) (n) : (a.shrink n).size = min a.size n
-- Mathlib/Topology/Bases.lean
theorem Dense.exists_countable_dense_subset {α : Type*} [TopologicalSpace α] {s : Set α}
    [SeparableSpace s] (hs : Dense s) : ∃ t ⊆ s, t.Countable ∧ Dense t
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem measure_support_lt_top_of_memℒp (f : α →ₛ E) (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) : μ (support f) < ∞
-- Mathlib/Data/Nat/ModEq.lean
theorem chineseRemainder'_lt_lcm (h : a ≡ b [MOD gcd n m]) (hn : n ≠ 0) (hm : m ≠ 0) :
    ↑(chineseRemainder' h) < lcm n m
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem newton_seq_deriv_norm (n : ℕ) :
    ‖F.derivative.eval (newton_seq n)‖ = ‖F.derivative.eval a‖
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_sub {x : ℝ} (hx : 0 < x) (y z : ℝ) : x ^ (y - z) = x ^ y / x ^ z
-- Mathlib/Analysis/Oscillation.lean
/-- If `oscillation f x < ε` at every `x` in a compact set `K`, then there exists `δ > 0` such
that the oscillation of `f` on `ball x δ` is less than `ε` for every `x` in `K`. -/
theorem uniform_oscillation [PseudoEMetricSpace E] {K : Set E} (comp : IsCompact K)
    {f : E → F} {ε : ENNReal} (hK : ∀ x ∈ K, oscillation f x < ε) :
    ∃ δ > 0, ∀ x ∈ K, diam (f '' (ball x (ENNReal.ofReal δ))) ≤ ε
-- Mathlib/Order/Interval/Set/Pi.lean
theorem piecewise_mem_Icc' {s : Set ι} [∀ j, Decidable (j ∈ s)] {f₁ f₂ g₁ g₂ : ∀ i, α i}
    (h₁ : f₁ ∈ Icc g₁ g₂) (h₂ : f₂ ∈ Icc g₁ g₂) : s.piecewise f₁ f₂ ∈ Icc g₁ g₂
-- Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
lemma isCompl_orthogonal_iff_disjoint (hB₀ : B.IsRefl) :
    IsCompl W (B.orthogonal W) ↔ Disjoint W (B.orthogonal W)
-- Mathlib/NumberTheory/Bernoulli.lean
@[simp]
theorem sum_bernoulli' (n : ℕ) : (∑ k ∈ range n, (n.choose k : ℚ) * bernoulli' k) = n
-- Mathlib/CategoryTheory/Limits/Types.lean
@[simp]
theorem Limit.w_apply' {F : J ⥤ Type v} {j j' : J} {x : limit F} (f : j ⟶ j') :
    F.map f (limit.π F j x) = limit.π F j' x
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem mem_subalgebraEquivIntermediateField [Algebra.IsAlgebraic K L] {S : Subalgebra K L}
    {x : L} : x ∈ subalgebraEquivIntermediateField S ↔ x ∈ S
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
lemma LSeries_modOne_eq : L ↗χ₁ = L 1
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem zero_cpow_eq_nhds {b : ℂ} (hb : b ≠ 0) : (fun x : ℂ => (0 : ℂ) ^ x) =ᶠ[𝓝 b] 0
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := mono)]
theorem div_subset_div : s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ / s₂ ⊆ t₁ / t₂
-- Mathlib/Data/Set/Card.lean
theorem ncard_le_ncard_diff_add_ncard (s t : Set α) (ht : t.Finite := by toFinite_tac) :
    s.ncard ≤ (s \ t).ncard + t.ncard
-- Mathlib/GroupTheory/Abelianization.lean
theorem commutator_subset_ker : commutator G ≤ f.ker
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := continuity, fun_prop)]
theorem Continuous.zpow {f : α → G} (h : Continuous f) (z : ℤ) : Continuous fun b => f b ^ z
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma map_of_epi_of_preservesCokernel (hS : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [(S.map F).HasHomology] (_ : Epi S.g)
    (_ : PreservesColimit (parallelPair S.f 0) F) :
    (S.map F).Exact
-- Mathlib/Logic/Equiv/Defs.lean
protected theorem forall₃_congr
    {α₁ α₂ β₁ β₂ γ₁ γ₂ : Sort*} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
    (∀ x y z, p x y z) ↔ ∀ x y z, q x y z
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_iff (hb : 0 < b) : a / b ≤ c ↔ a ≤ c * b
-- Mathlib/Data/Set/Basic.lean
@[simp] lemma univ_disjoint : Disjoint univ s ↔ s = ∅
-- Mathlib/Analysis/Convex/Function.lean
theorem ConcaveOn.right_le_of_le_left' (hf : ConcaveOn 𝕜 s f) {x y : E} {a b : 𝕜} (hx : x ∈ s)
    (hy : y ∈ s) (ha : 0 ≤ a) (hb : 0 < b) (hab : a + b = 1) (hfx : f (a • x + b • y) ≤ f x) :
    f y ≤ f (a • x + b • y)
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.sub (hf : HasFiniteFPowerSeriesOnBall f pf x n r)
    (hg : HasFiniteFPowerSeriesOnBall g pg x m r) :
    HasFiniteFPowerSeriesOnBall (f - g) (pf - pg) x (max n m) r
-- Mathlib/RingTheory/Ideal/Norm.lean
@[simp]
theorem spanNorm_eq (I : Ideal S) : spanNorm R I = relNorm R I
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
@[simp] theorem mul_div_right (n : Nat) {m : Nat} (H : 0 < m) : m * n / m = n
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem le_restrict_apply (s t : Set α) : μ (t ∩ s) ≤ μ.restrict s t
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
/-- If a `NonUnitalSubalgebra` over a field does not contain `1`, then its unitization is
isomorphic to its `Algebra.adjoin`. -/
@[simps! apply_coe]
noncomputable def unitizationAlgEquiv (h1 : (1 : A) ∉ s) :
    Unitization R s ≃ₐ[R] Algebra.adjoin R (s : Set A)
-- Mathlib/Analysis/Convex/Gauge.lean
theorem comap_gauge_nhds_zero (hb : Bornology.IsVonNBounded ℝ s) (h₀ : s ∈ 𝓝 0) :
    comap (gauge s) (𝓝 0) = 𝓝 0
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem _root_.SimpleGraph.componentComplMk_mem_hom
    (G : SimpleGraph V) {v : V} (vK : v ∉ K) (h : L ⊆ K) :
    v ∈ (G.componentComplMk vK).hom h
-- Mathlib/CategoryTheory/PathCategory.lean
@[simp]
theorem lift_cons {C} [Category C] (φ : V ⥤q C) {X Y Z : V} (p : Quiver.Path X Y) (f : Y ⟶ Z) :
    (lift φ).map (p.cons f) = (lift φ).map p ≫ φ.map f
-- Mathlib/Algebra/Polynomial/Div.lean
theorem eval₂_modByMonic_eq_self_of_root [CommRing S] {f : R →+* S} {p q : R[X]} (hq : q.Monic)
    {x : S} (hx : q.eval₂ f x = 0) : (p %ₘ q).eval₂ f x = p.eval₂ f x
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem sym_smul {R : Type*} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem one_lt_cosh : 1 < cosh x ↔ x ≠ 0
-- Mathlib/Data/ENNReal/Operations.lean
theorem pow_ne_top (h : a ≠ ∞) {n : ℕ} : a ^ n ≠ ∞
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem lift_restrict : lift (restrict h) = F
-- Mathlib/Analysis/Convex/Jensen.lean
/-- **Maximum principle** for convex functions. If a function `f` is convex on the convex hull of
`s`, then the eventual maximum of `f` on `convexHull 𝕜 s` lies in `s`. -/
theorem ConvexOn.exists_ge_of_mem_convexHull (hf : ConvexOn 𝕜 (convexHull 𝕜 s) f) {x}
    (hx : x ∈ convexHull 𝕜 s) : ∃ y ∈ s, f x ≤ f y
-- Mathlib/Probability/Density.lean
theorem quasiMeasurePreserving_hasPDF' [IsFiniteMeasure ℙ] [SigmaFinite ν] {X : Ω → E}
    [HasPDF X ℙ μ] (hX : AEMeasurable X ℙ) {g : E → F} (hg : QuasiMeasurePreserving g μ ν) :
    HasPDF (g ∘ X) ℙ ν
-- Mathlib/Data/Finsupp/BigOperators.lean
theorem Finset.support_sum_subset [AddCommMonoid M] (s : Finset (ι →₀ M)) :
    (s.sum id).support ⊆ Finset.sup s Finsupp.support
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem _root_.Memℓp.star_mem {f : ∀ i, E i} (hf : Memℓp f p) : Memℓp (star f) p
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- The inner product of a vector with a multiple of itself. -/
theorem real_inner_smul_self_left (x : F) (r : ℝ) : ⟪r • x, x⟫_ℝ = r * (‖x‖ * ‖x‖)
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem Fintype.prod_dvd_of_coprime [Fintype I] (Hs : Pairwise (IsCoprime on s))
    (Hs1 : ∀ i, s i ∣ z) : (∏ x, s x) ∣ z
-- Mathlib/Data/Stream/Init.lean
theorem even_tail (s : Stream' α) : even (tail s) = odd s
-- Mathlib/Algebra/Quandle.lean
theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y'
-- Mathlib/RingTheory/Jacobson.lean
/-- If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y`.
This lemma gives the correspondence in the particular case of an ideal and its comap.
See `le_relIso_of_maximal` for the more general relation isomorphism -/
theorem isMaximal_iff_isMaximal_disjoint [H : IsJacobson R] (J : Ideal S) :
    J.IsMaximal ↔ (comap (algebraMap R S) J).IsMaximal ∧ y ∉ Ideal.comap (algebraMap R S) J
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
protected theorem smul_add (r : R₁) (x y : ⨂[R] i, s i) : r • (x + y) = r • x + r • y
-- Mathlib/Data/Complex/Basic.lean
lemma div_re (z w : ℂ) : (z / w).re = z.re * w.re / normSq w + z.im * w.im / normSq w
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_le_dist_of_mem (hx : x ∈ s) (hy : y ∈ s) (hxy : x ≠ y) : s.infsep ≤ dist x y
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
/-- Given a homology map data for a morphism `φ`, this is the induced homology
map data for `a • φ`. -/
@[simps]
def smul (a : R) : HomologyMapData (a • φ) h₁ h₂
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
/-- `ofTensorProduct` is functorial in `M`. -/
lemma ofTensorProduct_naturality (f : M →ₗ[R] N) :
    map I f ∘ₗ ofTensorProduct I M =
      ofTensorProduct I N ∘ₗ AlgebraTensorModule.map LinearMap.id f
-- Mathlib/Algebra/Polynomial/EraseLead.lean
theorem eraseLead_support_card_lt (h : f ≠ 0) : (eraseLead f).support.card < f.support.card
-- Mathlib/Algebra/Field/ULift.lean
@[simp, norm_cast] lemma down_ratCast [RatCast α] (q : ℚ) : down (q : ULift α) = q
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
theorem seq_eq_bind_map {α β : Type u} [Monad m] [LawfulMonad m] (f : m (α → β)) (x : m α) : f <*> x = f >>= (. <$> x)
-- Mathlib/Data/Finset/Basic.lean
theorem insert_subset (ha : a ∈ t) (hs : s ⊆ t) : insert a s ⊆ t
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_of_fuzzy {x y : PGame} (h : x ‖ y) : x ⧏ y
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem zero'_eval : zero'.eval = fun v => pure (0 :: v)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_of_le (hfg : ∀ x, ‖f x‖ ≤ ‖g x‖) : IsBigOWith 1 l f g
-- Mathlib/CategoryTheory/Bicategory/LocallyDiscrete.lean
/-- Extract the equation from a 2-morphism in a locally discrete 2-category. -/
theorem eq_of_hom {X Y : LocallyDiscrete C} {f g : X ⟶ Y} (η : f ⟶ g) : f = g
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem back_eq (s : String) : back s = s.1.getLastD default
-- Mathlib/ModelTheory/Satisfiability.lean
theorem isSatisfiable_directed_union_iff {ι : Type*} [Nonempty ι] {T : ι → L.Theory}
    (h : Directed (· ⊆ ·) T) : Theory.IsSatisfiable (⋃ i, T i) ↔ ∀ i, (T i).IsSatisfiable
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
theorem seminorm_one_eq_one_iff_ne_zero (hp : p 1 ≤ 1) : p 1 = 1 ↔ p ≠ 0
-- Mathlib/Topology/ContinuousOn.lean
theorem mem_nhds_subtype_iff_nhdsWithin {s : Set α} {a : s} {t : Set s} :
    t ∈ 𝓝 a ↔ (↑) '' t ∈ 𝓝[s] (a : α)
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem norm_le_of_nonempty [Nonempty α] {M : ℝ} : ‖f‖ ≤ M ↔ ∀ x, ‖f x‖ ≤ M
-- Mathlib/MeasureTheory/Measure/Doubling.lean
theorem eventually_measure_mul_le_scalingConstantOf_mul (K : ℝ) :
    ∃ R : ℝ,
      0 < R ∧
        ∀ x t r, t ∈ Ioc 0 K → r ≤ R →
          μ (closedBall x (t * r)) ≤ scalingConstantOf μ K * μ (closedBall x r)
-- Mathlib/RingTheory/Ideal/Cotangent.lean
theorem _root_.AlgHom.ker_kerSquareLift (f : A →ₐ[R] B) :
    RingHom.ker f.kerSquareLift.toRingHom = f.toRingHom.ker.cotangentIdeal
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem differentiable_cos : Differentiable ℝ cos
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
@[simp]
theorem coe_add : ⇑(X + Y) = X + Y
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem true_bne  : ∀(b : Bool), (true  != b) = !b
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem NNReal.tendsto_pow_atTop_nhds_zero_of_lt_one {r : ℝ≥0} (hr : r < 1) :
    Tendsto (fun n : ℕ ↦ r ^ n) atTop (𝓝 0)
-- Mathlib/Algebra/BigOperators/Ring.lean
/-- The product over `univ` of a sum can be written as a sum over the product of sets,
`Fintype.piFinset`. `Finset.prod_sum` is an alternative statement when the product is not
over `univ`. -/
lemma prod_univ_sum [Fintype ι] (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    ∏ i, ∑ j ∈ t i, f i j = ∑ x ∈ piFinset t, ∏ i, f i (x i)
-- Mathlib/Data/Finset/Card.lean
/-- We can shrink `A` to any smaller size. -/
@[deprecated exists_subset_card_eq (since := "2024-06-23")]
theorem exists_smaller_set (A : Finset α) (i : ℕ) (h₁ : i ≤ card A) :
    ∃ B : Finset α, B ⊆ A ∧ card B = i
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem smul_continuousOn [LocallyCompactSpace X] [T2Space X] {𝕜 : Type*} [NormedField 𝕜]
    [SecondCountableTopologyEither X E] [NormedSpace 𝕜 E] {f : X → 𝕜} {g : X → E} {s : Set X}
    (hs : IsOpen s) (hf : LocallyIntegrableOn f s μ) (hg : ContinuousOn g s) :
    LocallyIntegrableOn (fun x => f x • g x) s μ
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
lemma mul_right_injective_of_invertible [Invertible A] :
    Function.Injective (fun (x : Matrix n m α) => A * x)
-- Mathlib/Analysis/InnerProductSpace/Spectrum.lean
/-- The mutual orthogonal complement of the eigenspaces of a self-adjoint operator on an inner
product space has no eigenvalues. -/
theorem orthogonalComplement_iSup_eigenspaces (μ : 𝕜) :
    eigenspace (T.restrict hT.orthogonalComplement_iSup_eigenspaces_invariant) μ = ⊥
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem coe_bot : (↑(⊥ : Compacts α) : Set α) = ∅
-- Mathlib/RingTheory/MatrixAlgebra.lean
theorem right_inv (M : Matrix n n A) : (toFunAlgHom R A n) (invFun R A n M) = M
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem toZ_of_ge (hi : i0 ≤ i) : toZ i0 i = Nat.find (exists_succ_iterate_of_le hi)
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
theorem derivativeFun_C (r : R) : derivativeFun (C R r) = 0
-- Mathlib/Data/List/Basic.lean
@[simp] lemma attach_nil : ([] : List α).attach = []
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
theorem eq_on_inv₀ [MonoidWithZeroHomClass F' G₀ M₀'] (f g : F') (h : f a = g a) :
    f a⁻¹ = g a⁻¹
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[norm_cast]
theorem coe_negPart (f : α →₁ₛ[μ] ℝ) : (negPart f : α →₁[μ] ℝ) = Lp.negPart (f : α →₁[μ] ℝ)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_mono_on_ae (hs : MeasurableSet s) (h : ∀ᵐ x ∂μ, x ∈ s → f x ≤ g x) :
    ∫ x in s, f x ∂μ ≤ ∫ x in s, g x ∂μ
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
theorem AddSubsemigroup.toSubsemigroup_closure (S : Set A) :
    AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) =
      Subsemigroup.closure (Multiplicative.toAdd ⁻¹' S)
-- Mathlib/Data/Set/Pointwise/Basic.lean
theorem zero_mul_subset (s : Set α) : 0 * s ⊆ 0
-- Mathlib/Topology/ContinuousOn.lean
theorem map_nhdsWithin (f : α → β) (a : α) (s : Set α) :
    map f (𝓝[s] a) = ⨅ t ∈ { t : Set α | a ∈ t ∧ IsOpen t }, 𝓟 (f '' (t ∩ s))
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) : f n = f 0 + n • b
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem evalFacProps {l : Products I} (J K : I → Prop)
    (h : ∀ a, a ∈ l.val → J a) [∀ j, Decidable (J j)] [∀ j, Decidable (K j)]
    (hJK : ∀ i, J i → K i) :
    l.eval (π C J) ∘ ProjRestricts C hJK = l.eval (π C K)
-- Mathlib/Data/List/DropRight.lean
theorem rdropWhile_concat (x : α) :
    rdropWhile p (l ++ [x]) = if p x then rdropWhile p l else l ++ [x]
-- Mathlib/Order/Interval/Set/Pi.lean
@[to_additive]
theorem image_mulSingle_Ioo (i : ι) (a b : α i) :
    Pi.mulSingle i '' Ioo a b = Ioo (Pi.mulSingle i a) (Pi.mulSingle i b)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
lemma interior_extend_target_subset_interior_range :
    interior (f.extend I).target ⊆ interior (range I)
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicatorAux_subset (δ : ℝ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
    thickenedIndicatorAux δ E₁ ≤ thickenedIndicatorAux δ E₂
-- Mathlib/AlgebraicGeometry/Restrict.lean
theorem isPullback_morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
    IsPullback (f ∣_ U) (f ⁻¹ᵁ U).ι U.ι f
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem ord_nat (n : ℕ) : ord n = n
-- Mathlib/Tactic/CategoryTheory/Elementwise.lean
theorem forall_congr_forget_Type (α : Type u) (p : α → Prop) :
    (∀ (x : (forget (Type u)).obj α), p x) ↔ ∀ (x : α), p x
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsPath.dropUntil {u v w : V} {p : G.Walk v w} (hc : p.IsPath)
    (h : u ∈ p.support) : (p.dropUntil u h).IsPath
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_lt_rpow_of_exponent_gt {x : ℝ≥0} {y z : ℝ} (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) :
    x ^ y < x ^ z
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem toQuadraticMap_apply (B : BilinMap R M N) (x : M) : B.toQuadraticMap x = B x x