/-- If `x` is in the convex hull of some finset `t` whose elements are not affine-independent,
then it is in the convex hull of a strict subset of `t`. -/
theorem mem_convexHull_erase [DecidableEq E] {t : Finset E} (h : ¬AffineIndependent 𝕜 ((↑) : t → E))
    {x : E} (m : x ∈ convexHull 𝕜 (↑t : Set E)) :
    ∃ y : (↑t : Set E), x ∈ convexHull 𝕜 (↑(t.erase y) : Set E)

{𝕜 : Type u_1}
{E : Type u}
[LinearOrderedField 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[DecidableEq E]
{t : Finset E}
(h : ¬AffineIndependent 𝕜 Subtype.val)
{x : E}
(m : x ∈ (convexHull 𝕜) ↑t)


@[simp]
theorem Span.finsupp_total_repr {w : Set M} (x : span R w) :
    Finsupp.total w M R (↑) (Span.repr R w x) = x

(R : Type u_1)
{M : Type u_2}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{w : Set M}
(x : ↥(Submodule.span R w))

(Finsupp.total (↑w) M R Subtype.val) (Span.repr R w x) = ↑x


theorem erase_union_singleton (a : α) (b : β a) (s : Finmap β) (h : s.lookup a = some b) :
    s.erase a ∪ singleton a b = s

{α : Type u}
{β : α → Type v}
[DecidableEq α]
(a : α)
(b : β a)
(s : Finmap β)
(h : Finmap.lookup a s = some b)

Finmap.erase a s ∪ Finmap.singleton a b = s


theorem exists_ball_subset_ball (h : y ∈ ball x ε) : ∃ ε' > 0, ball y ε' ⊆ ball x ε

{α : Type u}
[PseudoEMetricSpace α]
{x y : α}
{ε : ℝ≥0∞}
(h : y ∈ EMetric.ball x ε)

∃ ε' > 0, EMetric.ball y ε' ⊆ EMetric.ball x ε


/-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)

{M : Type u_1}
[Add M]
{z : M}
(self : IsAddCentral z)
(a : M)


theorem sign_neg {r : ℝ} : sign (-r) = -sign r


@[simp, norm_cast]
theorem coe_id : ((ContinuousAlgHom.id R A) : A →ₐ[R] A) = AlgHom.id R A

(R : Type u_1)
[CommSemiring R]
(A : Type u_2)
[Semiring A]
[TopologicalSpace A]
[Algebra R A]

↑(ContinuousAlgHom.id R A) = AlgHom.id R A


theorem norm_max_aux₂ {f : ℂ → F} {z w : ℂ} (hd : DiffContOnCl ℂ f (ball z (dist w z)))
    (hz : IsMaxOn (norm ∘ f) (closedBall z (dist w z)) z) : ‖f w‖ = ‖f z‖

(hd : DiffContOnCl ℂ f (Metric.ball z (dist w z)))

(hz : IsMaxOn (norm ∘ f) (Metric.closedBall z (dist w z)) z)


@[simp]
theorem Definable.union {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g) :
    A.Definable L (f ∪ g)

{M : Type w}
{A : Set M}
{L : FirstOrder.Language}
[L.Structure M]
{α : Type u₁}
{f g : Set (α → M)}
(hf : A.Definable L f)
(hg : A.Definable L g)


@[simp]
theorem coe_mk' (e : P₁ ≃ P₂) (e' : V₁ ≃ₗ[k] V₂) (p h) : ⇑(mk' e e' p h) = e


/-- Let `{x | p x}` be a subsemigroup of a commutative monoid `M`. Let `f : M → N` be a map
such that `f 1 = 1` and `f` is submultiplicative on `{x | p x}`, i.e.,
`p x → p y → f (x * y) ≤ f x * f y`. Let `g i`, `i ∈ s`, be a finite family of elements of `M` such
that `∀ i ∈ s, p (g i)`. Then `f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)`. -/
@[to_additive le_sum_of_subadditive_on_pred]
theorem le_prod_of_submultiplicative_on_pred (f : M → N) (p : M → Prop) (h_one : f 1 = 1)
    (h_mul : ∀ x y, p x → p y → f (x * y) ≤ f x * f y) (hp_mul : ∀ x y, p x → p y → p (x * y))
    (g : ι → M) {s : Finset ι} (hs : ∀ i ∈ s, p (g i)) : f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)

(h_mul : ∀ (x y : M), p x → p y → f (x * y) ≤ f x * f y)

(hp_mul : ∀ (x y : M), p x → p y → p (x * y))


theorem Quotient.algHom_ext {I : Ideal A} {S} [Semiring S] [Algebra R₁ S] ⦃f g : A ⧸ I →ₐ[R₁] S⦄
    (h : f.comp (Quotient.mkₐ R₁ I) = g.comp (Quotient.mkₐ R₁ I)) : f = g

(h : f.comp (Ideal.Quotient.mkₐ R₁ I) = g.comp (Ideal.Quotient.mkₐ R₁ I))


@[ext]
lemma hom_ext {M N : Bimod A B} (f g : M ⟶ N) (h : f.hom = g.hom) : f = g

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
{A B : Mon_ C}
{M N : Bimod A B}
(f g : M ⟶ N)
(h : f.hom = g.hom)


@[simp] lemma smul_τ₁ (a : R) (φ : S₁ ⟶ S₂) : (a • φ).τ₁ = a • φ.τ₁

{R : Type u_1}
{C : Type u_2}
[Semiring R]
[CategoryTheory.Category.{u_3, u_2} C]
[CategoryTheory.Preadditive C]
[CategoryTheory.Linear R C]
{S₁ S₂ : CategoryTheory.ShortComplex C}
(a : R)
(φ : S₁ ⟶ S₂)

(a • φ).τ₁ = a • φ.τ₁


/-- The subalgebra of `C(AddCircle T, ℂ)` generated by `fourier n` for `n ∈ ℤ` is dense. -/
theorem fourierSubalgebra_closure_eq_top : (@fourierSubalgebra T).topologicalClosure = ⊤


theorem lim_of_nmem_U (c : CU P) (x : X) (h : x ∉ c.U) : c.lim x = 1

{X : Type u_1}
[TopologicalSpace X]
{P : Set X → Prop}
(c : Urysohns.CU P)
(x : X)
(h : x ∉ c.U)


/-- A closed set is nowhere dense iff its interior is empty. -/
lemma IsClosed.isNowhereDense_iff {s : Set X} (hs : IsClosed s) :
    IsNowhereDense s ↔ interior s = ∅

{X : Type u_5}
[TopologicalSpace X]
{s : Set X}
(hs : IsClosed s)


theorem mem_trans (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ) :
    c ∈ f.trans g a ↔ ∃ b, b ∈ f a ∧ c ∈ g b

{α : Type u}
{β : Type v}
{γ : Type w}
(f : α ≃. β)
(g : β ≃. γ)
(a : α)
(c : γ)


@[to_additive (attr := gcongr)]
lemma zpow_lt_zpow' (hn : 0 < n) (h : a < b) : a ^ n < b ^ n

{α : Type u_1}
[OrderedAddCommGroup α]
{n : ℤ}
{a b : α}
(hn : 0 < n)
(h : a < b)


/-- A continuous function on a closed interval with `f a = f b`
takes either its maximum or its minimum value at a point in the interior of the interval. -/
theorem exists_Ioo_extr_on_Icc (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b) :
    ∃ c ∈ Ioo a b, IsExtrOn f (Icc a b) c

{X : Type u_1}
{Y : Type u_2}
[ConditionallyCompleteLinearOrder X]
[DenselyOrdered X]
[TopologicalSpace X]
[OrderTopology X]
[LinearOrder Y]
[TopologicalSpace Y]
[OrderTopology Y]
{f : X → Y}
{a b : X}
(hab : a < b)
(hfc : ContinuousOn f (Set.Icc a b))
(hfI : f a = f b)

∃ c ∈ Set.Ioo a b, IsExtrOn f (Set.Icc a b) c


theorem natAbs_sign (z : Int) : z.sign.natAbs = if z = 0 then 0 else 1


theorem hasFDerivAt_stereoInvFunAux (v : E) :
    HasFDerivAt (stereoInvFunAux v) (ContinuousLinearMap.id ℝ E) 0

{E : Type u_1}
[NormedAddCommGroup E]
[InnerProductSpace ℝ E]
(v : E)


/-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C

(T : CategoryTheory.Pretriangulated.Triangle C)

T.invRotate.obj₁ = (CategoryTheory.shiftFunctor C (-1)).obj T.obj₃


theorem div_pf {R} [DivisionRing R] {a b c d : R} (_ : b⁻¹ = c) (_ : a * c = d) : a / b = d

{R : Type u_2}
[DivisionRing R]
{a b c d : R}


theorem HasFTaylorSeriesUpTo.zero_eq' (h : HasFTaylorSeriesUpTo n f p) (x : E) :
    p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (f x)

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
{n : ℕ∞}
{p : E → FormalMultilinearSeries 𝕜 E F}
(h : HasFTaylorSeriesUpTo n f p)
(x : E)


@[simp]
theorem forall_map_iff {p : β → Prop} (f : α → β) : Forall p (l.map f) ↔ Forall (p ∘ f) l

{α : Type u}
{β : Type v}
{l : List α}
{p : β → Prop}
(f : α → β)

List.Forall p (List.map f l) ↔ List.Forall (p ∘ f) l


theorem const : ∀ n : ℕ, Nat.Primrec fun _ => n


theorem coeIdeal_inj {I J : Ideal R} :
    (I : FractionalIdeal R⁰ K) = (J : FractionalIdeal R⁰ K) ↔ I = J

{R : Type u_1}
[CommRing R]
{K : Type u_3}
[Field K]
[Algebra R K]
[IsFractionRing R K]
{I J : Ideal R}


theorem IsExtrOn.lineDerivWithin_eq_zero (h : IsExtrOn f s a)
    (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) : lineDerivWithin ℝ f s a b = 0

{E : Type u_1}
[AddCommGroup E]
[Module ℝ E]
{f : E → ℝ}
{s : Set E}
{a b : E}
(h : IsExtrOn f s a)
(h' : ∀ᶠ (t : ℝ) in 𝓝 0, a + t • b ∈ s)


/-- The Hausdorff distance satisfies the triangle inequality. -/
theorem hausdorffDist_triangle' (fin : hausdorffEdist t u ≠ ⊤) :
    hausdorffDist s u ≤ hausdorffDist s t + hausdorffDist t u

{α : Type u}
[PseudoMetricSpace α]
{s t u : Set α}
(fin : EMetric.hausdorffEdist t u ≠ ⊤)

Metric.hausdorffDist s u ≤ Metric.hausdorffDist s t + Metric.hausdorffDist t u


@[simp]
theorem kernelSubobjectMap_id : kernelSubobjectMap (𝟙 (Arrow.mk f)) = 𝟙 _

CategoryTheory.Limits.kernelSubobjectMap (𝟙 (CategoryTheory.Arrow.mk f)) =
  𝟙 (CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f))


@[simp]
theorem count_erase_self (a : α) (s : Multiset α) : count a (erase s a) = count a s - 1

{α : Type u_1}
[DecidableEq α]
(a : α)
(s : Multiset α)

Multiset.count a (s.erase a) = Multiset.count a s - 1


@[simp]
theorem det_toContinuousLinearMap (f : E →ₗ[𝕜] E) :
    (LinearMap.toContinuousLinearMap f).det = LinearMap.det f

{𝕜 : Type u}
[hnorm : NontriviallyNormedField 𝕜]
{E : Type v}
[AddCommGroup E]
[Module 𝕜 E]
[TopologicalSpace E]
[TopologicalAddGroup E]
[ContinuousSMul 𝕜 E]
[CompleteSpace 𝕜]
[T2Space E]
[FiniteDimensional 𝕜 E]
(f : E →ₗ[𝕜] E)


theorem StarConvex.smul (hs : StarConvex 𝕜 x s) (c : 𝕜) : StarConvex 𝕜 (c • x) (c • s)

{𝕜 : Type u_1}
{E : Type u_2}
[OrderedCommSemiring 𝕜]
[AddCommMonoid E]
[Module 𝕜 E]
{x : E}
{s : Set E}
(hs : StarConvex 𝕜 x s)
(c : 𝕜)


@[to_additive (attr := simp) cmp_add_left]
theorem cmp_mul_left' {α : Type*} [Mul α] [LinearOrder α] [CovariantClass α α (· * ·) (· < ·)]
    (a b c : α) :
    cmp (a * b) (a * c) = cmp b c

[CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]


theorem mem_groupoid_of_pregroupoid {PG : Pregroupoid H} {e : PartialHomeomorph H H} :
    e ∈ PG.groupoid ↔ PG.property e e.source ∧ PG.property e.symm e.target

{H : Type u}
[TopologicalSpace H]
{PG : Pregroupoid H}
{e : PartialHomeomorph H H}

e ∈ PG.groupoid ↔ PG.property (↑e) e.source ∧ PG.property (↑e.symm) e.target


@[to_additive]
theorem le_ciInf_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, a ≤ g i * h j) : a ≤ iInf g * iInf h

[CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]

[CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]


theorem card_le_of_injective' [StrongRankCondition R] {α β : Type*} [Fintype α] [Fintype β]
    (f : (α →₀ R) →ₗ[R] β →₀ R) (i : Injective f) : Fintype.card α ≤ Fintype.card β

(R : Type u)
[Semiring R]
[StrongRankCondition R]
{α : Type u_1}
{β : Type u_2}
[Fintype α]
[Fintype β]
(f : (α →₀ R) →ₗ[R] β →₀ R)
(i : Function.Injective ⇑f)


/-- A submodule has dimension at most `1` if and only if there is a
single vector, not necessarily in the submodule, such that the
submodule is contained in its span. -/
theorem rank_submodule_le_one_iff' (s : Submodule K V) [Module.Free K s] :
    Module.rank K s ≤ 1 ↔ ∃ v₀, s ≤ K ∙ v₀

{K : Type u}
{V : Type v}
[Ring K]
[StrongRankCondition K]
[AddCommGroup V]
[Module K V]
(s : Submodule K V)
[Module.Free K ↥s]

Module.rank K ↥s ≤ 1 ↔ ∃ v₀, s ≤ Submodule.span K {v₀}


lemma toUpperSet_le_iff {a b : α} : toUpperSet a ≤ toUpperSet b ↔ a ≤ b

Topology.WithUpperSet.toUpperSet a ≤ Topology.WithUpperSet.toUpperSet b ↔ a ≤ b


@[simp]
theorem coe_pos_real_smul : ↑(x • z) = (x : ℝ) • (z : ℂ)


theorem one_lt_inv₀ (ha : a ≠ 0) : 1 < a⁻¹ ↔ a < 1

{α : Type u_1}
[LinearOrderedCommGroupWithZero α]
{a : α}
(ha : a ≠ 0)


@[simp] theorem blt_eq : (Nat.blt x y = true) = (x < y)


protected theorem Disjoint.symmDiff_left (ha : Disjoint a c) (hb : Disjoint b c) :
    Disjoint (a ∆ b) c

{α : Type u_2}
[GeneralizedBooleanAlgebra α]
{a b c : α}
(ha : Disjoint a c)
(hb : Disjoint b c)


lemma injOn_pow {n : ℕ} {ζ : M} (hζ : IsPrimitiveRoot ζ n) :
    Set.InjOn (ζ ^ ·) (Finset.range n)

{M : Type u_1}
[CommMonoid M]
{n : ℕ}
{ζ : M}
(hζ : IsPrimitiveRoot ζ n)

Set.InjOn (fun x => ζ ^ x) ↑(Finset.range n)


protected theorem lt_of_sub_ne_zero (h : n - m ≠ 0) : m < n


/-- We can decompose a sum of absolute value `n` into a sum of `n` signs. -/
theorem exists_signed_sum {α : Type u_1} [DecidableEq α] (s : Finset α) (f : α → ℤ) :
    ∃ (β : Type u_1) (_ : Fintype β) (sgn : β → SignType) (g : β → α),
      (∀ b, g b ∈ s) ∧
        (Fintype.card β = ∑ a ∈ s, (f a).natAbs) ∧
          ∀ a ∈ s, (∑ b, if g b = a then (sgn b : ℤ) else 0) = f a

∃ β x sgn g,
  (∀ (b : β), g b ∈ s) ∧
    Fintype.card β = ∑ a ∈ s, (f a).natAbs ∧ ∀ a ∈ s, (∑ b : β, if g b = a then ↑(sgn b) else 0) = f a


@[to_additive (attr := simp)]
theorem op_div [DivInvMonoid α] (x y : α) : op (x / y) = (op y)⁻¹ * op x

{α : Type u_1}
[DivInvMonoid α]
(x y : α)

MulOpposite.op (x / y) = (MulOpposite.op y)⁻¹ * MulOpposite.op x


@[to_additive]
lemma iCondIndepFun.indepFun_div_left (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (f i / f j) (f k) μ

{f : ι → Ω → β}

(hf_indep : ProbabilityTheory.iCondIndepFun m' hm' (fun x => m) f μ)

ProbabilityTheory.CondIndepFun m' hm' (f i / f j) (f k) μ


/-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is transitive. -/
theorem Filter.Tendsto.uniformity_trans {l : Filter β} {f₁ f₂ f₃ : β → α}
    (h₁₂ : Tendsto (fun x => (f₁ x, f₂ x)) l (𝓤 α))
    (h₂₃ : Tendsto (fun x => (f₂ x, f₃ x)) l (𝓤 α)) : Tendsto (fun x => (f₁ x, f₃ x)) l (𝓤 α)

{f₁ f₂ f₃ : β → α}

(h₁₂ : Filter.Tendsto (fun x => (f₁ x, f₂ x)) l (𝓤 α))

(h₂₃ : Filter.Tendsto (fun x => (f₂ x, f₃ x)) l (𝓤 α))

Filter.Tendsto (fun x => (f₁ x, f₃ x)) l (𝓤 α)


@[simp, measurability]
protected theorem MeasurableSet.univ : MeasurableSet (univ : Set α)


theorem inl_lt_inr [LT α] [LT β] (a : α) (b : β) : toLex (inl a) < toLex (inr b)

{α : Type u_1}
{β : Type u_2}
[LT α]
[LT β]
(a : α)
(b : β)


/-- A linear map `T` is zero, if and only if the identity `⟪T x, x⟫_ℂ = 0` holds for all `x`.
-/
theorem inner_map_self_eq_zero (T : V →ₗ[ℂ] V) : (∀ x : V, ⟪T x, x⟫_ℂ = 0) ↔ T = 0

{V : Type u_4}
[NormedAddCommGroup V]
[InnerProductSpace ℂ V]
(T : V →ₗ[ℂ] V)


theorem sub_mulVec [Fintype n] (A B : Matrix m n α) (x : n → α) :
    (A - B) *ᵥ x = A *ᵥ x - B *ᵥ x

{m : Type u_2}
{n : Type u_3}
{α : Type v}
[NonUnitalNonAssocRing α]
[Fintype n]
(A B : Matrix m n α)
(x : n → α)


theorem Icc_pred_left (h : pred a ≤ b) : Icc (pred a) b = insert (pred a) (Icc a b)

{α : Type u_1}
[PartialOrder α]
[PredOrder α]
{a b : α}
(h : Order.pred a ≤ b)

Set.Icc (Order.pred a) b = insert (Order.pred a) (Set.Icc a b)


lemma prev_f_of_not_boundaryGE [e.IsRelIff] {i j : ι} (hij : c.prev j = i)
    (hj : ¬ e.BoundaryGE j) :
    c'.prev (e.f j) = e.f i

{ι : Type u_1}
{ι' : Type u_2}
{c : ComplexShape ι}
{c' : ComplexShape ι'}
(e : c.Embedding c')
[e.IsRelIff]
{i j : ι}
(hij : c.prev j = i)
(hj : ¬e.BoundaryGE j)


@[mono]
theorem toSubsemigroup_strictMono :
    StrictMono (toSubsemigroup : NonUnitalSubsemiring R → Subsemigroup R)

{R : Type u}
[NonUnitalNonAssocSemiring R]


@[simps! hom_app inv_app]
noncomputable
def GrothendieckTopology.sheafificationIsoPresheafToSheafCompSheafToPreasheaf :
    J.sheafification D ≅ plusPlusSheaf J D ⋙ sheafToPresheaf J D

(J : CategoryTheory.GrothendieckTopology C)

[CategoryTheory.Category.{max v u, w} D]

[∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]

[∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]

[(X : C) → CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ (CategoryTheory.forget D)]

(J.sheafificationIsoPresheafToSheafCompSheafToPreasheaf D).inv.app X = CategoryTheory.CategoryStruct.id (J.sheafify X)


/-- A property `C → Prop` is a closed predicate if it is closed under taking internal homs
-/
class ClosedPredicate : Prop where
  prop_ihom : ∀ {X Y}, P X → P Y → P ((ihom X).obj Y) := by aesop_cat

[self : CategoryTheory.MonoidalCategory.ClosedPredicate P]

P X → P Y → P ((CategoryTheory.ihom X).obj Y)


/-- The sum `F.sum' G` precomposed with the right inclusion functor is isomorphic to `G` -/
@[simps!]
def inrCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inr_ A B ⋙ F.sum' G ≅ G

{A : Type u₁}
[CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₁}
[CategoryTheory.Category.{v₁, u₁} B]
{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
(F : CategoryTheory.Functor A C)
(G : CategoryTheory.Functor B C)
(X : B)

(F.inrCompSum' G).hom.app X = CategoryTheory.CategoryStruct.id ((F.sum' G).obj (Sum.inr X))


@[nolint simpNF, simp, norm_cast] theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n) : A 0) = (OfNat.ofNat n : R)

{ι : Type u_1}
{σ : Type u_2}
{R : Type u_4}
[Semiring R]
[AddMonoid ι]
[SetLike σ R]
[AddSubmonoidClass σ R]
(A : ι → σ)
[SetLike.GradedMonoid A]
(n : ℕ)
[n.AtLeastTwo]


protected theorem IsWF.insert (h : IsWF s) (a : α) : IsWF (insert a s)

{α : Type u_2}
[Preorder α]
{s : Set α}
(h : s.IsWF)
(a : α)


lemma mul_eq_left (ha : a ≠ 0) : a * b = a ↔ b = 1


theorem IsNilpotent.isUnit_add_left_of_commute [Ring R] {r u : R}
    (hnil : IsNilpotent r) (hu : IsUnit u) (h_comm : Commute r u) :
    IsUnit (u + r)

{R : Type u_1}
[Ring R]
{r u : R}
(hnil : IsNilpotent r)
(hu : IsUnit u)
(h_comm : Commute r u)


/-- Deduce the equality of points from the vanishing of the nonnegative distance-/
theorem eq_of_nndist_eq_zero {x y : γ} : nndist x y = 0 → x = y


theorem op_closure (s : Set R) : (closure s).op = closure (MulOpposite.unop ⁻¹' s)

(Subring.closure s).op = Subring.closure (MulOpposite.unop ⁻¹' s)


/-- The `n`-th Chebyshev polynomial of the first kind evaluates on `cos θ` to the
value `cos (n * θ)`. -/
@[simp]
theorem T_real_cos : (T ℝ n).eval (cos θ) = cos (n * θ)

Polynomial.eval (Real.cos θ) (Polynomial.Chebyshev.T ℝ n) = Real.cos (↑n * θ)


@[simp]
theorem map_comp_C (f : R →+* S) : (map f).comp (C : R →+* MvPolynomial σ R) = C.comp f

{σ : Type u_1}
{R : Type u_3}
{S : Type u_4}
[CommSemiring R]
[CommSemiring S]
(f : R →+* S)

(MvPolynomial.map f).comp MvPolynomial.C = MvPolynomial.C.comp f


theorem filter_lt_of_top_le {n m l : ℕ} (hml : m ≤ l) :
    ((Ico n m).filter fun x => x < l) = Ico n m

List.filter (fun x => decide (x < l)) (List.Ico n m) = List.Ico n m


protected theorem ext_iff {f g : α →ₙ+* β} : f = g ↔ ∀ x, f x = g x

{α : Type u_2}
{β : Type u_3}
[NonUnitalNonAssocSemiring α]
[NonUnitalNonAssocSemiring β]
{f g : α →ₙ+* β}


/-- `average k G` is invariant under left multiplication by elements of `G`.
-/
@[simp]
theorem mul_average_left (g : G) : ↑(Finsupp.single g 1) * average k G = average k G

(k : Type u_1)
(G : Type u_2)
[CommSemiring k]
[Group G]
[Fintype G]
[Invertible ↑(Fintype.card G)]
(g : G)

Finsupp.single g 1 * GroupAlgebra.average k G = GroupAlgebra.average k G


/-- The rank of a diagnonal matrix is the count of non-zero elements on its main diagonal -/
theorem rank_diagonal [Fintype m] [DecidableEq m] [DecidableEq R] (w : m → R) :
    (diagonal w).rank = Fintype.card {i // (w i) ≠ 0}

{m : Type u_2}
{R : Type u_5}
[Field R]
[Fintype m]
[DecidableEq m]
[DecidableEq R]
(w : m → R)

(Matrix.diagonal w).rank = Fintype.card { i // w i ≠ 0 }


lemma cast_comm (n : ℤ) (x : α) : n * x = x * n

{α : Type u_3}
[NonAssocRing α]
(n : ℤ)
(x : α)


theorem const_sub (x y : β) : const (x - y) = const x - const y

{α : Type u_1}
{β : Type u_2}
[LinearOrderedField α]
[Ring β]
{abv : β → α}
[IsAbsoluteValue abv]
(x y : β)

CauSeq.const abv (x - y) = CauSeq.const abv x - CauSeq.const abv y


theorem Nonempty.preimage' {s : Set β} (hs : s.Nonempty) {f : α → β} (hf : s ⊆ range f) :
    (f ⁻¹' s).Nonempty

{α : Type u_1}
{β : Type u_2}
{s : Set β}
(hs : s.Nonempty)
{f : α → β}
(hf : s ⊆ Set.range f)


theorem restrict_le_zero_subset (hi₁ : MeasurableSet i) (hij : j ⊆ i) (hi₂ : v ≤[i] 0) : v ≤[j] 0

(hi₂ : v.restrict i ≤ MeasureTheory.VectorMeasure.restrict 0 i)

v.restrict j ≤ MeasureTheory.VectorMeasure.restrict 0 j


theorem Perm.eq_nil {l : List α} (p : l ~ []) : l = []

{α : Type u_1}
{l : List α}
(p : l ~ [])


lemma isOpen_symm_image_iff_of_subset_target {t : Set Y} (hs : t ⊆ e.target) :
    IsOpen (e.symm '' t) ↔ IsOpen t

{X : Type u_1}
{Y : Type u_3}
[TopologicalSpace X]
[TopologicalSpace Y]
(e : PartialHomeomorph X Y)
{t : Set Y}
(hs : t ⊆ e.target)


/-- If `F` satisfies the Mittag-Leffler condition, its restriction to eventual ranges is a
surjective functor. -/
theorem surjective_toEventualRanges (h : F.IsMittagLeffler) ⦃i j⦄ (f : i ⟶ j) :
    (F.toEventualRanges.map f).Surjective

{J : Type u}
[CategoryTheory.Category.{u_1, u} J]
(F : J ⥤ Type v)
[CategoryTheory.IsCofilteredOrEmpty J]
(h : F.IsMittagLeffler)
⦃i j : J⦄
(f : i ⟶ j)


/-- The `AlgHom` between spaces of square matrices induced by an `AlgHom` between their
coefficients. This is `Matrix.map` as an `AlgHom`. -/
@[simps]
def mapMatrix (f : α →ₐ[R] β) : Matrix m m α →ₐ[R] Matrix m m β

{m : Type u_2}
{R : Type u_7}
{α : Type v}
{β : Type w}
[Fintype m]
[DecidableEq m]
[CommSemiring R]
[Semiring α]
[Semiring β]
[Algebra R α]
[Algebra R β]
(f : α →ₐ[R] β)
(M : Matrix m m α)


theorem IsVonNBounded.of_sub_left (hst : IsVonNBounded 𝕜 (s - t)) (ht : t.Nonempty) :
    IsVonNBounded 𝕜 s

(hst : Bornology.IsVonNBounded 𝕜 (s - t))


@[simp]
theorem deriv_mul_const_field' (v : 𝕜') : (deriv fun x => u x * v) = fun x => deriv u x * v

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{𝕜' : Type u_2}
[NormedField 𝕜']
[NormedAlgebra 𝕜 𝕜']
{u : 𝕜 → 𝕜'}
(v : 𝕜')


@[simp]
theorem compr₂_apply (f : M →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Pₗ →ₗ[R] Qₗ) (m : M) (n : Nₗ) :
    f.compr₂ g m n = g (f m n)

{R : Type u_1}
[CommSemiring R]
{M : Type u_5}
{Nₗ : Type u_10}
{Pₗ : Type u_11}
{Qₗ : Type u_12}
[AddCommMonoid M]
[AddCommMonoid Nₗ]
[AddCommMonoid Pₗ]
[AddCommMonoid Qₗ]
[Module R M]
[Module R Nₗ]
[Module R Pₗ]
[Module R Qₗ]
(f : M →ₗ[R] Nₗ →ₗ[R] Pₗ)
(g : Pₗ →ₗ[R] Qₗ)
(m : M)
(n : Nₗ)


@[simp] lemma coe_inf [SemilatticeInf β] (f g : α →o β) :
  ((f ⊓ g : α →o β) : α → β) = (f : α → β) ⊓ g

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[SemilatticeInf β]
(f g : α →o β)


theorem nontrivial_of_einfsep_lt_top (hs : s.einfsep < ∞) : s.Nontrivial

{α : Type u_1}
[EDist α]
{s : Set α}
(hs : s.einfsep < ⊤)


/-- The Lebesgue measure associated to a basis, giving measure `1` to the parallelepiped spanned
by the basis. -/
irreducible_def Basis.addHaar (b : Basis ι ℝ E) : Measure E

{ι : Type u_5}
{E : Type u_6}
[Fintype ι]
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[MeasurableSpace E]
[BorelSpace E]
(b : Basis ι ℝ E)

b.addHaar = MeasureTheory.Measure.addHaarMeasure b.parallelepiped


/-- In an R₀ space, the closure of a singleton is a compact set. -/
theorem isCompact_closure_singleton : IsCompact (closure {x})

{X : Type u_1}
[TopologicalSpace X]
[R0Space X]
{x : X}


lemma set_smul_le (p : Submodule R M)
    (closed_under_smul : ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p) :
    s • N ≤ p


theorem lift_neg' {β} [AddCommGroup β] (f : α → β) : lift (-f) = -lift f

{α : Type u}
{β : Type u_1}
[AddCommGroup β]
(f : α → β)

FreeAbelianGroup.lift (-f) = -FreeAbelianGroup.lift f


theorem mdifferentiableOn_of_locally_mdifferentiableOn
    (h : ∀ x ∈ s, ∃ u, IsOpen u ∧ x ∈ u ∧ MDifferentiableOn I I' f (s ∩ u)) :
    MDifferentiableOn I I' f s


@[simp]
theorem pointwise_smul_toSubring (g : G) (S : ValuationSubring K) :
    (g • S).toSubring = g • S.toSubring

{K : Type u}
[Field K]
{G : Type u_1}
[Group G]
[MulSemiringAction G K]
(g : G)
(S : ValuationSubring K)


theorem det_updateColumn_smul (M : Matrix n n R) (j : n) (s : R) (u : n → R) :
    det (updateColumn M j <| s • u) = s * det (updateColumn M j u)

{n : Type u_2}
[DecidableEq n]
[Fintype n]
{R : Type v}
[CommRing R]
(M : Matrix n n R)
(j : n)
(s : R)
(u : n → R)

(M.updateColumn j (s • u)).det = s * (M.updateColumn j u).det


/-- `field_simp` needs the reverse direction of `divp_assoc` to move all `/ₚ` to the right. -/
@[field_simps]
theorem divp_assoc' (x y : α) (u : αˣ) : x * (y /ₚ u) = x * y /ₚ u

{α : Type u}
[Monoid α]
(x y : α)
(u : αˣ)


protected theorem add_min_add_left (a b c : Nat) : min (a + b) (a + c) = a + min b c


@[simp]
theorem ofRat_rat {abv : ℚ → ℚ} [IsAbsoluteValue abv] (q : ℚ) :
    ofRat (q : ℚ) = (q : Cauchy abv)


/-- If `M` is a topological module over `R` and `0` is a limit of invertible elements of `R`, then
`⊤` is the only submodule of `M` with a nonempty interior.
This is the case, e.g., if `R` is a nontrivially normed field. -/
theorem Submodule.eq_top_of_nonempty_interior' [NeBot (𝓝[{ x : R | IsUnit x }] 0)]
    (s : Submodule R M) (hs : (interior (s : Set M)).Nonempty) : s = ⊤

{R : Type u_1}
{M : Type u_2}
[Ring R]
[TopologicalSpace R]
[TopologicalSpace M]
[AddCommGroup M]
[ContinuousAdd M]
[Module R M]
[ContinuousSMul R M]
[(𝓝[{x | IsUnit x}] 0).NeBot]
(s : Submodule R M)
(hs : (interior ↑s).Nonempty)


@[ext]
lemma hom_ext {X Y : BialgebraCat.{v} R} (f g : X ⟶ Y) (h : f.toBialgHom = g.toBialgHom) :
    f = g

{R : Type u}
[CommRing R]
{X Y : BialgebraCat R}
(f g : X ⟶ Y)
(h : f.toBialgHom = g.toBialgHom)


@[simp, mfld_simps] theorem mem_univ (x : α) : x ∈ @univ α


theorem uIcc_eq_finset_subtype : uIcc a b = (uIcc (a : ℕ) b).subtype fun n : ℕ => 0 < n

Finset.uIcc a b = Finset.subtype (fun n => 0 < n) (Finset.uIcc ↑a ↑b)


/-- "Functoriality of `MakesOverArrow η s` in `s`. -/
lemma map₂ {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X Y : C} (f : X ⟶ Y)
    {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (hst : yoneda.map f ≫ t = s)
    {u : F.obj (op Y)} (h : MakesOverArrow η t u) : MakesOverArrow η s (F.map f.op u)

{A F : CategoryTheory.Functor Cᵒᵖ (Type v)}

(hst : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) t = s)

(h : CategoryTheory.OverPresheafAux.MakesOverArrow η t u)

CategoryTheory.OverPresheafAux.MakesOverArrow η s (F.map f.op u)


theorem mk_add_one_eq {α : Type*} [Infinite α] : #α + 1 = #α


@[simp]
theorem eLpNorm_zero' : eLpNorm (fun _ : α => (0 : F)) p μ = 0

{α : Type u_1}
{F : Type u_3}
{m0 : MeasurableSpace α}
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup F]

MeasureTheory.eLpNorm (fun x => 0) p μ = 0


@[simp]
theorem ofBoolAlg_mul_ofBoolAlg_eq_left_iff {a b : AsBoolAlg α} :
    ofBoolAlg a * ofBoolAlg b = ofBoolAlg a ↔ a ≤ b

{α : Type u_1}
[BooleanRing α]
{a b : AsBoolAlg α}


theorem dickson_two : dickson k a 2 = X ^ 2 - C a * (3 - k : R[X])

{R : Type u_1}
[CommRing R]
(k : ℕ)
(a : R)

Polynomial.dickson k a 2 = Polynomial.X ^ 2 - Polynomial.C a * (3 - ↑k)


/-- Gives a recurrence to compute the `n + 1`th value of the sequence of integer and fractional
parts of a value in case of termination.
-/
theorem succ_nth_stream_eq_none_iff :
    IntFractPair.stream v (n + 1) = none ↔
      IntFractPair.stream v n = none ∨ ∃ ifp, IntFractPair.stream v n = some ifp ∧ ifp.fr = 0

{K : Type u_1}
[LinearOrderedField K]
[FloorRing K]
{v : K}
{n : ℕ}

GenContFract.IntFractPair.stream v (n + 1) = none ↔
  GenContFract.IntFractPair.stream v n = none ∨ ∃ ifp, GenContFract.IntFractPair.stream v n = some ifp ∧ ifp.fr = 0


theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a

{α : Type u_1}
[Preorder α]
{a : α}
[SuccOrder α]
[NoMaxOrder α]
(h : Order.IsSuccLimit a)
(b : α)


theorem ker_le_comap : f.ker ≤ J.comap f

{R : Type u}
{L : Type v}
{L' : Type w₂}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[LieRing L']
[LieAlgebra R L']
(f : L →ₗ⁅R⁆ L')
(J : LieIdeal R L')


@[to_additive]
theorem colimitInvAux_eq_of_rel (x y : Σ j, F.obj j)
    (h : Types.FilteredColimit.Rel (F ⋙ forget Grp) x y) :
    colimitInvAux.{v, u} F x = colimitInvAux F y

(h : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget AddGrp) x y)

AddGrp.FilteredColimits.colimitNegAux F x = AddGrp.FilteredColimits.colimitNegAux F y


/-- Image is monotone with respect to `⊆`. See `Set.monotone_image` for the statement in
terms of `≤`. -/
@[gcongr]
theorem image_subset {a b : Set α} (f : α → β) (h : a ⊆ b) : f '' a ⊆ f '' b

{α : Type u_1}
{β : Type u_2}
{a b : Set α}
(f : α → β)
(h : a ⊆ b)


@[simp]
theorem natDegree_minpoly [Nontrivial A] (pb : PowerBasis A S) :
    (minpoly A pb.gen).natDegree = pb.dim

{S : Type u_2}
[Ring S]
{A : Type u_4}
[CommRing A]
[Algebra A S]
[Nontrivial A]
(pb : PowerBasis A S)


/-- For every set there exists a measurable superset of the same measure. -/
theorem exists_measurable_superset (μ : Measure α) (s : Set α) :
    ∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = μ s

{α : Type u_1}
[MeasurableSpace α]
(μ : MeasureTheory.Measure α)
(s : Set α)


/-- The left injection of a space in a disjoint union is an isometry -/
theorem isometry_inl : Isometry (Sum.inl : X → X ⊕ Y)

{X : Type u}
{Y : Type v}
[MetricSpace X]
[MetricSpace Y]


/-- Taking the product of two maps with the same domain is equivalent to taking the product of
their codomains. -/
@[simps]
def prodEquiv : (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C) ≃ (A →⋆ₙₐ[R] B × C)

{R : Type u_1}
{A : Type u_2}
{B : Type u_3}
{C : Type u_4}
[Monoid R]
[NonUnitalNonAssocSemiring A]
[DistribMulAction R A]
[Star A]
[NonUnitalNonAssocSemiring B]
[DistribMulAction R B]
[Star B]
[NonUnitalNonAssocSemiring C]
[DistribMulAction R C]
[Star C]
(f : A →⋆ₙₐ[R] B × C)

NonUnitalStarAlgHom.prodEquiv.symm f = ((NonUnitalStarAlgHom.fst R B C).comp f, (NonUnitalStarAlgHom.snd R B C).comp f)


theorem eq_top_of_isCompl_bot (h : IsCompl x ⊥) : x = ⊤

{α : Type u_1}
[Lattice α]
[BoundedOrder α]
{x : α}
(h : IsCompl x ⊥)


theorem spectralRadius_lt_of_forall_lt_of_nonempty [ProperSpace 𝕜] {a : A} (ha : (σ a).Nonempty)
    {r : ℝ≥0} (hr : ∀ k ∈ σ a, ‖k‖₊ < r) : spectralRadius 𝕜 a < r

{𝕜 : Type u_1}
{A : Type u_2}
[NormedField 𝕜]
[NormedRing A]
[NormedAlgebra 𝕜 A]
[CompleteSpace A]
[ProperSpace 𝕜]
{a : A}
(ha : (spectrum 𝕜 a).Nonempty)
{r : ℝ≥0}
(hr : ∀ k ∈ spectrum 𝕜 a, ‖k‖₊ < r)


@[to_additive (attr := simp)]
theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b

[CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]


@[simp]
theorem LinearMap.vecEmpty_apply (m : M) : (LinearMap.vecEmpty : M →ₗ[R] Fin 0 → M₃) m = ![]

{R : Type u}
{M : Type v}
{M₃ : Type y}
[Semiring R]
[AddCommMonoid M]
[AddCommMonoid M₃]
[Module R M]
[Module R M₃]
(m : M)


@[to_additive (attr := simp)]
theorem mem_carrier {s : Subsemigroup M} {x : M} : x ∈ s.carrier ↔ x ∈ s

{M : Type u_1}
[Mul M]
{s : Subsemigroup M}
{x : M}


/-- The natural homomorphism from a monoid to its quotient by a congruence relation is
    surjective. -/
@[to_additive "The natural homomorphism from an `AddMonoid` to its quotient by a congruence
relation is surjective."]
theorem mk'_surjective : Surjective c.mk'

{M : Type u_1}
[AddZeroClass M]
{c : AddCon M}


@[simp]
theorem zero_apply (m : ∀ i, M₁ i) : (0 : MultilinearMap R M₁ M₂) m = 0

{R : Type uR}
{ι : Type uι}
{M₁ : ι → Type v₁}
{M₂ : Type v₂}
[Semiring R]
[(i : ι) → AddCommMonoid (M₁ i)]
[AddCommMonoid M₂]
[(i : ι) → Module R (M₁ i)]
[Module R M₂]
(m : (i : ι) → M₁ i)


/-- Any element commutes with itself. -/
@[to_additive (attr := refl, simp) "Any element commutes with itself."]
protected theorem refl (a : S) : Commute a a


theorem sub_le_sub {x y z t : EReal} (h : x ≤ y) (h' : t ≤ z) : x - z ≤ y - t


lemma cfc_map_div (f g : R → R) (a : A) (hg' : ∀ x ∈ spectrum R a, g x ≠ 0)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac)
    (hg : ContinuousOn g (spectrum R a) := by cfc_cont_tac) (ha : p a := by cfc_tac) :
    cfc (fun x ↦ f x / g x) a = cfc f a * Ring.inverse (cfc g a)

cfc (fun x => f x / g x) a = cfc f a * Ring.inverse (cfc g a)


theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a

{α : Type u}
{β : Type v}
[Preorder β]
{f : α → β}
{a : α}

IsMaxOn f Set.univ a ↔ ∀ (x : α), f x ≤ f a


theorem bit0_of_bit0 : ∀ n : Num, n + n = n.bit0


lemma biUnion_associatedPrimes_eq_compl_regular [IsNoetherianRing R] :
    ⋃ p ∈ associatedPrimes R M, p = { r : R | IsSMulRegular M r }ᶜ

(R : Type u_1)
(M : Type u_3)
[CommRing R]
[AddCommGroup M]
[Module R M]
[IsNoetherianRing R]

⋃ p ∈ associatedPrimes R M, ↑p = {r | IsSMulRegular M r}ᶜ


theorem SLOnGLPos_smul_apply (s : SL(2, ℤ)) (g : GL(2, ℝ)⁺) (z : ℍ) :
    (s • g) • z = ((s : GL(2, ℝ)⁺) * g) • z


theorem add_succ (n m : Nat) : n + succ m = succ (n + m)


theorem join_map_map {f : α → β} (hf : Measurable f) (μ : Measure (Measure α)) :
    join (map (map f) μ) = map f (join μ)

(μ : MeasureTheory.Measure (MeasureTheory.Measure α))

(MeasureTheory.Measure.map (MeasureTheory.Measure.map f) μ).join = MeasureTheory.Measure.map f μ.join


@[ext] theorem ext ⦃inst₁ inst₂ : Ring R⦄
    (h_add : local_hAdd[R, inst₁] = local_hAdd[R, inst₂])
    (h_mul : local_hMul[R, inst₁] = local_hMul[R, inst₂]) :
    inst₁ = inst₂

{R : Type u}
⦃inst₁ inst₂ : Ring R⦄
(h_add : HAdd.hAdd = HAdd.hAdd)
(h_mul : HMul.hMul = HMul.hMul)


@[simp] theorem lookup_cons_self  {k : α} : ((k,b)::es).lookup k = some b

∀ {β : Type u_1} {b : β} {es : List (α × β)} {k : α}, List.lookup k ((k, b) :: es) = some b


lemma surjective_eq_topologically :
    @Surjective = topologically Function.Surjective

@AlgebraicGeometry.Surjective =
  AlgebraicGeometry.topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => Function.Surjective


theorem generate_inter {s : Set (Set α)} (hs : IsPiSystem s) {t₁ t₂ : Set α}
    (ht₁ : (generate s).Has t₁) (ht₂ : (generate s).Has t₂) : (generate s).Has (t₁ ∩ t₂)

(ht₁ : (MeasurableSpace.DynkinSystem.generate s).Has t₁)

(ht₂ : (MeasurableSpace.DynkinSystem.generate s).Has t₂)

(MeasurableSpace.DynkinSystem.generate s).Has (t₁ ∩ t₂)


theorem thickening_of_nonpos (hδ : δ ≤ 0) (s : Set α) : thickening δ s = ∅

{α : Type u}
[PseudoEMetricSpace α]
{δ : ℝ}
(hδ : δ ≤ 0)
(s : Set α)


@[to_additive]
theorem mk'_spec (x) (y : S) : f.mk' x y * f.toMap y = f.toMap x

{M : Type u_1}
[AddCommMonoid M]
{S : AddSubmonoid M}
{N : Type u_2}
[AddCommMonoid N]
(f : S.LocalizationMap N)
(x : M)
(y : ↥S)


@[simp]
theorem coe_normComp : (f.normComp : α → ℝ) = norm ∘ f

{α : Type u}
{β : Type v}
[TopologicalSpace α]
[SeminormedAddCommGroup β]
(f : BoundedContinuousFunction α β)


@[simp] theorem mk_lt_mk {i₁ i₂ : Nat} : Pos.mk i₁ < Pos.mk i₂ ↔ i₁ < i₂

{ byteIdx := i₁ } < { byteIdx := i₂ } ↔ i₁ < i₂


@[simp]
theorem sin_sub_nat_mul_two_pi (x : ℝ) (n : ℕ) : sin (x - n * (2 * π)) = sin x

Real.sin (x - ↑n * (2 * Real.pi)) = Real.sin x


@[to_additive]
protected lemma Continuous.mulIndicator (hs : ∀ a ∈ frontier s, f a = 1) (hf : Continuous f) :
    Continuous (mulIndicator s f)

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
[Zero β]
{f : α → β}
{s : Set α}
(hs : ∀ a ∈ frontier s, f a = 0)
(hf : Continuous f)


@[simp]
theorem coe_toEquiv_symm : e.toEquiv.symm = e.symm

{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[Semiring A]
[Semiring B]
[Algebra R A]
[Algebra R B]
[CoalgebraStruct R A]
[CoalgebraStruct R B]
(e : A ≃ₐc[R] B)


/-- The functor which sends `[n]` to the simplicial set `Δ[n]` equipped by
the obvious augmentation towards the terminal object of the category of sets. -/
@[simps]
noncomputable def standardSimplex : SimplexCategory ⥤ SSet.Augmented.{u}

∀ {X Y : SimplexCategory} (θ : X ⟶ Y)
  (a :
    ((fun Δ =>
          { left := SSet.standardSimplex.obj Δ, right := ⊤_ Type u,
            hom :=
              {
                app := fun Δ' =>
                  CategoryTheory.Limits.terminal.from
                    (((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ'),
                naturality := ⋯ } })
        X).right),
  (SSet.Augmented.standardSimplex.map θ).right a =
    CategoryTheory.Limits.terminal.from
      ((fun Δ =>
            { left := SSet.standardSimplex.obj Δ, right := ⊤_ Type u,
              hom :=
                {
                  app := fun Δ' =>
                    CategoryTheory.Limits.terminal.from
                      (((𝟭 (CategoryTheory.SimplicialObject (Type u))).obj (SSet.standardSimplex.obj Δ)).obj Δ'),
                  naturality := ⋯ } })
          X).right
      a


@[integral_simps]
theorem integral_smul [NormedSpace 𝕜 G] [SMulCommClass ℝ 𝕜 G] (c : 𝕜) (f : α → G) :
    ∫ a, c • f a ∂μ = c • ∫ a, f a ∂μ

{α : Type u_1}
{𝕜 : Type u_4}
[NontriviallyNormedField 𝕜]
{G : Type u_5}
[NormedAddCommGroup G]
[NormedSpace ℝ G]
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
[NormedSpace 𝕜 G]
[SMulCommClass ℝ 𝕜 G]
(c : 𝕜)
(f : α → G)

∫ (a : α), c • f a ∂μ = c • ∫ (a : α), f a ∂μ


theorem directedOn_iff_directed {s} : @DirectedOn α r s ↔ Directed r (Subtype.val : s → α)

{α : Type u}
{r : α → α → Prop}
{s : Set α}


@[simp] theorem or_cons : (a::l).or = (a || l.or)


/-- If the elements of a set are independent, then any pair within that set is disjoint. -/
theorem Independent.pairwiseDisjoint : Pairwise (Disjoint on t)

{α : Type u_1}
{ι : Type u_3}
[CompleteLattice α]
{t : ι → α}
(ht : CompleteLattice.Independent t)


lemma range_mapIncl_mono {p p' : Submodule R P} {q q' : Submodule R Q} (hp : p ≤ p') (hq : q ≤ q') :
    LinearMap.range (mapIncl p q) ≤ LinearMap.range (mapIncl p' q')

{R : Type u_1}
[CommSemiring R]
{P : Type u_6}
{Q : Type u_7}
[AddCommMonoid P]
[AddCommMonoid Q]
[Module R P]
[Module R Q]
{p p' : Submodule R P}
{q q' : Submodule R Q}
(hp : p ≤ p')
(hq : q ≤ q')

LinearMap.range (TensorProduct.mapIncl p q) ≤ LinearMap.range (TensorProduct.mapIncl p' q')


@[simp, rclike_simps] -- Porting note: removed `norm_cast`
theorem natCast_re (n : ℕ) : re (n : K) = n


theorem of_exists_root (H : ∀ p : k[X], p.Monic → Irreducible p → Separable p → ∃ x, p.eval x = 0) :
    IsSepClosed k

(H : ∀ (p : k[X]), p.Monic → Irreducible p → p.Separable → ∃ x, Polynomial.eval x p = 0)


theorem imp {r s : α → α → Prop} (H : ∀ a b, r a b → s a b) : ∀ l₁ l₂, Lex r l₁ l₂ → Lex s l₁ l₂

{α : Type u}
{r s : α → α → Prop}
(H : ∀ (a b : α), r a b → s a b)
(l₁ l₂ : List α)


@[simp]
theorem LinearMap.BilinForm.toMatrix'_symm :
    (BilinForm.toMatrix'.symm : Matrix n n R₂ ≃ₗ[R₂] _) = Matrix.toBilin'

{R₂ : Type u_5}
[CommSemiring R₂]
{n : Type u_11}
[Fintype n]
[DecidableEq n]


@[gcongr]
theorem sSup_le_sSup (h : s ⊆ t) : sSup s ≤ sSup t

{α : Type u_1}
[CompleteSemilatticeSup α]
{s t : Set α}
(h : s ⊆ t)


/-- A variant of `List.nthLe_rotate` useful for rewrites from right to left. -/
@[deprecated get_eq_get_rotate (since := "2023-03-26")]
theorem nthLe_rotate' (l : List α) (n k : ℕ) (hk : k < l.length) :
    (l.rotate n).nthLe ((l.length - n % l.length + k) % l.length)
        ((Nat.mod_lt _ (k.zero_le.trans_lt hk)).trans_le (length_rotate _ _).ge) =
      l.nthLe k hk

{α : Type u}
(l : List α)
(n k : ℕ)
(hk : k < l.length)

(l.rotate n).nthLe ((l.length - n % l.length + k) % l.length) ⋯ = l.nthLe k hk


theorem map_injective {f : F} (hf : Function.Injective f) :
    Function.Injective (map f : NonUnitalStarSubalgebra R A → NonUnitalStarSubalgebra R B)

{F : Type v'}
{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[Star A]
[NonUnitalNonAssocSemiring B]
[Module R B]
[Star B]
[FunLike F A B]
[NonUnitalAlgHomClass F R A B]
[NonUnitalStarAlgHomClass F R A B]
{f : F}
(hf : Function.Injective ⇑f)


theorem eq_of_mem_singleton {x y : α} (h : x ∈ ({y} : Finset α)) : x = y


/-- Equivalence closure of binary relations is monotone. -/
theorem eqvGen_mono {r s : α → α → Prop} (h : ∀ x y, r x y → s x y) :
    EqvGen.Setoid r ≤ EqvGen.Setoid s

{α : Type u_1}
{r s : α → α → Prop}
(h : ∀ (x y : α), r x y → s x y)


theorem approx_mk (a : F.A) (f : F.B a → M F) (i : ℕ) :
    (M.mk ⟨a, f⟩).approx (succ i) = CofixA.intro a fun j => (f j).approx i

{F : PFunctor.{u}}
(a : F.A)
(f : F.B a → F.M)
(i : ℕ)

(PFunctor.M.mk ⟨a, f⟩).approx i.succ = PFunctor.Approx.CofixA.intro a fun j => (f j).approx i


@[simp]
theorem nonMemberSubfamily_memberSubfamily :
    (𝒜.memberSubfamily a).nonMemberSubfamily a = 𝒜.memberSubfamily a

{α : Type u_1}
[DecidableEq α]
{𝒜 : Finset (Finset α)}
{a : α}

Finset.nonMemberSubfamily a (Finset.memberSubfamily a 𝒜) = Finset.memberSubfamily a 𝒜


{K : Type v}
{L : Type w}
[CommRing K]
[Field L]
(i : K →+* L)


theorem addBottom_nth_succ_fst (L : ListBlank (∀ k, Option (Γ k))) (n : ℕ) :
    ((addBottom L).nth (n + 1)).1 = false

(L : Turing.ListBlank ((k : K) → Option (Γ k)))

((Turing.TM2to1.addBottom L).nth (n + 1)).1 = false


theorem Option.id_traverse {α} (x : Option α) : Option.traverse (pure : α → Id α) x = x


@[reassoc]
lemma stalkMap_congr (f g : X ⟶ Y) (hfg : f = g) (x x' : X) (hxx' : x = x') :
    f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hfg ▸ hxx' ▸ rfl) ≫ g.stalkMap x'

{X Y : AlgebraicGeometry.LocallyRingedSpace}

AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ =
  Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap g x'


/-- The space `Π i : Fin 2, α i` is measurably equivalent to `α 0 × α 1`. -/
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type*) [∀ i, MeasurableSpace (α i)] : (∀ i, α i) ≃ᵐ α 0 × α 1

(α : Fin 2 → Type u_8)
[(i : Fin 2) → MeasurableSpace (α i)]

⇑(MeasurableEquiv.piFinTwo α).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)


@[simp]
theorem mul_inv_cancel_right₀ (h : b ≠ 0) (a : G₀) : a * b * b⁻¹ = a

{G₀ : Type u}
[GroupWithZero G₀]
{b : G₀}
(h : b ≠ 0)
(a : G₀)


/-- If distinct points `p₁` and `p₂` lie in `s` but `p₃` does not, the three points are affinely
independent. -/
theorem affineIndependent_of_ne_of_mem_of_mem_of_not_mem {s : AffineSubspace k P} {p₁ p₂ p₃ : P}
    (hp₁p₂ : p₁ ≠ p₂) (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∉ s) :
    AffineIndependent k ![p₁, p₂, p₃]

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[DivisionRing k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{s : AffineSubspace k P}
{p₁ p₂ p₃ : P}
(hp₁p₂ : p₁ ≠ p₂)
(hp₁ : p₁ ∈ s)
(hp₂ : p₂ ∈ s)
(hp₃ : p₃ ∉ s)


theorem derivative_sum {s : Finset ι} {f : ι → R[X]} :
    derivative (∑ b ∈ s, f b) = ∑ b ∈ s, derivative (f b)

{R : Type u}
{ι : Type y}
[Semiring R]
{s : Finset ι}
{f : ι → R[X]}

Polynomial.derivative (∑ b ∈ s, f b) = ∑ b ∈ s, Polynomial.derivative (f b)


@[simp]
theorem product_union [DecidableEq α] [DecidableEq β] : s ×ˢ (t ∪ t') = s ×ˢ t ∪ s ×ˢ t'

{α : Type u_1}
{β : Type u_2}
{s : Finset α}
{t t' : Finset β}
[DecidableEq α]
[DecidableEq β]


@[simp]
theorem coe_indicatorConst {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    (↑(indicatorConst p hs hμs c) : Lp E p μ) = indicatorConstLp p hs hμs c

{α : Type u_1}
{E : Type u_4}
[MeasurableSpace α]
[NormedAddCommGroup E]
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
{s : Set α}
(hs : MeasurableSet s)
(hμs : μ s ≠ ⊤)
(c : E)

↑(MeasureTheory.Lp.simpleFunc.indicatorConst p hs hμs c) = MeasureTheory.indicatorConstLp p hs hμs c


/-- The diameter of the empty set vanishes -/
@[simp]
theorem diam_empty : diam (∅ : Set α) = 0


lemma support_monotone : Monotone (support (ι := ι) (β := α))

[(i : ι) → CanonicallyOrderedAddCommMonoid (α i)]

[(i : ι) → (x : α i) → Decidable (x ≠ 0)]


theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
    ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j'

{P : Type u_1}
[DistribLattice P]
{I J : Order.Ideal P}
{x i j : P}
(hi : i ∈ I)
(hj : j ∈ J)
(hx : x ≤ i ⊔ j)


/-- This is the standard Banach-Steinhaus theorem, or Uniform Boundedness Principle.
If a family of continuous linear maps from a Banach space into a normed space is pointwise
bounded, then the norms of these linear maps are uniformly bounded.

See also `WithSeminorms.banach_steinhaus` for the general statement in barrelled spaces. -/
theorem banach_steinhaus {ι : Type*} [CompleteSpace E] {g : ι → E →SL[σ₁₂] F}
    (h : ∀ x, ∃ C, ∀ i, ‖g i x‖ ≤ C) : ∃ C', ∀ i, ‖g i‖ ≤ C'

{σ₁₂ : 𝕜 →+* 𝕜₂}

(h : ∀ (x : E), ∃ C, ∀ (i : ι), ‖(g i) x‖ ≤ C)


@[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithTop α) = WithTop.some


/-- Basic hypothesis to talk about a smooth (Lie) additive monoid or a smooth additive
semigroup. A smooth additive monoid over `α`, for example, is obtained by requiring both the
instances `AddMonoid α` and `SmoothAdd α`. -/
class SmoothAdd {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Add G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_add : Smooth (I.prod I) I fun p : G × G => p.1 + p.2

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{H : Type u_2}
[TopologicalSpace H]
{E : Type u_3}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{I : ModelWithCorners 𝕜 E H}
{G : Type u_4}
[Add G]
[TopologicalSpace G]
[ChartedSpace H G]
[self : SmoothAdd I G]


@[simp, norm_cast]
theorem coe_sup (a b : Regular α) : (↑(a ⊔ b) : α) = ((a : α) ⊔ b)ᶜᶜ

{α : Type u_1}
[HeytingAlgebra α]
(a b : Heyting.Regular α)


theorem coe_nonneg {n : ℕ} : 0 ≤ (n : WithBot ℕ)


theorem DifferentiableWithinAt.fderivWithin_congr_mono (h : DifferentiableWithinAt 𝕜 f s x)
    (hs : EqOn f₁ f t) (hx : f₁ x = f x) (hxt : UniqueDiffWithinAt 𝕜 t x) (h₁ : t ⊆ s) :
    fderivWithin 𝕜 f₁ t x = fderivWithin 𝕜 f s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f f₁ : E → F}
{x : E}
{s t : Set E}
(h : DifferentiableWithinAt 𝕜 f s x)
(hs : Set.EqOn f₁ f t)
(hx : f₁ x = f x)
(hxt : UniqueDiffWithinAt 𝕜 t x)
(h₁ : t ⊆ s)


theorem mk_mem_localTrivAt_source : (⟨b, a⟩ : Z.TotalSpace) ∈ (Z.localTrivAt b).source

{ι : Type u_1}
{B : Type u_2}
{F : Type u_3}
[TopologicalSpace B]
[TopologicalSpace F]
(Z : FiberBundleCore ι B F)
(b : B)
(a : F)

{ proj := b, snd := a } ∈ (Z.localTrivAt b).source


/-- If a sequence `v` of real numbers satisfies `k * v n ≤ v (n+1)` with `1 < k`,
then it goes to +∞. -/
theorem tendsto_atTop_of_geom_le {v : ℕ → ℝ} {c : ℝ} (h₀ : 0 < v 0) (hc : 1 < c)
    (hu : ∀ n, c * v n ≤ v (n + 1)) : Tendsto v atTop atTop

Filter.Tendsto v Filter.atTop Filter.atTop


theorem exists_inv {p : Ring.DirectLimit G f} : p ≠ 0 → ∃ y, p * y = 1

{ι : Type v}
[Preorder ι]
(G : ι → Type w)
[Nonempty ι]
[IsDirected ι fun x x_1 => x ≤ x_1]
[(i : ι) → Field (G i)]
(f : (i j : ι) → i ≤ j → G i → G j)
{p : Ring.DirectLimit G f}


/-- If a unit `a` semiconjugates `x` to `y`, then `a⁻¹` semiconjugates `y` to `x`. -/
@[to_additive "If an additive unit `a` semiconjugates `x` to `y`, then `-a` semiconjugates `y` to
`x`."]
theorem units_inv_symm_left {a : Mˣ} {x y : M} (h : SemiconjBy (↑a) x y) : SemiconjBy (↑a⁻¹) y x

{M : Type u_1}
[AddMonoid M]
{a : AddUnits M}
{x y : M}
(h : AddSemiconjBy (↑a) x y)


lemma PresheafHom.isAmalgamation_iff {X : C} (S : Sieve X)
    (x : Presieve.FamilyOfElements (presheafHom F G) S.arrows)
    (hx : x.Compatible) (y : (presheafHom F G).obj (op X)) :
    x.IsAmalgamation y ↔ ∀ (Y : C) (g : Y ⟶ X) (hg : S g),
      y.app (op (Over.mk g)) = (x g hg).app (op (Over.mk (𝟙 Y)))

(x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.presheafHom F G) S.arrows)

(y : (CategoryTheory.presheafHom F G).obj (Opposite.op X))

x.IsAmalgamation y ↔
  ∀ (Y : C) (g : Y ⟶ X) (hg : S.arrows g),
    y.app (Opposite.op (CategoryTheory.Over.mk g)) =
      (x g hg).app (Opposite.op (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id Y)))


@[simp]
theorem toReal_lt_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal < b.toReal ↔ a < b


@[to_additive (attr := simp)]
theorem ker_mk' : MonoidHom.ker (QuotientGroup.mk' N : G →* G ⧸ N) = N

{G : Type u}
[AddGroup G]
(N : AddSubgroup G)
[nN : N.Normal]


/-- The pseudofunctor from `Cat` to `Cat` defined with `WithInitial`. -/
@[simps]
def pseudofunctor : Pseudofunctor Cat Cat


/-- The image of a substructure along a homomorphism is a substructure. -/
@[simps]
def map (φ : M →[L] N) (S : L.Substructure M) : L.Substructure N

{L : FirstOrder.Language}
{M : Type w}
{N : Type u_1}
[L.Structure M]
[L.Structure N]
(φ : L.Hom M N)
(S : L.Substructure M)

↑(FirstOrder.Language.Substructure.map φ S) = ⇑φ '' ↑S


theorem IsPrime.radical (H : IsPrime I) : radical I = I

{R : Type u}
[CommSemiring R]
{I : Ideal R}
(H : I.IsPrime)


@[simp]
theorem differentiableAt_const_add_iff (c : F) :
    DifferentiableAt 𝕜 (fun y => c + f y) x ↔ DifferentiableAt 𝕜 f x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
{x : E}
(c : F)


/-- `X × {*}` is homeomorphic to `X`. -/
@[simps! (config := .asFn) apply]
def prodPUnit : X × PUnit ≃ₜ X

⇑(Homeomorph.prodPUnit X) = fun p => p.1


/-- `QuadraticMap.polar` as a bilinear map -/
@[simps!]
def polarBilin : BilinMap R M N

{R : Type u_3}
{M : Type u_4}
{N : Type u_5}
[CommRing R]
[AddCommGroup M]
[AddCommGroup N]
[Module R M]
[Module R N]
(Q : QuadraticMap R M N)
(m y : M)

(Q.polarBilin m) y = QuadraticMap.polar (⇑Q) m y


/-- A category is artinian if it is essentially small and all objects are artinian. -/
class Artinian extends EssentiallySmall C : Prop where
  artinianObject : ∀ X : C, ArtinianObject X

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
[self : CategoryTheory.Artinian C]
(X : C)


/-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C

(C : Type u)
[CategoryTheory.Category.{v, u} C]

(CategoryTheory.prod.leftUnitorEquivalence C).inverse = CategoryTheory.prod.leftInverseUnitor C


@[simp]
theorem multiplicity_self {a : α} (ha : ¬IsUnit a) (ha0 : a ≠ 0) : multiplicity a a = 1

{α : Type u_1}
[CancelCommMonoidWithZero α]
[DecidableRel fun x x_1 => x ∣ x_1]
{a : α}
(ha : ¬IsUnit a)
(ha0 : a ≠ 0)


theorem symmDiff_symmDiff_right' :
    a ∆ (b ∆ c) = a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ aᶜ ⊓ b ⊓ cᶜ ⊔ aᶜ ⊓ bᶜ ⊓ c

{α : Type u_2}
[BooleanAlgebra α]
(a b c : α)


@[simp] theorem exact_sat (r : Int) (t : Int) : (exact r).sat t = decide (r = t)

(Lean.Omega.Constraint.exact r).sat t = decide (r = t)


@[to_additive]
theorem mul_left_surjective (a : G) : Surjective (a * ·)


theorem sup_inf_left (a b c : α) : a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c)

{α : Type u}
[DistribLattice α]
(a b c : α)


theorem SuperpolynomialDecay.param_zpow_mul (hk : Tendsto k l atTop)
    (hf : SuperpolynomialDecay l k f) (z : ℤ) :
    SuperpolynomialDecay l k fun a => k a ^ z * f a

(hf : Asymptotics.SuperpolynomialDecay l k f)

Asymptotics.SuperpolynomialDecay l k fun a => k a ^ z * f a


theorem preimage_closedBall (x : ℕ) (r : ℝ) : (↑) ⁻¹' closedBall (x : ℝ) r = closedBall x r

Nat.cast ⁻¹' Metric.closedBall (↑x) r = Metric.closedBall x r


@[simp]
theorem IsSymmetric.apply_clm {T : E →L[𝕜] E} (hT : IsSymmetric (T : E →ₗ[𝕜] E)) (x y : E) :
    ⟪T x, y⟫ = ⟪x, T y⟫

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
{T : E →L[𝕜] E}
(hT : (↑T).IsSymmetric)
(x y : E)


theorem pderiv_C_mul {f : MvPolynomial σ R} {i : σ} : pderiv i (C a * f) = C a * pderiv i f

{R : Type u}
{σ : Type v}
{a : R}
[CommSemiring R]
{f : MvPolynomial σ R}
{i : σ}

(MvPolynomial.pderiv i) (MvPolynomial.C a * f) = MvPolynomial.C a * (MvPolynomial.pderiv i) f


@[to_additive sum_nonpos]
theorem prod_le_one' (h : ∀ i ∈ s, f i ≤ 1) : ∏ i ∈ s, f i ≤ 1

{ι : Type u_1}
{N : Type u_5}
[OrderedAddCommMonoid N]
{f : ι → N}
{s : Finset ι}
(h : ∀ i ∈ s, f i ≤ 0)


@[simp]
theorem val_natCast (n : ℕ) : (n : HomogeneousLocalization 𝒜 x).val = n

{ι : Type u_1}
{R : Type u_2}
{A : Type u_3}
[AddCommMonoid ι]
[DecidableEq ι]
[CommRing R]
[CommRing A]
[Algebra R A]
{𝒜 : ι → Submodule R A}
[GradedAlgebra 𝒜]
{x : Submonoid A}
(n : ℕ)


theorem prod_univ_units_id_eq_neg_one [CommRing K] [IsDomain K] [Fintype Kˣ] :
    ∏ x : Kˣ, x = (-1 : Kˣ)

{K : Type u_1}
[CommRing K]
[IsDomain K]
[Fintype Kˣ]


theorem one_lt_mul_of_le_of_lt [ZeroLEOneClass α] [MulPosMono α]
    (ha : 1 ≤ a) (hb : 1 < b) : 1 < a * b

{α : Type u}
[Semiring α]
[Preorder α]
{a b : α}
[ZeroLEOneClass α]
[MulPosMono α]
(ha : 1 ≤ a)
(hb : 1 < b)


@[simp]
theorem compl_sup : (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ

{α : Type u_2}
[HeytingAlgebra α]
{a b : α}


@[simp] theorem bind_eq_none {o : Option α} {f : α → Option β} :
    o.bind f = none ↔ ∀ a, o = some a → f a = none

{α : Type u_1}
{β : Type u_2}
{o : Option α}
{f : α → Option β}

o.bind f = none ↔ ∀ (a : α), o = some a → f a = none


/-- The categorical equivalence between `C` and `ShrinkHoms C`, when `C` is locally small.
-/
@[simps!]
noncomputable def equivalence : C ≌ ShrinkHoms C

[CategoryTheory.LocallySmall.{w, v, u} C]

(CategoryTheory.ShrinkHoms.equivalence C).functor.map f = (equivShrink (X ⟶ Y)) f


protected theorem dvd_antisymm : ∀ {m n : Nat}, m ∣ n → n ∣ m → m = n


@[to_additive]
theorem TendstoUniformly.mul (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f * f') (g * g') l

{α : Type u_1}
{β : Type u_2}
[UniformSpace α]
[AddGroup α]
[UniformAddGroup α]
{ι : Type u_3}
{l : Filter ι}
{f f' : ι → β → α}
{g g' : β → α}
(hf : TendstoUniformly f g l)
(hf' : TendstoUniformly f' g' l)


theorem contMDiffAt_of_mem_maximalAtlas (h : e ∈ maximalAtlas I M) (hx : x ∈ e.source) :
    ContMDiffAt I I n e x

(h : e ∈ SmoothManifoldWithCorners.maximalAtlas I M)


/-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a₁ • b < a₂ • b → a₁ < a₂` if `0 ≤ b`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class SMulPosReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_right` instead. -/
  protected elim ⦃b : β⦄ (hb : 0 ≤ b) ⦃a₁ a₂ : α⦄ (hb : a₁ • b < a₂ • b) : a₁ < a₂

{α : Type u_1}
{β : Type u_2}
[SMul α β]
[Preorder α]
[Preorder β]
[Zero β]
[self : SMulPosReflectLT α β]
⦃b : β⦄
(hb : 0 ≤ b)
⦃a₁ a₂ : α⦄


@[simp] lemma Commute.smul_left_iff : Commute (g • a) b ↔ Commute a b

{G : Type u_3}
{H : Type u_4}
[Group G]
[Mul H]
[MulAction G H]
[SMulCommClass G H H]
[IsScalarTower G H H]
{g : G}
{a b : H}


theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b

{α : Type u_1}
[PartialOrder α]
[PredOrder α]
{b : α}
(H : ∀ a > b, Order.pred a < b)


theorem complete_univ {α : Type u} [UniformSpace α] [CompleteSpace α] :
    IsComplete (univ : Set α)


@[simp]
theorem mem_product {l₁ : List α} {l₂ : List β} {a : α} {b : β} :
    (a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂

{α : Type u_1}
{β : Type u_2}
{l₁ : List α}
{l₂ : List β}
{a : α}
{b : β}

(a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂


/-- The quotient of a ring by an ideal is a field iff the ideal is maximal. -/
theorem maximal_ideal_iff_isField_quotient (I : Ideal R) : I.IsMaximal ↔ IsField (R ⧸ I)


/-- An affine combination over `s.subtype pred` equals one over `s.filter pred`. -/
theorem affineCombination_subtype_eq_filter (w : ι → k) (p : ι → P) (pred : ι → Prop)
    [DecidablePred pred] :
    ((s.subtype pred).affineCombination k (fun i => p i) fun i => w i) =
      (s.filter pred).affineCombination k p w

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[S : AffineSpace V P]
{ι : Type u_4}
(s : Finset ι)
(w : ι → k)
(p : ι → P)
(pred : ι → Prop)
[DecidablePred pred]

((Finset.affineCombination k (Finset.subtype pred s) fun i => p ↑i) fun i => w ↑i) =
  (Finset.affineCombination k (Finset.filter pred s) p) w


theorem id_mem_of_tgt {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 d ∈ S.arrows d d

{C : Type u}
[CategoryTheory.Groupoid C]
(S : CategoryTheory.Subgroupoid C)
{c d : C}
{f : c ⟶ d}
(h : f ∈ S.arrows c d)

CategoryTheory.CategoryStruct.id d ∈ S.arrows d d


@[simp]
theorem singleton_inter_nonempty : ({a} ∩ s).Nonempty ↔ a ∈ s


theorem _root_.AntitoneOn.mono (h : AntitoneOn f s) (h' : s₂ ⊆ s) : AntitoneOn f s₂

{α : Type u_1}
{β : Type u_2}
{s s₂ : Set α}
{f : α → β}
[Preorder α]
[Preorder β]
(h : AntitoneOn f s)
(h' : s₂ ⊆ s)


/-- If `n % 4 = 1`, then `χ₄ n = 1`. -/
theorem χ₄_int_one_mod_four {n : ℤ} (hn : n % 4 = 1) : χ₄ n = 1


theorem away_of_isUnit_of_bijective {R : Type*} (S : Type*) [CommRing R] [CommRing S]
    [Algebra R S] {r : R} (hr : IsUnit r) (H : Function.Bijective (algebraMap R S)) :
    IsLocalization.Away r S

(H : Function.Bijective ⇑(algebraMap R S))


/--
The functor from `C` to `Over X` which sends `Y : C` to `π₁ : X ⨯ Y ⟶ X`, sometimes denoted `X*`.
-/
@[simps! obj_left obj_hom map_left]
def star [HasBinaryProducts C] : C ⥤ Over X

∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  ((CategoryTheory.Over.star X).map f).left = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) f


theorem ofFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : FractionRing K[X]) :
    ofFractionRing (c • p) = c • ofFractionRing p

{K : Type u}
[CommRing K]
{R : Type u_1}
[SMul R (FractionRing K[X])]
(c : R)
(p : FractionRing K[X])

{ toFractionRing := c • p } = c • { toFractionRing := p }


private theorem restrictNonposSeq_succ (n : ℕ) :
    restrictNonposSeq s i n.succ = someExistsOneDivLT s (i \ ⋃ k ≤ n, restrictNonposSeq s i k)

{α : Type u_1}
[MeasurableSpace α]
{s : MeasureTheory.SignedMeasure α}
{i : Set α}
(n : ℕ)

MeasureTheory.SignedMeasure.restrictNonposSeq s i n.succ =
  MeasureTheory.SignedMeasure.someExistsOneDivLT s
    (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k)


private theorem newton_seq_dist_aux (n : ℕ) :
    ∀ k : ℕ, ‖newton_seq (n + k) - newton_seq n‖ ≤ ‖F.derivative.eval a‖ * T ^ 2 ^ n

(hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)

‖newton_seq_gen hnorm (n + k) - newton_seq_gen hnorm n‖ ≤
  ‖Polynomial.eval a (Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n


theorem isLittleO_irrefl' (h : ∃ᶠ x in l, ‖f' x‖ ≠ 0) : ¬f' =o[l] f'

{α : Type u_1}
{E' : Type u_6}
[SeminormedAddCommGroup E']
{f' : α → E'}
{l : Filter α}
(h : ∃ᶠ (x : α) in l, ‖f' x‖ ≠ 0)


theorem normSq_eq_zero {z : ℂ} : normSq z = 0 ↔ z = 0


theorem isTotallyDisconnected_empty : IsTotallyDisconnected (∅ : Set α)


theorem HasFTaylorSeriesUpTo.eq_iteratedFDeriv
    (h : HasFTaylorSeriesUpTo n f p) {m : ℕ} (hmn : (m : ℕ∞) ≤ n) (x : E) :
    p x m = iteratedFDeriv 𝕜 m f x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
{n : ℕ∞}
{p : E → FormalMultilinearSeries 𝕜 E F}
(h : HasFTaylorSeriesUpTo n f p)
{m : ℕ}
(hmn : ↑m ≤ n)
(x : E)


@[simp]
theorem toDeleteEdges_copy {v u u' v' : V} (s : Set (Sym2 V))
    (p : G.Walk u v) (hu : u = u') (hv : v = v') (h) :
    (p.copy hu hv).toDeleteEdges s h =
      (p.toDeleteEdges s (by subst_vars; exact h)).copy hu hv

{V : Type u}
(G : SimpleGraph V)
{v u u' v' : V}
(s : Set (Sym2 V))
(p : G.Walk u v)
(hu : u = u')
(hv : v = v')
(h : ∀ e ∈ (p.copy hu hv).edges, e ∉ s)

SimpleGraph.Walk.toDeleteEdges s (p.copy hu hv) h = (SimpleGraph.Walk.toDeleteEdges s p ⋯).copy hu hv


/-- **Chebyshev's inequality**: one can control the deviation probability of a real random variable
from its expectation in terms of the variance. -/
theorem meas_ge_le_variance_div_sq [@IsFiniteMeasure Ω _ ℙ] {X : Ω → ℝ} (hX : Memℒp X 2) {c : ℝ}
    (hc : 0 < c) : ℙ {ω | c ≤ |X ω - 𝔼[X]|} ≤ ENNReal.ofReal (Var[X] / c ^ 2)

{Ω : Type u_1}
[MeasureTheory.MeasureSpace Ω]
[MeasureTheory.IsFiniteMeasure ℙ]
{X : Ω → ℝ}
(hX : MeasureTheory.Memℒp X 2 ℙ)
{c : ℝ}
(hc : 0 < c)

ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} ≤ ENNReal.ofReal (ProbabilityTheory.variance X ℙ / c ^ 2)


@[to_additive]
theorem prod_eq_single_of_mem {s : Finset α} {f : α → β} (a : α) (h : a ∈ s)
    (h₀ : ∀ b ∈ s, b ≠ a → f b = 1) : ∏ x ∈ s, f x = f a

{α : Type u_3}
{β : Type u_4}
[CommMonoid β]
{s : Finset α}
{f : α → β}
(a : α)
(h : a ∈ s)
(h₀ : ∀ b ∈ s, b ≠ a → f b = 1)


@[to_additive]
theorem inv_apply [Inv β] (f : α →ₛ β) (x : α) : f⁻¹ x = (f x)⁻¹

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[Neg β]
(f : MeasureTheory.SimpleFunc α β)
(x : α)


@[simp]
theorem inv_mul_cancel (h : a ≠ 0) : a⁻¹ * a = 1

{G₀ : Type u_3}
[GroupWithZero G₀]
{a : G₀}
(h : a ≠ 0)


/-- Note that we rarely use `CompleteSemilatticeSup`
(in fact, any such object is always a `CompleteLattice`, so it's usually best to start there).

Nevertheless it is sometimes a useful intermediate step in constructions.
-/
class CompleteSemilatticeSup (α : Type*) extends PartialOrder α, SupSet α where
  /-- Any element of a set is less than the set supremum. -/
  le_sSup : ∀ s, ∀ a ∈ s, a ≤ sSup s
  /-- Any upper bound is more than the set supremum. -/
  sSup_le : ∀ s a, (∀ b ∈ s, b ≤ a) → sSup s ≤ a

{α : Type u_9}
[self : CompleteSemilatticeSup α]
(s : Set α)
(a : α)


theorem setIntegral_compProd_univ_right (f : β × γ → E) {s : Set β} (hs : MeasurableSet s)
    (hf : IntegrableOn f (s ×ˢ univ) ((κ ⊗ₖ η) a)) :
    ∫ z in s ×ˢ univ, f z ∂(κ ⊗ₖ η) a = ∫ x in s, ∫ y, f (x, y) ∂η (a, x) ∂κ a

{η : ProbabilityTheory.Kernel (α × β) γ}

(hf : MeasureTheory.IntegrableOn f (s ×ˢ Set.univ) ((κ ⊗ₖ η) a))

∫ (z : β × γ) in s ×ˢ Set.univ, f z ∂(κ ⊗ₖ η) a = ∫ (x : β) in s, ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a


/-- If `φ` is a normed bump function, compute `φ ⋆ g`
if `g` is constant on `Metric.ball x₀ φ.rOut`. -/
theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :
    (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = g x₀

(hg : ∀ x ∈ Metric.ball x₀ φ.rOut, g x = g x₀)

(φ.normed μ ⋆[ContinuousLinearMap.lsmul ℝ ℝ, μ] g) x₀ = g x₀


theorem Succ.rec_bot (p : α → Prop) (hbot : p ⊥) (hsucc : ∀ a, p a → p (succ a)) (a : α) : p a

(hsucc : ∀ (a : α), p a → p (Order.succ a))


theorem injOn_of_ncard_image_eq (h : (f '' s).ncard = s.ncard) (hs : s.Finite := by toFinite_tac) :
    Set.InjOn f s

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{f : α → β}
(h : (f '' s).ncard = s.ncard)
(hs : s.Finite := by toFinite_tac)


/-- See `inv_le_inv_of_le` for the implication from right-to-left with one fewer assumption. -/
theorem inv_le_inv (ha : 0 < a) (hb : 0 < b) : a⁻¹ ≤ b⁻¹ ↔ b ≤ a

{α : Type u_2}
[LinearOrderedSemifield α]
{a b : α}
(ha : 0 < a)
(hb : 0 < b)

a⁻¹ ≤ b⁻¹ ↔ b ≤ a


protected theorem isBot (a : α) : IsBot a

{α : Type u_1}
[Preorder α]
[Subsingleton α]
(a : α)


/--
A constructor for lax monoidal functors whose axioms are described by `tensorHom` instead of
`whiskerLeft` and `whiskerRight`.
-/
@[simps]
def LaxMonoidalFunctor.ofTensorHom (F : C ⥤ D)
    /- unit morphism -/
    (ε : 𝟙_ D ⟶ F.obj (𝟙_ C))
    /- tensorator -/
    (μ : ∀ X Y : C, F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Y))
    (μ_natural :
      ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
        (F.map f ⊗ F.map g) ≫ μ Y Y' = μ X X' ≫ F.map (f ⊗ g) := by
      aesop_cat)
    /- associativity of the tensorator -/
    (associativity :
      ∀ X Y Z : C,
        (μ X Y ⊗ 𝟙 (F.obj Z)) ≫ μ (X ⊗ Y) Z ≫ F.map (α_ X Y Z).hom =
          (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom ≫ (𝟙 (F.obj X) ⊗ μ Y Z) ≫ μ X (Y ⊗ Z) := by
      aesop_cat)
    /- unitality -/
    (left_unitality :
      ∀ X : C, (λ_ (F.obj X)).hom = (ε ⊗ 𝟙 (F.obj X)) ≫ μ (𝟙_ C) X ≫ F.map (λ_ X).hom := by
        aesop_cat)
    (right_unitality :
      ∀ X : C, (ρ_ (F.obj X)).hom = (𝟙 (F.obj X) ⊗ ε) ≫ μ X (𝟙_ C) ≫ F.map (ρ_ X).hom := by
        aesop_cat) :
        LaxMonoidalFunctor C D

(μ :
  (X Y : C) →
    CategoryTheory.MonoidalCategory.tensorObj (F.obj X) (F.obj Y) ⟶
      F.obj (CategoryTheory.MonoidalCategory.tensorObj X Y))

(μ_natural :
  ∀ {X Y X' Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y'),
    CategoryTheory.MonoidalCategory.tensorHom (F.map f) (F.map g) ≫ μ Y Y' =
      μ X X' ≫ F.map (CategoryTheory.MonoidalCategory.tensorHom f g) := by
  aesop_cat)

(associativity :
  ∀ (X Y Z : C),
    CategoryTheory.MonoidalCategory.tensorHom (μ X Y) (𝟙 (F.obj Z)) ≫
        μ (CategoryTheory.MonoidalCategory.tensorObj X Y) Z ≫
          F.map (CategoryTheory.MonoidalCategory.associator X Y Z).hom =
      (CategoryTheory.MonoidalCategory.associator (F.obj X) (F.obj Y) (F.obj Z)).hom ≫
        CategoryTheory.MonoidalCategory.tensorHom (𝟙 (F.obj X)) (μ Y Z) ≫
          μ X (CategoryTheory.MonoidalCategory.tensorObj Y Z) := by
  aesop_cat)

(left_unitality :
  ∀ (X : C),
    (CategoryTheory.MonoidalCategory.leftUnitor (F.obj X)).hom =
      CategoryTheory.MonoidalCategory.tensorHom ε (𝟙 (F.obj X)) ≫
        μ (𝟙_ C) X ≫ F.map (CategoryTheory.MonoidalCategory.leftUnitor X).hom := by
  aesop_cat)

(right_unitality :
  ∀ (X : C),
    (CategoryTheory.MonoidalCategory.rightUnitor (F.obj X)).hom =
      CategoryTheory.MonoidalCategory.tensorHom (𝟙 (F.obj X)) ε ≫
        μ X (𝟙_ C) ≫ F.map (CategoryTheory.MonoidalCategory.rightUnitor X).hom := by
  aesop_cat)

∀ {X Y : C} (a : X ⟶ Y),
  (CategoryTheory.LaxMonoidalFunctor.ofTensorHom F ε μ μ_natural associativity left_unitality right_unitality).map a =
    F.map a


@[simp] lemma unop_inv_braiding (X Y : Cᵒᵖ) : (β_ X Y).inv.unop = (β_ (unop Y) (unop X)).inv

(C : Type u₁)
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
[CategoryTheory.BraidedCategory C]
(X Y : Cᵒᵖ)

(β_ X Y).inv.unop = (β_ (Opposite.unop Y) (Opposite.unop X)).inv


/-- **Hölder inequality**: the scalar product of two functions is bounded by the product of their
`L^p` and `L^q` norms when `p` and `q` are conjugate exponents. A version for `NNReal`-valued
functions. For an alternative version, convenient if the infinite sums are already expressed as
`p`-th powers, see `inner_le_Lp_mul_Lq_hasSum`. -/
theorem inner_le_Lp_mul_Lq_tsum {f g : ι → ℝ≥0} {p q : ℝ} (hpq : p.IsConjExponent q)
    (hf : Summable fun i => f i ^ p) (hg : Summable fun i => g i ^ q) :
    (Summable fun i => f i * g i) ∧
      ∑' i, f i * g i ≤ (∑' i, f i ^ p) ^ (1 / p) * (∑' i, g i ^ q) ^ (1 / q)

{ι : Type u}
{f g : ι → ℝ≥0}
{p q : ℝ}
(hpq : p.IsConjExponent q)
(hf : Summable fun i => f i ^ p)
(hg : Summable fun i => g i ^ q)

(Summable fun i => f i * g i) ∧
  ∑' (i : ι), f i * g i ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)


{R : Type u_1}
{M : Type u_2}
[Ring R]
[AddCommGroup M]
[Module R M]
(p : Submodule R M)


@[to_additive]
theorem monotone_comap {f : F} : Monotone (comap f)

{M : Type u_1}
{N : Type u_2}
[AddZeroClass M]
[AddZeroClass N]
{F : Type u_4}
[FunLike F M N]
[mc : AddMonoidHomClass F M N]
{f : F}


theorem countable_isBot (α : Type*) [PartialOrder α] : { x : α | IsBot x }.Countable


theorem le_succ_of_pred_le : pred n ≤ m → n ≤ succ m


/-- An element of `contDiffGroupoid ⊤ I` is `C^n` for any `n`. -/
theorem contMDiffOn_of_mem_contDiffGroupoid {e' : PartialHomeomorph H H}
    (h : e' ∈ contDiffGroupoid ⊤ I) : ContMDiffOn I I n e' e'.source

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{n : ℕ∞}
{e' : PartialHomeomorph H H}
(h : e' ∈ contDiffGroupoid ⊤ I)


@[to_additive]
theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
    AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x

{α : Type u_5}
{E : Type u_6}
[SeminormedCommGroup E]
[PseudoEMetricSpace α]
{Kf Kg : ℝ≥0}
{f g : α → E}
(hf : AntilipschitzWith Kf f)
(hg : LipschitzWith Kg g)
(hK : Kg < Kf⁻¹)


@[simp]
theorem mem_iInf {ι} (p : ι → Submodule R M) {x} : (x ∈ ⨅ i, p i) ↔ ∀ i, x ∈ p i

{R : Type u_1}
{M : Type u_3}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{ι : Sort u_4}
(p : ι → Submodule R M)
{x : M}


theorem rdrop_eq_reverse_drop_reverse : l.rdrop n = reverse (l.reverse.drop n)

l.rdrop n = (List.drop n l.reverse).reverse


/-- A measurable set `s` is a *fundamental domain* for an additive action of an additive group `G`
on a measurable space `α` with respect to a measure `α` if the sets `g +ᵥ s`, `g : G`, are pairwise
a.e. disjoint and cover the whole space. -/
structure IsAddFundamentalDomain (G : Type*) {α : Type*} [Zero G] [VAdd G α] [MeasurableSpace α]
    (s : Set α) (μ : Measure α := by volume_tac) : Prop where
  protected nullMeasurableSet : NullMeasurableSet s μ
  protected ae_covers : ∀ᵐ x ∂μ, ∃ g : G, g +ᵥ x ∈ s
  protected aedisjoint : Pairwise <| (AEDisjoint μ on fun g : G => g +ᵥ s)

{μ : autoParam (MeasureTheory.Measure α) _auto✝}

(self : MeasureTheory.IsAddFundamentalDomain G s μ)

Pairwise (MeasureTheory.AEDisjoint μ on fun g => g +ᵥ s)


@[simp]
theorem ofMkLEMk_refl {B A₁ : C} (f : A₁ ⟶ B) [Mono f] : ofMkLEMk f f le_rfl = 𝟙 _

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{B A₁ : C}
(f : A₁ ⟶ B)
[CategoryTheory.Mono f]

CategoryTheory.Subobject.ofMkLEMk f f ⋯ = CategoryTheory.CategoryStruct.id A₁


@[simp]
theorem basis_repr_tmul (a : A) (m : M) :
    (basis A b).repr (a ⊗ₜ m) = a • Finsupp.mapRange (algebraMap R A) (map_zero _) (b.repr m)

{R : Type uR}
{A : Type uA}
{M : Type uM}
{ι : Type uι}
[CommSemiring R]
[Semiring A]
[Algebra R A]
[AddCommMonoid M]
[Module R M]
(b : Basis ι R M)
(a : A)
(m : M)

(Algebra.TensorProduct.basis A b).repr (a ⊗ₜ[R] m) = a • Finsupp.mapRange ⇑(algebraMap R A) ⋯ (b.repr m)


/-- If all closed balls of large enough radius are compact, then the space is proper. Especially
useful when the lower bound for the radius is 0. -/
theorem ProperSpace.of_isCompact_closedBall_of_le (R : ℝ)
    (h : ∀ x : α, ∀ r, R ≤ r → IsCompact (closedBall x r)) : ProperSpace α

(h : ∀ (x : α) (r : ℝ), R ≤ r → IsCompact (Metric.closedBall x r))


@[simp, norm_cast]
lemma coe_inf' {ι : Type*} {s : Finset ι} (H : s.Nonempty) (f : ι → C(α, β)) :
    ⇑(s.inf' H f) = s.inf' H fun i ↦ ⇑(f i)

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
[SemilatticeInf β]
[ContinuousInf β]
{ι : Type u_4}
{s : Finset ι}
(H : s.Nonempty)
(f : ι → C(α, β))

⇑(s.inf' H f) = s.inf' H fun i => ⇑(f i)


@[simp] protected lemma mul_inv_le_one (a : ℝ≥0∞) : a * a⁻¹ ≤ 1


theorem closedBall_disjoint_ball (h : δ + ε ≤ dist x y) : Disjoint (closedBall x δ) (ball y ε)

{α : Type u}
[PseudoMetricSpace α]
{x y : α}
{δ ε : ℝ}
(h : δ + ε ≤ dist x y)

Disjoint (Metric.closedBall x δ) (Metric.ball y ε)


theorem inl_mono : Monotone (toLex ∘ inl : α → α ⊕ₗ β)

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]


/-- The functor from a groupoid `C` to its opposite sending every morphism to its inverse. -/
@[simps]
noncomputable def Groupoid.invFunctor : C ⥤ Cᵒᵖ

(C : Type u)
[CategoryTheory.Groupoid C]
{X Y : C}
(f : X ⟶ Y)

(CategoryTheory.Groupoid.invFunctor C).map f = (CategoryTheory.Groupoid.inv f).op


/--
A relation series `a₀ -r→ a₁ -r→ ... -r→ aₙ` of `r` gives a relation series of the reverse of `r`
by reversing the series `aₙ ←r- aₙ₋₁ ←r- ... ←r- a₁ ←r- a₀`.
-/
@[simps length]
def reverse (p : RelSeries r) : RelSeries (fun (a b : α) ↦ r b a)

{α : Type u_1}
{r : Rel α α}
(p : RelSeries r)


@[simp]
theorem realize_formula (g : M ≃[L] N) (φ : L.Formula α) {v : α → M} :
    φ.Realize (g ∘ v) ↔ φ.Realize v

{L : FirstOrder.Language}
{M : Type w}
{N : Type u_1}
[L.Structure M]
[L.Structure N]
{α : Type u'}
(g : L.Equiv M N)
(φ : L.Formula α)
{v : α → M}


theorem ContDiff.csinh {n} (h : ContDiff ℂ n f) : ContDiff ℂ n fun x => Complex.sinh (f x)

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℂ E]
{f : E → ℂ}
{n : ℕ∞}
(h : ContDiff ℂ n f)


@[simp]
theorem toSpanSingleton_zero : toSpanSingleton R M 0 = 0

(R : Type u_1)
(M : Type u_4)
[Semiring R]
[AddCommMonoid M]
[Module R M]


theorem Continuous.comp_upperSemicontinuousOn {g : γ → δ} {f : α → γ} (hg : Continuous g)
    (hf : UpperSemicontinuousOn f s) (gmon : Monotone g) : UpperSemicontinuousOn (g ∘ f) s

{α : Type u_1}
[TopologicalSpace α]
{s : Set α}
{γ : Type u_3}
[LinearOrder γ]
[TopologicalSpace γ]
[OrderTopology γ]
{δ : Type u_4}
[LinearOrder δ]
[TopologicalSpace δ]
[OrderTopology δ]
{g : γ → δ}
{f : α → γ}
(hg : Continuous g)
(hf : UpperSemicontinuousOn f s)
(gmon : Monotone g)


theorem card_range_le {α β : Type*} (f : α → β) [Fintype α] [Fintype (Set.range f)] :
    Fintype.card (Set.range f) ≤ Fintype.card α

{α : Type u_4}
{β : Type u_5}
(f : α → β)
[Fintype α]
[Fintype ↑(Set.range f)]

Fintype.card ↑(Set.range f) ≤ Fintype.card α


protected theorem sub_neg (a b : Int) : a - -b = a + b


@[to_additive]
theorem singleton_div_ball : {x} / ball y δ = ball (x / y) δ

{E : Type u_1}
[SeminormedCommGroup E]
(δ : ℝ)
(x y : E)

{x} / Metric.ball y δ = Metric.ball (x / y) δ


theorem hall_cond_of_compl {ι : Type u} {t : ι → Finset α} {s : Finset ι}
    (hus : s.card = (s.biUnion t).card) (ht : ∀ s : Finset ι, s.card ≤ (s.biUnion t).card)
    (s' : Finset (sᶜ : Set ι)) : s'.card ≤ (s'.biUnion fun x' => t x' \ s.biUnion t).card

(ht : ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card)

s'.card ≤ (s'.biUnion fun x' => t ↑x' \ s.biUnion t).card


@[simps!]
instance : MonoidalCategoryStruct (Dial C)


theorem coe_id : (NormedAddGroupHom.id V : V → V) = _root_.id

(V : Type u_1)
[SeminormedAddCommGroup V]


nonrec theorem SmoothOn.prod_mk {f : M → M'} {g : M → N'} (hf : SmoothOn I I' f s)
    (hg : SmoothOn I J' g s) : SmoothOn I (I'.prod J') (fun x => (f x, g x)) s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{E' : Type u_5}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_6}
[TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7}
[TopologicalSpace M']
[ChartedSpace H' M']
{F' : Type u_14}
[NormedAddCommGroup F']
[NormedSpace 𝕜 F']
{G' : Type u_15}
[TopologicalSpace G']
{J' : ModelWithCorners 𝕜 F' G'}
{N' : Type u_16}
[TopologicalSpace N']
[ChartedSpace G' N']
{s : Set M}
{f : M → M'}
{g : M → N'}
(hf : SmoothOn I I' f s)
(hg : SmoothOn I J' g s)


/-- The cocone points of two colimit cocones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit t) (w : F ≅ G) : s.pt ≅ t.pt

{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F G : J ⥤ C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)

(P.coconePointsIsoOfNatIso Q w).inv = Q.map s w.inv


/-- The universal property of the tensor product of algebras.

Pairs of algebra morphisms that commute are equivalent to algebra morphisms from the tensor product.

This is `Algebra.TensorProduct.lift` as an equivalence.

See also `GradedTensorProduct.liftEquiv` for an alternative commutativity requirement for graded
algebra. -/
@[simps]
def liftEquiv : {fg : (A →ₐ[S] C) × (B →ₐ[R] C) // ∀ x y, Commute (fg.1 x) (fg.2 y)}
    ≃ ((A ⊗[R] B) →ₐ[S] C)

{R : Type uR}
{S : Type uS}
{A : Type uA}
{B : Type uB}
{C : Type uC}
[CommSemiring R]
[CommSemiring S]
[Algebra R S]
[Semiring A]
[Algebra R A]
[Algebra S A]
[IsScalarTower R S A]
[Semiring B]
[Algebra R B]
[Semiring C]
[Algebra R C]
[Algebra S C]
[IsScalarTower R S C]
(f' : A ⊗[R] B →ₐ[S] C)

↑(Algebra.TensorProduct.liftEquiv.symm f') =
  (f'.comp Algebra.TensorProduct.includeLeft, (AlgHom.restrictScalars R f').comp Algebra.TensorProduct.includeRight)


lemma iterate_bit0 (hf : Involutive f) (n : ℕ) : f^[2 * n] = id

{α : Type u_5}
{f : α → α}
(hf : Function.Involutive f)
(n : ℕ)


theorem Coalgebra.homEquiv_naturality_str_symm (adj : F ⊣ G) (V₁ V₂ : Coalgebra G) (f : V₁ ⟶ V₂) :
    F.map f.f ≫ (adj.homEquiv V₂.V V₂.V).symm V₂.str =
    (adj.homEquiv V₁.V V₁.V).symm V₁.str ≫ f.f

(V₁ V₂ : CategoryTheory.Endofunctor.Coalgebra G)

CategoryTheory.CategoryStruct.comp (F.map f.f) ((adj.homEquiv V₂.V V₂.V).symm V₂.str) =
  CategoryTheory.CategoryStruct.comp ((adj.homEquiv V₁.V V₁.V).symm V₁.str) f.f


@[to_additive]
theorem tendsto_inv_nhdsWithin_Ioi_inv {a : H} : Tendsto Inv.inv (𝓝[>] a⁻¹) (𝓝[<] a)

{H : Type x}
[TopologicalSpace H]
[OrderedCommGroup H]
[ContinuousInv H]
{a : H}

Filter.Tendsto Inv.inv (𝓝[>] a⁻¹) (𝓝[<] a)


theorem pbind_eq_bind (f : α → Option β) (x : Option α) : (x.pbind fun a _ ↦ f a) = x.bind f

{α : Type u_1}
{β : Type u_2}
(f : α → Option β)
(x : Option α)


theorem exists_results_of_mem {s : Computation α} {a} (h : a ∈ s) : ∃ n, Results s a n

{α : Type u}
{s : Computation α}
{a : α}
(h : a ∈ s)


/-- A property ensuring that the tangent cone to `s` at `x` spans a dense subset of the whole space.
The main role of this property is to ensure that the differential within `s` at `x` is unique,
hence this name. The uniqueness it asserts is proved in `UniqueDiffWithinAt.eq` in `Fderiv.Basic`.
To avoid pathologies in dimension 0, we also require that `x` belongs to the closure of `s` (which
is automatic when `E` is not `0`-dimensional). -/
@[mk_iff]
structure UniqueDiffWithinAt (s : Set E) (x : E) : Prop where
  dense_tangentCone : Dense (Submodule.span 𝕜 (tangentConeAt 𝕜 s x) : Set E)
  mem_closure : x ∈ closure s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[AddCommMonoid E]
[Module 𝕜 E]
[TopologicalSpace E]
{s : Set E}
{x : E}
(self : UniqueDiffWithinAt 𝕜 s x)


theorem univ_fin2 : (univ : Finset (Fin 2)) = {0, 1}


theorem Ideal.pow_le_prime_iff {I P : Ideal R} [_hP : P.IsPrime] {n : ℕ} (hn : n ≠ 0) :
    I ^ n ≤ P ↔ I ≤ P

{R : Type u_1}
[CommRing R]
[IsDedekindDomain R]
{I P : Ideal R}
[_hP : P.IsPrime]
{n : ℕ}
(hn : n ≠ 0)


theorem remainder_pos {m : ℝ} (hm : 1 < m) (k : ℕ) : 0 < remainder m k


theorem measurable_fract [BorelSpace R] : Measurable (Int.fract : R → R)

{R : Type u_2}
[LinearOrderedRing R]
[FloorRing R]
[TopologicalSpace R]
[OrderTopology R]
[MeasurableSpace R]
[BorelSpace R]


theorem mem_span_singleton' {x y : α} : x ∈ span ({y} : Set α) ↔ ∃ a, a * y = x


/-- The opposite `ShortComplex` in `Cᵒᵖ` associated to a short complex in `C`. -/
@[simps]
def op : ShortComplex Cᵒᵖ


theorem mk_covBy_mk_iff_left : (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂

{α : Type u_1}
{β : Type u_2}
[PartialOrder α]
[PartialOrder β]
{a₁ a₂ : α}
{b : β}


theorem IsUpperSet.bot_mem (hs : IsUpperSet s) : ⊥ ∈ s ↔ s = univ

{α : Type u_1}
[Preorder α]
{s : Set α}
[OrderBot α]
(hs : IsUpperSet s)


lemma Continuous.finset_sup'_apply (hne : s.Nonempty) (hs : ∀ i ∈ s, Continuous (f i)) :
    Continuous (fun a ↦ s.sup' hne (f · a))

{L : Type u_1}
{X : Type u_2}
[TopologicalSpace L]
[TopologicalSpace X]
{ι : Type u_3}
[SemilatticeSup L]
[ContinuousSup L]
{s : Finset ι}
{f : ι → X → L}
(hne : s.Nonempty)
(hs : ∀ i ∈ s, Continuous (f i))

Continuous fun a => s.sup' hne fun x => f x a


theorem sub_lt_of_abs_sub_lt_right (h : |a - b| < c) : a - c < b

{α : Type u_1}
[LinearOrderedAddCommGroup α]
{a b c : α}
(h : |a - b| < c)


/-- The kernel of the natural homomorphism from a monoid to its quotient by a congruence
    relation `c` equals `c`. -/
@[to_additive (attr := simp) "The kernel of the natural homomorphism from an `AddMonoid` to its
quotient by an additive congruence relation `c` equals `c`."]
theorem mk'_ker : ker c.mk' = c

{M : Type u_1}
[MulOneClass M]
(c : Con M)


@[simp]
theorem uniqueMDiffOn_image (h : M ≃ₘ^n⟮I, J⟯ N) (hn : 1 ≤ n) {s : Set M} :
    UniqueMDiffOn J (h '' s) ↔ UniqueMDiffOn I s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_4}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{H : Type u_5}
[TopologicalSpace H]
{G : Type u_7}
[TopologicalSpace G]
{I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 F G}
{M : Type u_9}
[TopologicalSpace M]
[ChartedSpace H M]
{N : Type u_11}
[TopologicalSpace N]
[ChartedSpace G N]
{n : ℕ∞}
[SmoothManifoldWithCorners I M]
[SmoothManifoldWithCorners J N]
(h : M ≃ₘ^n⟮I, J⟯ N)
(hn : 1 ≤ n)
{s : Set M}

UniqueMDiffOn J (⇑h '' s) ↔ UniqueMDiffOn I s


theorem smoothAt_coordChangeL {x : B} (h : x ∈ e.baseSet) (h' : x ∈ e'.baseSet) :
    SmoothAt IB 𝓘(𝕜, F →L[𝕜] F) (fun b : B => (e.coordChangeL 𝕜 e' b : F →L[𝕜] F)) x

[TopologicalSpace (Bundle.TotalSpace F E)]

{e e' : Trivialization F Bundle.TotalSpace.proj}

SmoothAt IB 𝓘(𝕜, F →L[𝕜] F) (fun b => ↑(Trivialization.coordChangeL 𝕜 e e' b)) x


lemma IsOpenMap.coborder_preimage_subset (hf : IsOpenMap f) (s : Set Y) :
    coborder (f ⁻¹' s) ⊆ f ⁻¹' (coborder s)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
{f : X → Y}
(hf : IsOpenMap f)
(s : Set Y)


theorem lt_top_of_finrank_lt_finrank {s : Submodule R M} (lt : finrank R s < finrank R M) :
    s < ⊤

(lt : FiniteDimensional.finrank R ↥s < FiniteDimensional.finrank R M)


/-- The inclusion of the base ring in a topological algebra as a continuous linear map. -/
@[simps]
def algebraMapCLM : R →L[R] A

(R : Type u_1)
(A : Type u)
[CommSemiring R]
[Semiring A]
[Algebra R A]
[TopologicalSpace R]
[TopologicalSpace A]
[ContinuousSMul R A]
(a : R)

(algebraMapCLM R A) a = (algebraMap R A) a


@[to_additive (attr := simp) card_nsmul_eq_zero']
theorem pow_card_eq_one' {G : Type*} [Group G] {x : G} : x ^ Nat.card G = 1


protected theorem mul_self_sub_mul_self_eq (a b : Nat) : a * a - b * b = (a + b) * (a - b)


/-- `sq` is the quadratic form mapping the vector `x : A` to `x * x` -/
@[simps!]
def sq : QuadraticMap R A A

{R : Type u_3}
{A : Type u_7}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[SMulCommClass R A A]
[IsScalarTower R A A]
(a : A)


theorem functorPushforward_comp (R : Sieve X) :
    R.functorPushforward (F ⋙ G) = (R.functorPushforward F).functorPushforward G

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D)
{X : C}
{E : Type u₃}
[CategoryTheory.Category.{v₃, u₃} E]
(G : CategoryTheory.Functor D E)
(R : CategoryTheory.Sieve X)

CategoryTheory.Sieve.functorPushforward (F.comp G) R =
  CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functorPushforward F R)


lemma _root_.Odd.intCast (hn : Odd n) : Odd (n : α)

{α : Type u_3}
[Ring α]
{n : ℤ}
(hn : Odd n)


theorem openEmbedding_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (h : Injective f₁) :
    OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ i, OpenEmbedding (f₂ i)

{ι : Type u_5}
{κ : Type u_6}
{σ : ι → Type u_7}
{τ : κ → Type u_8}
[(i : ι) → TopologicalSpace (σ i)]
[(k : κ) → TopologicalSpace (τ k)]
{f₁ : ι → κ}
{f₂ : (i : ι) → σ i → τ (f₁ i)}
(h : Function.Injective f₁)

OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), OpenEmbedding (f₂ i)


@[to_additive]
theorem ContinuousInv.induced {α : Type*} {β : Type*} {F : Type*} [FunLike F α β] [Group α]
    [Group β] [MonoidHomClass F α β] [tβ : TopologicalSpace β] [ContinuousInv β] (f : F) :
    @ContinuousInv α (tβ.induced f) _

{α : Type u_1}
{β : Type u_2}
{F : Type u_3}
[FunLike F α β]
[Group α]
[Group β]
[MonoidHomClass F α β]
[tβ : TopologicalSpace β]
[ContinuousInv β]
(f : F)


@[simp]
theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0


/-- The axiomatic definition of conditional probability derived from a measure-theoretic one. -/
theorem cond_apply (hms : MeasurableSet s) (t : Set Ω) : μ[t|s] = (μ s)⁻¹ * μ (s ∩ t)

{Ω : Type u_1}
{m : MeasurableSpace Ω}
(μ : MeasureTheory.Measure Ω)
{s : Set Ω}
(hms : MeasurableSet s)
(t : Set Ω)

(ProbabilityTheory.cond μ s) t = (μ s)⁻¹ * μ (s ∩ t)


theorem list_succ_last (n) : list (n+1) = (list n).map castSucc ++ [last n]

Fin.list (n + 1) = List.map Fin.castSucc (Fin.list n) ++ [Fin.last n]


/-- A polynomial `p` lifts if and only if it is in the image of `mapAlg`. -/
theorem mem_lifts_iff_mem_alg (R : Type u) [CommSemiring R] {S : Type v} [Semiring S] [Algebra R S]
    (p : S[X]) : p ∈ lifts (algebraMap R S) ↔ p ∈ AlgHom.range (@mapAlg R _ S _ _)

p ∈ Polynomial.lifts (algebraMap R S) ↔ p ∈ (Polynomial.mapAlg R S).range


@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt 𝕜 iso s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{x : E}
{s : Set E}
(iso : E ≃L[𝕜] F)


@[simp] theorem or_eq (x y : BitVec w)                    : BitVec.or x y = x ||| y


theorem comp_lipschitzOnWith {Kf Kg : ℝ≥0} {f : β → γ} {g : α → β} {s : Set α}
    (hf : LipschitzWith Kf f) (hg : LipschitzOnWith Kg g s) : LipschitzOnWith (Kf * Kg) (f ∘ g) s

{α : Type u}
{β : Type v}
{γ : Type w}
[PseudoEMetricSpace α]
[PseudoEMetricSpace β]
[PseudoEMetricSpace γ]
{Kf Kg : ℝ≥0}
{f : β → γ}
{g : α → β}
{s : Set α}
(hf : LipschitzWith Kf f)
(hg : LipschitzOnWith Kg g s)


/-- An implication of predicates `P → P'` induces a braided functor between full braided
subcategories. -/
@[simps!]
def fullBraidedSubcategory.map (h : ∀ ⦃X⦄, P X → P' X) :
    BraidedFunctor (FullSubcategory P) (FullSubcategory P')

(X Y : CategoryTheory.FullSubcategory P)

(CategoryTheory.MonoidalCategory.fullBraidedSubcategory.map h).μ X Y =
  CategoryTheory.CategoryStruct.id
    (CategoryTheory.MonoidalCategory.tensorObj ((CategoryTheory.FullSubcategory.map h).obj X)
      ((CategoryTheory.FullSubcategory.map h).obj Y))


@[simp]
theorem div_neg_self {a : K} (h : a ≠ 0) : a / -a = -1

{K : Type u_3}
[DivisionRing K]
{a : K}
(h : a ≠ 0)


@[simp, norm_cast]
theorem toNNReal_coe : (r : ℝ≥0∞).toNNReal = r


/-- Monotone convergence theorem for nonincreasing sequences of functions -/
theorem lintegral_iInf {f : ℕ → α → ℝ≥0∞} (h_meas : ∀ n, Measurable (f n)) (h_anti : Antitone f)
    (h_fin : ∫⁻ a, f 0 a ∂μ ≠ ∞) : ∫⁻ a, ⨅ n, f n a ∂μ = ⨅ n, ∫⁻ a, f n a ∂μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : ℕ → α → ℝ≥0∞}
(h_meas : ∀ (n : ℕ), Measurable (f n))
(h_anti : Antitone f)
(h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤)

∫⁻ (a : α), ⨅ n, f n a ∂μ = ⨅ n, ∫⁻ (a : α), f n a ∂μ


theorem ne_empty_of_mem (hs : s ∈ f) : s ≠ ∅

{α : Type u}
{f : Ultrafilter α}
{s : Set α}
(hs : s ∈ f)


/-- Now we consider a square:
```
  A ---f---> X
  |          |
  i          p
  |          |
  v          v
  B ---g---> Y
```

The datum of a lift in a commutative square, i.e. an up-right-diagonal
morphism which makes both triangles commute. -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
@[ext]
structure LiftStruct (sq : CommSq f i p g) where
  /-- The lift. -/
  l : B ⟶ X
  /-- The upper left triangle commutes. -/
  fac_left : i ≫ l = f
  /-- The lower right triangle commutes. -/
  fac_right : l ≫ p = g

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
{A B X Y : C}
{f : A ⟶ X}
{i : A ⟶ B}
{p : X ⟶ Y}
{g : B ⟶ Y}
{sq : CategoryTheory.CommSq f i p g}
(self : sq.LiftStruct)

CategoryTheory.CategoryStruct.comp i self.l = f


/-- The equivalence between `RingHom` and `ℚ`-algebra homomorphisms. -/
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S)

{R : Type u_1}
{S : Type u_2}
[Ring R]
[Ring S]
[Algebra ℚ R]
[Algebra ℚ S]
(f : R →+* S)

RingHom.equivRatAlgHom f = f.toRatAlgHom


@[simp]
theorem comp_refl (f : M ↪[L] N) : f.comp (refl L M) = f

{L : FirstOrder.Language}
{M : Type w}
{N : Type w'}
[L.Structure M]
[L.Structure N]
(f : L.Embedding M N)

f.comp (FirstOrder.Language.Embedding.refl L M) = f


@[simp]
theorem curryFinFinset_symm_apply_const (hk : s.card = k) (hl : sᶜ.card = l)
    (f : G[×k]→L[𝕜] G[×l]→L[𝕜] G') (x : G) :
    ((curryFinFinset 𝕜 G G' hk hl).symm f fun _ => x) = f (fun _ => x) fun _ => x

(f : ContinuousMultilinearMap 𝕜 (fun i => G) (ContinuousMultilinearMap 𝕜 (fun i => G) G'))

(((ContinuousMultilinearMap.curryFinFinset 𝕜 G G' hk hl).symm f) fun x_1 => x) = (f fun x_1 => x) fun x_1 => x


@[simp] theorem pos_lt_eq (p₁ p₂ : Pos) : (p₁ < p₂) = (p₁.1 < p₂.1)


theorem eapprox_comp [MeasurableSpace γ] {f : γ → ℝ≥0∞} {g : α → γ} {n : ℕ} (hf : Measurable f)
    (hg : Measurable g) : (eapprox (f ∘ g) n : α → ℝ≥0∞) = (eapprox f n : γ →ₛ ℝ≥0∞) ∘ g

{α : Type u_1}
{γ : Type u_3}
[MeasurableSpace α]
[MeasurableSpace γ]
{f : γ → ℝ≥0∞}
{g : α → γ}
{n : ℕ}
(hf : Measurable f)
(hg : Measurable g)

↑(MeasureTheory.SimpleFunc.eapprox (f ∘ g) n) = ↑(MeasureTheory.SimpleFunc.eapprox f n) ∘ g


theorem iget_of_mem [Inhabited α] {a : α} : ∀ {o : Option α}, a ∈ o → o.iget = a

{α : Type u_1}
[Inhabited α]
{a : α}
{o : Option α}


@[simp]
theorem toAddSubmonoid_sSup (s : Set (Submodule R M)) :
    (sSup s).toAddSubmonoid = sSup (toAddSubmonoid '' s)

{R : Type u_1}
{M : Type u_3}
[Semiring R]
[AddCommMonoid M]
[Module R M]
(s : Set (Submodule R M))

(sSup s).toAddSubmonoid = sSup (Submodule.toAddSubmonoid '' s)


lemma zero₁ (j j' : J) (h : ¬ c.Rel j' j) :
    hom₁ h₁ f₂ F c j j' = 0

{C₁ : Type u_1}
{C₂ : Type u_2}
{D : Type u_3}
{I₁ : Type u_4}
{I₂ : Type u_5}
{J : Type u_6}
[CategoryTheory.Category.{u_8, u_1} C₁]
[CategoryTheory.Category.{u_9, u_2} C₂]
[CategoryTheory.Category.{u_7, u_3} D]
[CategoryTheory.Preadditive C₁]
[CategoryTheory.Preadditive C₂]
[CategoryTheory.Preadditive D]
{c₁ : ComplexShape I₁}
{c₂ : ComplexShape I₂}
{K₁ L₁ : HomologicalComplex C₁ c₁}
{f₁ f₁' : K₁ ⟶ L₁}
(h₁ : Homotopy f₁ f₁')
{K₂ L₂ : HomologicalComplex C₂ c₂}
(f₂ : K₂ ⟶ L₂)
(F : C₁ ⥤ C₂ ⥤ D)
[F.Additive]
[∀ (X₁ : C₁), (F.obj X₁).Additive]
(c : ComplexShape J)
[DecidableEq J]
[TotalComplexShape c₁ c₂ c]
[K₁.HasMapBifunctor K₂ F c]
[L₁.HasMapBifunctor L₂ F c]
(j j' : J)
(h : ¬c.Rel j' j)

HomologicalComplex.mapBifunctorMapHomotopy.hom₁ h₁ f₂ F c j j' = 0


lemma of_openCover (H : ∀ i, P (𝒰.map i ≫ f)) : P f

{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}


protected theorem measurableSet_ge_of_countable {ι} [LinearOrder ι] {τ : Ω → ι} {f : Filtration ι m}
    [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) : MeasurableSet[f i] {ω | i ≤ τ ω}

{Ω : Type u_1}
{m : MeasurableSpace Ω}
{ι : Type u_4}
[LinearOrder ι]
{τ : Ω → ι}
{f : MeasureTheory.Filtration ι m}
[Countable ι]
(hτ : MeasureTheory.IsStoppingTime f τ)
(i : ι)


/-- Elements of disjoint, normal subgroups commute. -/
@[to_additive "Elements of disjoint, normal subgroups commute."]
theorem commute_of_normal_of_disjoint (H₁ H₂ : Subgroup G) (hH₁ : H₁.Normal) (hH₂ : H₂.Normal)
    (hdis : Disjoint H₁ H₂) (x y : G) (hx : x ∈ H₁) (hy : y ∈ H₂) : Commute x y

{G : Type u_1}
[Group G]
(H₁ H₂ : Subgroup G)
(hH₁ : H₁.Normal)
(hH₂ : H₂.Normal)
(hdis : Disjoint H₁ H₂)
(x y : G)
(hx : x ∈ H₁)
(hy : y ∈ H₂)


/-- Baire theorem: if countably many closed sets cover the whole space, then their interiors
are dense. Formulated here with `⋃₀`. -/
theorem dense_sUnion_interior_of_closed {S : Set (Set X)} (hc : ∀ s ∈ S, IsClosed s)
    (hS : S.Countable) (hU : ⋃₀ S = univ) : Dense (⋃ s ∈ S, interior s)

{X : Type u_1}
[TopologicalSpace X]
[BaireSpace X]
{S : Set (Set X)}
(hc : ∀ s ∈ S, IsClosed s)
(hS : S.Countable)
(hU : ⋃₀ S = Set.univ)


@[simp]
theorem card_sigma {σ : α → Type*} (s : Finset α) (t : ∀ a, Finset (σ a)) :
    card (s.sigma t) = ∑ a ∈ s, card (t a)

{α : Type u_3}
{σ : α → Type u_6}
(s : Finset α)
(t : (a : α) → Finset (σ a))


@[norm_cast, simp]
theorem dist_cast_real (x y : ℤ) : dist (x : ℝ) y = dist x y


@[simp]
theorem piecewise_empty [∀ i : α, Decidable (i ∈ (∅ : Set α))] : piecewise ∅ f g = g

{α : Type u_1}
{δ : α → Sort u_6}
(f g : (i : α) → δ i)
[(i : α) → Decidable (i ∈ ∅)]


/-- The generator of the annihilating ideal has minimal degree among
 the non-zero members of the annihilating ideal -/
theorem degree_annIdealGenerator_le_of_mem (a : A) (p : 𝕜[X]) (hp : p ∈ annIdeal 𝕜 a)
    (hpn0 : p ≠ 0) : degree (annIdealGenerator 𝕜 a) ≤ degree p

{𝕜 : Type u_1}
{A : Type u_2}
[Field 𝕜]
[Ring A]
[Algebra 𝕜 A]
(a : A)
(p : 𝕜[X])
(hp : p ∈ Polynomial.annIdeal 𝕜 a)
(hpn0 : p ≠ 0)

(Polynomial.annIdealGenerator 𝕜 a).degree ≤ p.degree


theorem ChainClosure.isChain (hc : ChainClosure r c) : IsChain r c

{α : Type u_1}
{r : α → α → Prop}
{c : Set α}
(hc : ChainClosure r c)


theorem find_mem {c : Set (PartialRefinement u s)} (i : ι) (ne : c.Nonempty) : find c ne i ∈ c

{c : Set (ShrinkingLemma.PartialRefinement u s)}

ShrinkingLemma.PartialRefinement.find c ne i ∈ c


theorem conductor_eq_top_of_powerBasis (pb : PowerBasis R S) : conductor R pb.gen = ⊤

{R : Type u_1}
{S : Type u_2}
[CommRing R]
[CommRing S]
[Algebra R S]
(pb : PowerBasis R S)


/-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N)

{M : Type u_1}
{N : Type u_2}
[One M]
[One N]
(f : OneHom M N)


/-- Postcompose a partial equivalence with an equivalence.
We modify the source and target to have better definitional behavior. -/
@[simps!]
def transEquiv (e : PartialEquiv α β) (f' : β ≃ γ) : PartialEquiv α γ

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(e : PartialEquiv α β)
(f' : β ≃ γ)


/-- 1 is in the set of natural number powers of an element of a monoid. -/
@[to_additive "0 is in the set of natural number multiples of an element of an `AddMonoid`."]
theorem powers.one_mem {x : M} : (1 : M) ∈ powers x


@[to_additive]
nonrec theorem SmoothAt.inv {f : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀) :
    SmoothAt I' I (fun x => (f x)⁻¹) x₀

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{H : Type u_2}
[TopologicalSpace H]
{E : Type u_3}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{I : ModelWithCorners 𝕜 E H}
{G : Type u_5}
[TopologicalSpace G]
[ChartedSpace H G]
[AddGroup G]
[LieAddGroup I G]
{E' : Type u_6}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_7}
[TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'}
{M : Type u_8}
[TopologicalSpace M]
[ChartedSpace H' M]
{f : M → G}
{x₀ : M}
(hf : SmoothAt I' I f x₀)


theorem norm_setIntegral_le_of_norm_le_const {C : ℝ} (hs : μ s < ∞) (hC : ∀ x ∈ s, ‖f x‖ ≤ C)
    (hfm : AEStronglyMeasurable f (μ.restrict s)) : ‖∫ x in s, f x ∂μ‖ ≤ C * (μ s).toReal

(hfm : MeasureTheory.AEStronglyMeasurable f (μ.restrict s))

‖∫ (x : X) in s, f x ∂μ‖ ≤ C * (μ s).toReal


@[simp]
theorem symm_symm (e : A₁ ≃ₐ[R] A₂) : e.symm.symm = e

{R : Type uR}
{A₁ : Type uA₁}
{A₂ : Type uA₂}
[CommSemiring R]
[Semiring A₁]
[Semiring A₂]
[Algebra R A₁]
[Algebra R A₂]
(e : A₁ ≃ₐ[R] A₂)


@[simp] theorem all_eq (p : α → β → Bool) (l : AssocList α β) :
    all p l = l.toList.all fun (a, b) => p a b

{α : Type u_1}
{β : Type u_2}
(p : α → β → Bool)
(l : Batteries.AssocList α β)

Batteries.AssocList.all p l =
  l.toList.all fun x =>
    match x with
    | (a, b) => p a b


theorem max_def' [LinearOrder α] (a b : α) : max a b = if b ≤ a then a else b

{α : Type u_2}
[LinearOrder α]
(a b : α)


@[simp]
theorem self_sub_toIocMod (a b : α) : b - toIocMod hp a b = toIocDiv hp a b • p

{α : Type u_1}
[LinearOrderedAddCommGroup α]
[hα : Archimedean α]
{p : α}
(hp : 0 < p)
(a b : α)


theorem of_surjective {α β} [Infinite β] (f : α → β) (hf : Surjective f) : Infinite α

{α : Sort u_4}
{β : Sort u_5}
[Infinite β]
(f : α → β)
(hf : Function.Surjective f)


@[measurability]
theorem measurableSet_interior : MeasurableSet (interior s)

{α : Type u_1}
{s : Set α}
[TopologicalSpace α]
[MeasurableSpace α]
[OpensMeasurableSpace α]


@[simp]
protected theorem irrefl {v : V} : ¬G.Adj v v

{V : Type u}
(G : SimpleGraph V)
{v : V}


theorem periodizedBernoulli.continuous {k : ℕ} (hk : k ≠ 1) : Continuous (periodizedBernoulli k)


@[to_additive]
theorem characteristic_iff_le_comap : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.comap ϕ.toMonoidHom

{G : Type u_1}
[AddGroup G]
{H : AddSubgroup G}

H.Characteristic ↔ ∀ (ϕ : G ≃+ G), H ≤ AddSubgroup.comap ϕ.toAddMonoidHom H


/-- `repr` preserves addition, up to multiples of `f` -/
theorem repr_add_sub_repr_add_repr_mem_span (h : IsAdjoinRoot S f) (x y : S) :
    h.repr (x + y) - (h.repr x + h.repr y) ∈ Ideal.span ({f} : Set R[X])

{R : Type u}
{S : Type v}
[CommRing R]
[Ring S]
{f : R[X]}
[Algebra R S]
(h : IsAdjoinRoot S f)
(x y : S)

h.repr (x + y) - (h.repr x + h.repr y) ∈ Ideal.span {f}


@[simp]
theorem eraseLead_C_mul_X_pow (r : R) (n : ℕ) : eraseLead (C r * X ^ n) = 0

{R : Type u_1}
[Semiring R]
(r : R)
(n : ℕ)

(Polynomial.C r * Polynomial.X ^ n).eraseLead = 0


@[to_additive (attr := simp)]
theorem toSubmonoid_eq {p q : Subgroup G} : p.toSubmonoid = q.toSubmonoid ↔ p = q

{G : Type u_1}
[AddGroup G]
{p q : AddSubgroup G}

p.toAddSubmonoid = q.toAddSubmonoid ↔ p = q


@[simp, norm_cast]
theorem coe_sup [SemilatticeSup α] {P : α → Prop}
    (Psup : ∀ ⦃x y⦄, P x → P y → P (x ⊔ y)) (x y : Subtype P) :
    (haveI := Subtype.semilatticeSup Psup; (x ⊔ y : Subtype P) : α) = (x ⊔ y : α)

(Psup : ∀ ⦃x y : α⦄, P x → P y → P (x ⊔ y))


/-- If we're boundaryless, `(extChartAt I x).target` is a neighborhood of the key point -/
theorem extChartAt_target_mem_nhds [I.Boundaryless] (x : M) :
    (extChartAt I x).target ∈ 𝓝 (extChartAt I x x)

{𝕜 : Type u_1}
{E : Type u_2}
{M : Type u_3}
{H : Type u_4}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[TopologicalSpace H]
[TopologicalSpace M]
(I : ModelWithCorners 𝕜 E H)
[ChartedSpace H M]
[I.Boundaryless]
(x : M)

(extChartAt I x).target ∈ 𝓝 (↑(extChartAt I x) x)


theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false


@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHaus.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a

(w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)

CategoryTheory.CategoryStruct.comp (CompHaus.pullback.lift f g a b w) (CompHaus.pullback.fst f g) = a


@[simp]
theorem flip_apply (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (x : E) (y : F) : f.flip y x = f x y

{𝕜 : Type u_1}
{𝕜₂ : Type u_2}
{𝕜₃ : Type u_3}
{E : Type u_4}
{F : Type u_6}
{G : Type u_8}
[SeminormedAddCommGroup E]
[SeminormedAddCommGroup F]
[SeminormedAddCommGroup G]
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜₂]
[NontriviallyNormedField 𝕜₃]
[NormedSpace 𝕜 E]
[NormedSpace 𝕜₂ F]
[NormedSpace 𝕜₃ G]
{σ₂₃ : 𝕜₂ →+* 𝕜₃}
{σ₁₃ : 𝕜 →+* 𝕜₃}
[RingHomIsometric σ₂₃]
[RingHomIsometric σ₁₃]
(f : E →SL[σ₁₃] F →SL[σ₂₃] G)
(x : E)
(y : F)


theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x'

{α : Type u_1}
[LinearOrder α]
{x y : α}
{β : Type u_3}
[LinearOrder β]
{x' y' : β}


@[simp]
theorem Monic.natDegree_map [Semiring S] [Nontrivial S] {P : R[X]} (hmo : P.Monic) (f : R →+* S) :
    (P.map f).natDegree = P.natDegree

{R : Type u}
{S : Type v}
[Semiring R]
[Semiring S]
[Nontrivial S]
{P : R[X]}
(hmo : P.Monic)
(f : R →+* S)

(Polynomial.map f P).natDegree = P.natDegree


theorem natDegree_map_eq_of_injective (hf : Injective f) (p : R[X]) :
    natDegree (p.map f) = natDegree p

{R : Type u}
{S : Type v}
[Semiring R]
[Semiring S]
{f : R →+* S}
(hf : Function.Injective ⇑f)
(p : R[X])

(Polynomial.map f p).natDegree = p.natDegree


theorem hyperoperation_ge_four_zero (n k : ℕ) :
    hyperoperation (n + 4) 0 k = if Even k then 1 else 0


theorem Memℒp.of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (hμ'_le : μ' ≤ c • μ)
    {f : α → E} (hf : Memℒp f p μ) : Memℒp f p μ'

{α : Type u_1}
{E : Type u_2}
{m0 : MeasurableSpace α}
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup E]
{μ' : MeasureTheory.Measure α}
(c : ℝ≥0∞)
(hc : c ≠ ⊤)
(hμ'_le : μ' ≤ c • μ)
{f : α → E}
(hf : MeasureTheory.Memℒp f p μ)


@[simp]
theorem withDensityᵥ_neg : μ.withDensityᵥ (-f) = -μ.withDensityᵥ f

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{E : Type u_3}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{f : α → E}


lemma mk_map {V W : Type*} [Quiver V] [Quiver W] {obj : V → W} {map} {X Y : V} {f : X ⟶ Y} :
    (Prefunctor.mk obj map).map f = map f

{map : {X Y : V} → (X ⟶ Y) → (obj X ⟶ obj Y)}

{ obj := obj, map := map }.map f = map f


theorem mem_of_one_mem (h : (1 : S) ∈ I) (x) : x ∈ I

{S : Type u_2}
[CommRing S]
{I : Ideal S}
(h : 1 ∈ I)
(x : S)