@[simp]
theorem colimit_presheaf (F : J ⥤ PresheafedSpace.{_, _, v} C) :
    (colimit F).presheaf = limit (pushforwardDiagramToColimit F).leftOp

[∀ (X : TopCat), CategoryTheory.Limits.HasLimitsOfShape Jᵒᵖ (TopCat.Presheaf C X)]

(F : J ⥤ AlgebraicGeometry.PresheafedSpace C)

(AlgebraicGeometry.PresheafedSpace.colimit F).presheaf =
  CategoryTheory.Limits.limit (AlgebraicGeometry.PresheafedSpace.pushforwardDiagramToColimit F).leftOp


protected theorem map_smul (c : R) (x : M) : fₗ (c • x) = c • fₗ x

{R : Type u_1}
{M : Type u_9}
{M₂ : Type u_11}
[Semiring R]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R M₂]
(fₗ : M →ₗ[R] M₂)
(c : R)
(x : M)


theorem toAList_cons (a : α) (b : β a) (xs : List (Sigma β)) :
    List.toAList (⟨a, b⟩ :: xs) = insert a b xs.toAList

{α : Type u}
{β : α → Type v}
[DecidableEq α]
(a : α)
(b : β a)
(xs : List (Sigma β))

(⟨a, b⟩ :: xs).toAList = AList.insert a b xs.toAList


@[simp]
theorem card_bind : card (s.bind f) = (s.map (card ∘ f)).sum

{α : Type u_1}
{β : Type v}
(s : Multiset α)
(f : α → Multiset β)

Multiset.card (s.bind f) = (Multiset.map (⇑Multiset.card ∘ f) s).sum


@[to_additive (attr := simp)]
theorem semiconjBy_iff_eq [CancelCommMonoid M] {a x y : M} : SemiconjBy a x y ↔ x = y

{M : Type u_2}
[CancelCommMonoid M]
{a x y : M}


@[simp]
theorem preimage_Ioc (e : α ≃o β) (a b : β) : e ⁻¹' Ioc a b = Ioc (e.symm a) (e.symm b)

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]
(e : α ≃o β)
(a b : β)

⇑e ⁻¹' Set.Ioc a b = Set.Ioc (e.symm a) (e.symm b)


theorem rel_map_right {s : Multiset α} {t : Multiset γ} {f : γ → β} :
    Rel r s (t.map f) ↔ Rel (fun a b => r a (f b)) s t

{α : Type u_1}
{β : Type v}
{γ : Type u_2}
{r : α → β → Prop}
{s : Multiset α}
{t : Multiset γ}
{f : γ → β}

Multiset.Rel r s (Multiset.map f t) ↔ Multiset.Rel (fun a b => r a (f b)) s t


@[simp] lemma image_compl : s.image compl = sᶜˢ

{α : Type u_2}
[DecidableEq α]
[BooleanAlgebra α]
(s : Finset α)


protected theorem _root_.HasSum.toNNReal {f : α → ℝ} {y : ℝ} (hf₀ : ∀ n, 0 ≤ f n)
    (hy : HasSum f y) : HasSum (fun x => Real.toNNReal (f x)) y.toNNReal

{α : Type u_1}
{f : α → ℝ}
{y : ℝ}
(hf₀ : ∀ (n : α), 0 ≤ f n)
(hy : HasSum f y)

HasSum (fun x => (f x).toNNReal) y.toNNReal


@[simp]
theorem sortedUniv_nodup (α) [Fintype α] [Encodable α] : (sortedUniv α).Nodup

(α : Type u_2)
[Fintype α]
[Encodable α]


@[simp]
theorem vec2_dotProduct (v w : Fin 2 → α) : v ⬝ᵥ w = v 0 * w 0 + v 1 * w 1

{α : Type u}
[AddCommMonoid α]
[Mul α]
(v w : Fin 2 → α)

Matrix.dotProduct v w = v 0 * w 0 + v 1 * w 1


@[simp] theorem id_comp (f : BoundedLatticeHom α β) : (BoundedLatticeHom.id β).comp f = f

{α : Type u_3}
{β : Type u_4}
[Lattice α]
[Lattice β]
[BoundedOrder α]
[BoundedOrder β]
(f : BoundedLatticeHom α β)


/-- If two unoriented angles are equal, and the signs of the corresponding oriented angles are
equal, then the oriented angles are equal (even in degenerate cases). -/
theorem oangle_eq_of_angle_eq_of_sign_eq {p₁ p₂ p₃ p₄ p₅ p₆ : P} (h : ∠ p₁ p₂ p₃ = ∠ p₄ p₅ p₆)
    (hs : (∡ p₁ p₂ p₃).sign = (∡ p₄ p₅ p₆).sign) : ∡ p₁ p₂ p₃ = ∡ p₄ p₅ p₆

[hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]

∡ p₁ p₂ p₃ = ∡ p₄ p₅ p₆


theorem ofBool_eq_iff_eq : ∀(b b' : Bool), BitVec.ofBool b = BitVec.ofBool b' ↔ b = b'


theorem isNat_zpow_pos {α : Type*} [DivisionSemiring α] {a : α} {b : ℤ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsNat (a ^ nb) ne) :
    IsNat (a ^ b) ne

(pe' : Mathlib.Meta.NormNum.IsNat (a ^ nb) ne)


theorem setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀ (μ : Measure α)
    {f : α → ℝ≥0∞} {s : Set α} (hf : AEMeasurable f (μ.restrict s)) (g : α → ℝ≥0∞)
    (hs : MeasurableSet s) (h'f : ∀ᵐ x ∂μ.restrict s, f x < ∞) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ

{f : α → ℝ≥0∞}

(g : α → ℝ≥0∞)

(h'f : ∀ᵐ (x : α) ∂μ.restrict s, f x < ⊤)

∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ


theorem EuclideanSpace.nndist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : nndist x y = NNReal.sqrt (∑ i, nndist (x i) (y i) ^ 2)

{𝕜 : Type u_8}
[RCLike 𝕜]
{n : Type u_9}
[Fintype n]
(x y : EuclideanSpace 𝕜 n)

nndist x y = NNReal.sqrt (∑ i : n, nndist (x i) (y i) ^ 2)


@[simp]
theorem app_smul (X : C) (r : R) (α : F ⟶ G) : (r • α).app X = r • α.app X

{R : Type u_1}
[Semiring R]
{C : Type u_2}
{D : Type u_3}
[CategoryTheory.Category.{u_5, u_2} C]
[CategoryTheory.Category.{u_4, u_3} D]
[CategoryTheory.Preadditive D]
[CategoryTheory.Linear R D]
{F G : CategoryTheory.Functor C D}
(X : C)
(r : R)
(α : F ⟶ G)


theorem ad_ker_eq_bot_of_hasTrivialRadical [HasTrivialRadical R L] : (ad R L).ker = ⊥

(R : Type u_1)
(L : Type u_2)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[LieAlgebra.HasTrivialRadical R L]


/-- If `f` is a partial homeomorphism defined on a neighbourhood of `f.symm a`, and `f` has a
nonzero derivative `f'` at `f.symm a`, then `f.symm` has the derivative `f'⁻¹` at `a`.

This is one of the easy parts of the inverse function theorem: it assumes that we already have
an inverse function. -/
theorem PartialHomeomorph.hasDerivAt_symm (f : PartialHomeomorph 𝕜 𝕜) {a f' : 𝕜} (ha : a ∈ f.target)
    (hf' : f' ≠ 0) (htff' : HasDerivAt f f' (f.symm a)) : HasDerivAt f.symm f'⁻¹ a

(htff' : HasDerivAt (↑f) f' (↑f.symm a))


theorem findIdx_of_get?_eq_some {xs : List α} (w : xs.get? (xs.findIdx p) = some y) : p y

(w : xs.get? (List.findIdx p xs) = some y)


theorem length_pos {l : List α} : 0 < length l ↔ l ≠ []


theorem pure_injective : Injective (pure : α → NonemptyInterval α)


@[measurability, fun_prop]
theorem AEMeasurable.real_toNNReal {f : α → ℝ} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => Real.toNNReal (f x)) μ

{α : Type u_1}
[MeasurableSpace α]
{f : α → ℝ}
{μ : MeasureTheory.Measure α}
(hf : AEMeasurable f μ)

AEMeasurable (fun x => (f x).toNNReal) μ


lemma succAbove_pred_of_le (p i : Fin (n + 1)) (h : i ≤ p) (hi : i ≠ 0) :
    succAbove p (i.pred hi) = (i.pred hi).castSucc

p.succAbove (i.pred hi) = (i.pred hi).castSucc


theorem pow_right_iff (hm : 0 < m) : IsRelPrime x (y ^ m) ↔ IsRelPrime x y

{α : Type u_1}
[CommMonoid α]
[DecompositionMonoid α]
{x y : α}
{m : ℕ}
(hm : 0 < m)


/-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃
      NormedAddGroupHom V₁ (f.equalizer g)

(ψ : NormedAddGroupHom V₁ ↥(f.equalizer g))

↑(NormedAddGroupHom.Equalizer.liftEquiv.symm ψ) = (NormedAddGroupHom.Equalizer.ι f g).comp ψ


/-- The Cartesian product of analytic functions is analytic. -/
lemma AnalyticAt.prod {e : E} {f : E → F} {g : E → G}
    (hf : AnalyticAt 𝕜 f e) (hg : AnalyticAt 𝕜 g e) :
    AnalyticAt 𝕜 (fun x ↦ (f x, g x)) e

{𝕜 : Type u_2}
[NontriviallyNormedField 𝕜]
{E : Type u_3}
{F : Type u_4}
{G : Type u_5}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{e : E}
{f : E → F}
{g : E → G}
(hf : AnalyticAt 𝕜 f e)
(hg : AnalyticAt 𝕜 g e)


theorem div_lt_self (ha : 0 < a) (hb : 1 < b) : a / b < a

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


theorem nontrivial_iff_pair_subset : s.Nontrivial ↔ ∃ x y, x ≠ y ∧ {x, y} ⊆ s


theorem oadd_mul (e₁ n₁ a₁ e₂ n₂ a₂) :
    oadd e₁ n₁ a₁ * oadd e₂ n₂ a₂ =
      if e₂ = 0 then oadd e₁ (n₁ * n₂) a₁ else oadd (e₁ + e₂) n₂ (oadd e₁ n₁ a₁ * a₂)

(e₁ : ONote)
(n₁ : ℕ+)
(a₁ e₂ : ONote)
(n₂ : ℕ+)
(a₂ : ONote)

e₁.oadd n₁ a₁ * e₂.oadd n₂ a₂ = if e₂ = 0 then e₁.oadd (n₁ * n₂) a₁ else (e₁ + e₂).oadd n₂ (e₁.oadd n₁ a₁ * a₂)


theorem comap_eq_lift' {f : Filter β} {m : α → β} : comap m f = f.lift' (preimage m)

{α : Type u_1}
{β : Type u_2}
{f : Filter β}
{m : α → β}

Filter.comap m f = f.lift' (Set.preimage m)


@[simp] theorem recAux_zero {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) :
    Nat.recAux zero succ 0 = zero

(succ : (n : Nat) → motive n → motive (n + 1))


@[simp]
theorem mem_compPartialSumTarget_iff {m M N : ℕ} {a : Σ n, Composition n} :
    a ∈ compPartialSumTarget m M N ↔
      m ≤ a.2.length ∧ a.2.length < M ∧ ∀ j : Fin a.2.length, a.2.blocksFun j < N

{m M N : ℕ}
{a : (n : ℕ) × Composition n}

a ∈ FormalMultilinearSeries.compPartialSumTarget m M N ↔
  m ≤ a.snd.length ∧ a.snd.length < M ∧ ∀ (j : Fin a.snd.length), a.snd.blocksFun j < N


lemma IsClosedMap.specializingMap (hf : IsClosedMap f) : SpecializingMap f

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


/-- A traversable functor is lawful if its `traverse` satisfies a
number of additional properties.  It must send `pure : α → Id α` to `pure`,
send the composition of applicative functors to the composition of the
`traverse` of each, send each function `f` to `fun x ↦ f <$> x`, and
satisfy a naturality condition with respect to applicative
transformations. -/
class LawfulTraversable (t : Type u → Type u) [Traversable t] extends LawfulFunctor t :
    Prop where
  /-- `traverse` plays well with `pure` of the identity monad-/
  id_traverse : ∀ {α} (x : t α), traverse (pure : α → Id α) x = x
  /-- `traverse` plays well with composition of applicative functors. -/
  comp_traverse :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G] {α β γ}
      (f : β → F γ) (g : α → G β) (x : t α),
      traverse (Functor.Comp.mk ∘ map f ∘ g) x = Comp.mk (map (traverse f) (traverse g x))
  /-- An axiom for `traverse` involving `pure : β → Id β`. -/
  traverse_eq_map_id : ∀ {α β} (f : α → β) (x : t α),
    traverse ((pure : β → Id β) ∘ f) x = id.mk (f <$> x)
  /-- The naturality axiom explaining how lawful traversable functors should play with
  lawful applicative functors. -/
  naturality :
    ∀ {F G} [Applicative F] [Applicative G] [LawfulApplicative F] [LawfulApplicative G]
      (η : ApplicativeTransformation F G) {α β} (f : α → F β) (x : t α),
      η (traverse f x) = traverse (@η _ ∘ f) x

{t : Type u → Type u}
[Traversable t]
[self : LawfulTraversable t]
{α : Type u}
(x : t α)


theorem hasFiniteIntegral_of_dominated_convergence {F : ℕ → α → β} {f : α → β} {bound : α → ℝ}
    (bound_hasFiniteIntegral : HasFiniteIntegral bound μ)
    (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) : HasFiniteIntegral f μ

{F : ℕ → α → β}

(bound_hasFiniteIntegral : MeasureTheory.HasFiniteIntegral bound μ)

(h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a)

(h_lim : ∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => F n a) Filter.atTop (𝓝 (f a)))


theorem expand_size [Hashable α] {buckets : Buckets α β} :
    (expand sz buckets).buckets.size = buckets.size

(source : Array (Batteries.AssocList α β))

(target : Batteries.HashMap.Imp.Buckets α β)

(hs : ∀ (j : Nat), j < i → source.data[j]?.getD Batteries.AssocList.nil = Batteries.AssocList.nil)

(Batteries.HashMap.Imp.expand.go i source target).size =
  Nat.sum (List.map (fun x => x.toList.length) source.data) + target.size


theorem btw_rfl_left {a b : α} : btw a a b

{α : Type u_1}
[CircularOrder α]
{a b : α}


class IncidenceGeometry where
  Point : Type u₁
  Line : Type u₂
  Circle : Type u₃

  between : Point → Point → Point → Prop -- implies colinearity
  onLine : Point → Line → Prop
  onCircle : Point → Circle → Prop
  inCircle : Point → Circle → Prop
  centerCircle : Point → Circle → Prop
  circlesInter : Circle → Circle → Prop

  ne_23_of_between : ∀ {a b c : Point}, between a b c → b ≠ c
  line_unique_of_pts : ∀ {a b : Point}, ∀ {L M : Line},
    a ≠ b → onLine a L → onLine b L → onLine a M → onLine b M → L = M
  onLine_2_of_between : ∀ {a b c : Point}, ∀ {L : Line},
    between a b c → onLine a L → onLine c L → onLine b L
  line_of_pts : ∀ a b, ∃ L, onLine a L ∧ onLine b L
  circle_of_ne : ∀ a b, a ≠ b → ∃ C, centerCircle a C ∧ onCircle b C
  circlesInter_of_onCircle_inCircle :
    ∀ {a b α β}, onCircle b α → onCircle a β → inCircle a α →
    inCircle b β → circlesInter α β
  pts_of_circlesInter : ∀ {α β}, circlesInter α β →
    ∃ a b, a ≠ b ∧ onCircle a α ∧ onCircle a β ∧ onCircle b α ∧ onCircle b β
  inCircle_of_centerCircle : ∀ {a α}, centerCircle a α → inCircle a α

[self : IncidenceGeometry]
(a b : IncidenceGeometry.Point)

∃ L, IncidenceGeometry.onLine a L ∧ IncidenceGeometry.onLine b L


theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f

{α : Type u}
{f : Filter α}
{s t : Set α}
(h : {x | x ∈ s ↔ x ∈ t} ∈ f)


theorem ofReal_le_iff_le_toReal {a : ℝ} {b : ℝ≥0∞} (hb : b ≠ ∞) :
    ENNReal.ofReal a ≤ b ↔ a ≤ ENNReal.toReal b


theorem monotone_lt {x : α} : Monotone (x < ·)


@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set G} : centralizer s = ⊤ ↔ s ⊆ center G

AddSubgroup.centralizer s = ⊤ ↔ s ⊆ ↑(AddSubgroup.center G)


theorem norm_eq_pow_val {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm = (p : ℚ) ^ (-f.valuation : ℤ)

{p : ℕ}
[Fact (Nat.Prime p)]
{f : PadicSeq p}
(hf : ¬f ≈ 0)


theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a

{α : Type u_1}
[PartialOrder α]
[SuccOrder α]
[PredOrder α]
[NoMinOrder α]
(a : α)


/-- If a function `f` with a densely ordered codomain is monotone on a neighborhood of `a` and the
closure of the image of this neighborhood under `f` is a neighborhood of `f a`, then `f` is
continuous at `a`. -/
theorem continuousAt_of_monotoneOn_of_closure_image_mem_nhds [DenselyOrdered β] {f : α → β}
    {s : Set α} {a : α} (h_mono : MonotoneOn f s) (hs : s ∈ 𝓝 a)
    (hfs : closure (f '' s) ∈ 𝓝 (f a)) : ContinuousAt f a

{α : Type u_1}
{β : Type u_2}
[LinearOrder α]
[TopologicalSpace α]
[OrderTopology α]
[LinearOrder β]
[TopologicalSpace β]
[OrderTopology β]
[DenselyOrdered β]
{f : α → β}
{s : Set α}
{a : α}
(h_mono : MonotoneOn f s)
(hs : s ∈ 𝓝 a)
(hfs : closure (f '' s) ∈ 𝓝 (f a))


theorem disjoint_closedBall_of_lt_infEdist {r : ℝ≥0∞} (h : r < infEdist x s) :
    Disjoint (closedBall x r) s

{α : Type u}
[PseudoEMetricSpace α]
{x : α}
{s : Set α}
{r : ℝ≥0∞}
(h : r < EMetric.infEdist x s)


/-- **Rational root theorem** part 1:
if `r : f.codomain` is a root of a polynomial over the ufd `A`,
then the numerator of `r` divides the constant coefficient -/
theorem num_dvd_of_is_root {p : A[X]} {r : K} (hr : aeval r p = 0) : num A r ∣ p.coeff 0

{A : Type u_1}
{K : Type u_2}
[CommRing A]
[IsDomain A]
[UniqueFactorizationMonoid A]
[Field K]
[Algebra A K]
[IsFractionRing A K]
{p : A[X]}
{r : K}
(hr : (Polynomial.aeval r) p = 0)


/-- All points have distance to the circumcenter equal to the
circumradius. -/
@[simp]
theorem dist_circumcenter_eq_circumradius' {n : ℕ} (s : Simplex ℝ P n) :
    ∀ i, dist s.circumcenter (s.points i) = s.circumradius

{V : Type u_1}
{P : Type u_2}
[NormedAddCommGroup V]
[InnerProductSpace ℝ V]
[MetricSpace P]
[NormedAddTorsor V P]
{n : ℕ}
(s : Affine.Simplex ℝ P n)
(i : Fin (n + 1))


theorem leftLim_le_rightLim (h : x < y) : leftLim f y ≤ rightLim f x

{α : Type u_1}
{β : Type u_2}
[LinearOrder α]
[ConditionallyCompleteLinearOrder β]
[TopologicalSpace β]
[OrderTopology β]
{f : α → β}
(hf : Antitone f)
{x y : α}
(h : x < y)

Function.leftLim f y ≤ Function.rightLim f x


/-- The extension of `N₁` to the Karoubi envelope of `SimplicialObject C`. -/
@[simps!]
def N₂ : Karoubi (SimplicialObject C) ⥤ Karoubi (ChainComplex C ℕ)

(P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C))

(AlgebraicTopology.DoldKan.N₂.obj P).X.d i j =
  if h : i = j + 1 then CategoryTheory.eqToHom ⋯ ≫ ∑ i : Fin (j + 2), (-1) ^ ↑i • P.X.δ i else 0


lemma IsRightCancelMulZero.to_noZeroDivisors [NonUnitalNonAssocRing α] [IsRightCancelMulZero α] :
    NoZeroDivisors α

(α : Type u_2)
[NonUnitalNonAssocRing α]
[IsRightCancelMulZero α]


/-- The forgetful functor from `Top` to `Locale` which forgets that the space has "enough points".
-/
@[simps!]
def topToLocale : TopCat ⥤ Locale

∀ {X Y : TopCat} (f : X ⟶ Y), topToLocale.map f = Quiver.Hom.op (TopologicalSpace.Opens.comap f)


@[simp]
theorem mk'_rightMovesEquiv {x y L R hL hR} :
    (@Relabelling.mk' x y L R hL hR).rightMovesEquiv = R.symm

{hL : (i : y.LeftMoves) → (x.moveLeft (L i)).Relabelling (y.moveLeft i)}

{hR : (j : y.RightMoves) → (x.moveRight (R j)).Relabelling (y.moveRight j)}

(SetTheory.PGame.Relabelling.mk' L R hL hR).rightMovesEquiv = R.symm


/-- Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence induce the same
uniform structure on `ι`.

This is a specialization of `EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi'` to
the case where `𝔖` covers `X`. -/
lemma EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi [UniformSpace ι]
    {𝔖 : Set (Set X)} (𝔖_covers : ⋃₀ 𝔖 = univ) (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
    UniformInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
    UniformInducing F

UniformInducing (⇑(UniformOnFun.ofFun 𝔖) ∘ F) ↔ UniformInducing F


theorem eq_iterate_verschiebung {x : 𝕎 R} {n : ℕ} (h : ∀ i < n, x.coeff i = 0) :
    x = verschiebung^[n] (x.shift n)

{p : ℕ}
{R : Type u_1}
[hp : Fact (Nat.Prime p)]
[CommRing R]
{x : WittVector p R}
{n : ℕ}
(h : ∀ i < n, x.coeff i = 0)

x = (⇑WittVector.verschiebung)^[n] (x.shift n)


theorem existsUnique (h : IsUniversal f) (g : CostructuredArrow S T) :
    ∃! η : g.left ⟶ f.left, S.map η ≫ f.hom = g.hom

{f : CategoryTheory.CostructuredArrow S T}

(g : CategoryTheory.CostructuredArrow S T)

∃! η, CategoryTheory.CategoryStruct.comp (S.map η) f.hom = g.hom


/-- Two submonoids are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T

{M : Type u_1}
[AddZeroClass M]
{S T : AddSubmonoid M}
(h : ∀ (x : M), x ∈ S ↔ x ∈ T)


protected lemma inv_pos : 0 < z⁻¹ ↔ 0 < z


@[simp]
theorem boundary_zero : (c.boundary ⟨0, c.card_boundaries_pos⟩ : Fin (n + 1)) = 0


@[to_additive prod_top]
theorem prod_top (K : Subgroup G) : K.prod (⊤ : Subgroup N) = K.comap (MonoidHom.fst G N)

{G : Type u_1}
[Group G]
{N : Type u_5}
[Group N]
(K : Subgroup G)

K.prod ⊤ = Subgroup.comap (MonoidHom.fst G N) K


@[to_additive (attr := simp)]
theorem _root_.Subgroup.ker_subtype (H : Subgroup G) : H.subtype.ker = ⊥

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


theorem pi_subset {s : Finset α} (t₁ t₂ : ∀ a, Finset (β a)) (h : ∀ a ∈ s, t₁ a ⊆ t₂ a) :
    s.pi t₁ ⊆ s.pi t₂

{α : Type u_1}
{β : α → Type u}
[DecidableEq α]
{s : Finset α}
(t₁ t₂ : (a : α) → Finset (β a))
(h : ∀ a ∈ s, t₁ a ⊆ t₂ a)


@[simp]
theorem isNilpotent_mulLeft_iff (a : A) : IsNilpotent (mulLeft R a) ↔ IsNilpotent a

(R : Type u_1)
{A : Type v}
[CommSemiring R]
[Semiring A]
[Algebra R A]
(a : A)

IsNilpotent (LinearMap.mulLeft R a) ↔ IsNilpotent a


theorem det_eq_prod_roots_charpoly [IsAlgClosed R] : A.det = (Matrix.charpoly A).roots.prod

{n : Type u_1}
[Fintype n]
[DecidableEq n]
{R : Type u_2}
[Field R]
(A : Matrix n n R)
[IsAlgClosed R]


theorem mem_support_seq_iff : b ∈ (seq q p).support ↔ ∃ f ∈ q.support, b ∈ f '' p.support

{α : Type u_1}
{β : Type u_2}
(q : PMF (α → β))
(p : PMF α)
(b : β)

b ∈ (q.seq p).support ↔ ∃ f ∈ q.support, b ∈ f '' p.support


theorem snd_map_fst : (Submodule.snd R M M₂).map (LinearMap.fst R M M₂) = ⊥

(R : Type u)
(M : Type v)
(M₂ : Type w)
[Semiring R]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R M₂]

Submodule.map (LinearMap.fst R M M₂) (Submodule.snd R M M₂) = ⊥


lemma map_injective (hf : Function.Injective f) : Function.Injective <| map W f

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
(W : WeierstrassCurve.Affine R)
{f : R →+* S}
(hf : Function.Injective ⇑f)

Function.Injective ⇑(WeierstrassCurve.Affine.CoordinateRing.map W f)


@[simp]
theorem piLp_equiv_toEuclideanLin_apply (M : Matrix m n 𝕜) (v : EuclideanSpace 𝕜 n) :
    WithLp.equiv 2 (m → 𝕜) (toEuclideanLin M v) = M *ᵥ WithLp.equiv 2 (n → 𝕜) v

{𝕜 : Type u_3}
[RCLike 𝕜]
{m : Type u_8}
{n : Type u_9}
[Fintype n]
[DecidableEq n]
(M : Matrix m n 𝕜)
(v : EuclideanSpace 𝕜 n)

(WithLp.equiv 2 (m → 𝕜)) ((Matrix.toEuclideanLin M) v) = M.mulVec ((WithLp.equiv 2 (n → 𝕜)) v)


@[to_additive (attr := simp)]
protected lemma mul_div_cancel_right (h : IsUnit b) (a : α) : a * b / b = a

{α : Type u}
[DivisionMonoid α]
{b : α}
(h : IsUnit b)
(a : α)


theorem cofan_inj_id (n : ℕ) : (s.cofan _).inj (IndexSet.id (op [n])) = s.ι n

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
{X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X)
(n : ℕ)

(s.cofan (Opposite.op [n])).inj (SimplicialObject.Splitting.IndexSet.id (Opposite.op [n])) = s.ι n


/-- Commutative monoid objects in `C` are "just" braided lax monoidal functors from the trivial
braided monoidal category to `C`.
-/
@[simps]
def equivLaxBraidedFunctorPUnit : LaxBraidedFunctor (Discrete PUnit.{u + 1}) C ≌ CommMon_ C

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

(CommMon_.equivLaxBraidedFunctorPUnit C).counitIso = CommMon_.EquivLaxBraidedFunctorPUnit.counitIso C


@[simp]
theorem transvection_mul_apply_of_ne (a b : n) (ha : a ≠ i) (c : R) (M : Matrix n n R) :
    (transvection i j c * M) a b = M a b

{n : Type u_1}
{R : Type u₂}
[DecidableEq n]
[CommRing R]
(i j : n)
[Fintype n]
(a b : n)
(ha : a ≠ i)
(c : R)
(M : Matrix n n R)

(Matrix.transvection i j c * M) a b = M a b


/-- Reinterpret `Additive α →+ β` as `α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative' [MulOneClass α] [AddZeroClass β] :
    (Additive α →+ β) ≃ (α →* Multiplicative β)

{α : Type u}
{β : Type v}
[MulOneClass α]
[AddZeroClass β]
(f : Additive α →+ β)
(a : α)

(AddMonoidHom.toMultiplicative' f) a = Multiplicative.ofAdd (f (Additive.ofMul a))


theorem lt_mul_of_limit {a b c : Ordinal} (h : IsLimit c) : a < b * c ↔ ∃ c' < c, a < b * c'


/-- The Hurwitz zeta function is differentiable away from `s = 1`. -/
lemma differentiableAt_hurwitzZeta (a : UnitAddCircle) {s : ℂ} (hs : s ≠ 1) :
    DifferentiableAt ℂ (hurwitzZeta a) s

DifferentiableAt ℂ (HurwitzZeta.hurwitzZeta a) s


theorem not_mem_range_coe_iff {x : OnePoint X} : x ∉ range some ↔ x = ∞

x ∉ Set.range OnePoint.some ↔ x = OnePoint.infty


/-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
@[simps! (config := .asFn) apply symm_apply]
def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β

⇑(Equiv.funUnique α β) = fun f => f default


theorem isBigO_pow_pow_of_le_left {r₁ r₂ : ℝ} (h₁ : 0 ≤ r₁) (h₂ : r₁ ≤ r₂) :
    (fun n : ℕ ↦ r₁ ^ n) =O[atTop] fun n ↦ r₂ ^ n

(fun n => r₁ ^ n) =O[Filter.atTop] fun n => r₂ ^ n


/-- A version of `Equiv.optionCongr` for `WithBot`. -/
@[simps! apply]
def withBotCongr (e : α ≃o β) : WithBot α ≃o WithBot β

{α : Type u_2}
{β : Type u_3}
[PartialOrder α]
[PartialOrder β]
(e : α ≃o β)

∀ (a : Option α), e.withBotCongr a = Option.map (⇑e) a


/-- A monoid homomorphism `M →* N` can equivalently be viewed as a monoid homomorphism
`Mᵐᵒᵖ →* Nᵐᵒᵖ`. This is the action of the (fully faithful) `ᵐᵒᵖ`-functor on morphisms. -/
@[to_additive (attr := simps)
      "An additive monoid homomorphism `M →+ N` can equivalently be viewed as an
      additive monoid homomorphism `Mᵃᵒᵖ →+ Nᵃᵒᵖ`. This is the action of the (fully faithful)
      `ᵃᵒᵖ`-functor on morphisms."]
def MonoidHom.op {M N} [MulOneClass M] [MulOneClass N] : (M →* N) ≃ (Mᵐᵒᵖ →* Nᵐᵒᵖ)

{M : Type u_2}
{N : Type u_3}
[MulOneClass M]
[MulOneClass N]
(f : Mᵐᵒᵖ →* Nᵐᵒᵖ)

∀ (a : M), (MonoidHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a


theorem fiberProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hαβ : s.IsPWO) (a : α) : {y | toLex (a, y) ∈ s}.IsPWO

{α : Type u_2}
{β : Type u_3}
[PartialOrder α]
[Preorder β]
{s : Set (Lex (α × β))}
(hαβ : s.IsPWO)
(a : α)


@[simp]
theorem deriv_pow'' (hc : DifferentiableAt 𝕜 c x) :
    deriv (fun x => c x ^ n) x = (n : 𝕜) * c x ^ (n - 1) * deriv c x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{x : 𝕜}
{c : 𝕜 → 𝕜}
(n : ℕ)
(hc : DifferentiableAt 𝕜 c x)

deriv (fun x => c x ^ n) x = ↑n * c x ^ (n - 1) * deriv c x


@[simp]
theorem symm_self_id (α : X ≅ Y) : α.symm ≪≫ α = Iso.refl Y

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{X Y : C}
(α : X ≅ Y)


@[to_additive (attr := simp)]
theorem toLex_inv [Inv α] (a : α) : toLex a⁻¹ = (toLex a)⁻¹


lemma chainBotCoeff_zero_right [Nontrivial L] : chainBotCoeff α (0 : Weight K H L) = 1

{K : Type u_1}
{L : Type u_2}
[Field K]
[CharZero K]
[LieRing L]
[LieAlgebra K L]
[LieAlgebra.IsKilling K L]
[FiniteDimensional K L]
{H : LieSubalgebra K L}
[H.IsCartanSubalgebra]
[LieModule.IsTriangularizable K (↥H) L]
(α : LieModule.Weight K (↥H) L)
(hα : α.IsNonZero)
[Nontrivial L]


theorem ContinuousLinearMap.extendTo𝕜_apply (fr : RestrictScalars ℝ 𝕜 F →L[ℝ] ℝ) (x : F) :
    fr.extendTo𝕜 x = (fr x : 𝕜) - (I : 𝕜) * (fr ((I : 𝕜) • x) : 𝕜)

{𝕜 : Type u_1}
[RCLike 𝕜]
{F : Type u_2}
[SeminormedAddCommGroup F]
[NormedSpace 𝕜 F]
(fr : RestrictScalars ℝ 𝕜 F →L[ℝ] ℝ)
(x : F)

fr.extendTo𝕜 x = ↑(fr x) - RCLike.I * ↑(fr (RCLike.I • x))


@[simp]
lemma app_unitForward {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : Cᵒᵖ)
    (p : YonedaCollection (restrictedYonedaObj η) X.unop) :
    η.app X (unitForward η X.unop p) = p.yonedaEquivFst

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

(p :
  CategoryTheory.OverPresheafAux.YonedaCollection (CategoryTheory.OverPresheafAux.restrictedYonedaObj η)
    (Opposite.unop X))

η.app X (CategoryTheory.OverPresheafAux.unitForward η (Opposite.unop X) p) = p.yonedaEquivFst


@[simp]
theorem liftOfRightInverseAux_comp_apply (hf : Function.RightInverse f_inv f) (g : A →+* C)
    (hg : RingHom.ker f ≤ RingHom.ker g) (a : A) :
    (f.liftOfRightInverseAux f_inv hf g hg) (f a) = g a

{A : Type u_1}
{B : Type u_2}
{C : Type u_3}
[Ring A]
[Ring B]
[Ring C]
(f : A →+* B)
(f_inv : B → A)
(hf : Function.RightInverse f_inv ⇑f)
(g : A →+* C)
(hg : RingHom.ker f ≤ RingHom.ker g)
(a : A)


theorem extChartAt_source_mem_nhds (x : M) : (extChartAt I x).source ∈ 𝓝 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]
(x : M)


@[simp]
theorem cast_pow' (a : ZMod n) (k : ℕ) : (cast (a ^ k : ZMod n) : R) = (cast a : R) ^ k

{n : ℕ}
{R : Type u_1}
[Ring R]
[CharP R n]
(a : ZMod n)
(k : ℕ)


theorem natDegree_lt_iff_degree_lt (hp : p ≠ 0) : p.natDegree < n ↔ p.degree < ↑n

{R : Type u}
{n : ℕ}
[Semiring R]
{p : R[X]}
(hp : p ≠ 0)


/-- Submonoids of monoid `M` are isomorphic to additive submonoids of `Additive M`. -/
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M)

{M : Type u_1}
[MulOneClass M]
(S : Submonoid M)

↑(Submonoid.toAddSubmonoid S) = ⇑Additive.toMul ⁻¹' ↑S


/-- This is the infinitary Erdős–Szekeres theorem, and an important lemma in the usual proof of
    Bolzano-Weierstrass for `ℝ`. -/
theorem exists_increasing_or_nonincreasing_subseq (r : α → α → Prop) [IsTrans α r] (f : ℕ → α) :
    ∃ g : ℕ ↪o ℕ,
      (∀ m n : ℕ, m < n → r (f (g m)) (f (g n))) ∨ ∀ m n : ℕ, m < n → ¬r (f (g m)) (f (g n))

{α : Type u_1}
(r : α → α → Prop)
[IsTrans α r]
(f : ℕ → α)

∃ g, (∀ (m n : ℕ), m < n → r (f (g m)) (f (g n))) ∨ ∀ (m n : ℕ), m < n → ¬r (f (g m)) (f (g n))


lemma preStoneCechCompat {F G : Ultrafilter α} {x : α} (hF : ↑F ≤ 𝓝 x) (hG : ↑G ≤ 𝓝 x) :
    Ultrafilter.extend g F = Ultrafilter.extend g G

{α : Type u}
[TopologicalSpace α]
{β : Type v}
[TopologicalSpace β]
[T2Space β]
[CompactSpace β]
{g : α → β}
(hg : Continuous g)
{F G : Ultrafilter α}
{x : α}
(hF : ↑F ≤ 𝓝 x)
(hG : ↑G ≤ 𝓝 x)


@[simp]
theorem sumAddHom_singleAddHom [∀ i, AddCommMonoid (β i)] :
    sumAddHom (singleAddHom β) = AddMonoidHom.id _

{ι : Type u}
{β : ι → Type v}
[DecidableEq ι]
[(i : ι) → AddCommMonoid (β i)]

DFinsupp.sumAddHom (DFinsupp.singleAddHom β) = AddMonoidHom.id (Π₀ (i : ι), β i)


theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
    [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y

{α : Type u_3}
[Preorder α]
[IsTotal α fun x x_1 => x ≤ x_1]
[DecidableRel fun x x_1 => x ≤ x_1]
[DecidableRel fun x x_1 => x < x_1]
(x y : α)


theorem Fin.eq_of_compare {n n' : Fin m} (h : compare n n' = .eq) : n = n'

{m : Nat}
{n n' : Fin m}
(h : compare n n' = Ordering.eq)


@[simp]
theorem evalFrom_append_singleton (s : σ) (x : List α) (a : α) :
    M.evalFrom s (x ++ [a]) = M.step (M.evalFrom s x) a

{α : Type u}
{σ : Type v}
(M : DFA α σ)
(s : σ)
(x : List α)
(a : α)


theorem smul_def (a : A) (b : B) (m : M) : a ⊗ₜ[R] b • m = a • b • m

{R : Type u_1}
{A : Type u_2}
{B : Type u_3}
{M : Type u_4}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
[Semiring A]
[Semiring B]
[Module A M]
[Module B M]
[Algebra R A]
[Algebra R B]
[IsScalarTower R A M]
[IsScalarTower R B M]
[SMulCommClass A B M]
(a : A)
(b : B)
(m : M)


@[simp]
theorem map_id : s.map (RingHom.id R) = s

{R : Type u}
[NonAssocSemiring R]
(s : Subsemiring R)


lemma one_sub_le_exp_neg (x : ℝ) : 1 - x ≤ exp (-x)


theorem id : MeasurableEmbedding (id : α → α)


@[simp]
lemma UniformOnFun.toFun_smul {M : Type*} [SMul M β] (c : M) (f : α →ᵤ[𝔖] β) :
    toFun 𝔖 (c • f) = c • toFun 𝔖 f

{α : Type u_1}
{β : Type u_2}
{𝔖 : Set (Set α)}
{M : Type u_5}
[SMul M β]
(c : M)
(f : α →ᵤ[𝔖] β)

(UniformOnFun.toFun 𝔖) (c • f) = c • (UniformOnFun.toFun 𝔖) f


@[simp]
theorem get_thinkN (n) : get (thinkN s n) = get s

{α : Type u}
(s : Computation α)
[h : s.Terminates]
(n : ℕ)


theorem toEven_comp_ofEven : (toEven Q).comp (ofEven Q) = AlgHom.id R _

{R : Type u_1}
{M : Type u_2}
[CommRing R]
[AddCommGroup M]
[Module R M]
(Q : QuadraticForm R M)

(CliffordAlgebra.toEven Q).comp (CliffordAlgebra.ofEven Q) =
  AlgHom.id R ↥(CliffordAlgebra.even (CliffordAlgebra.EquivEven.Q' Q))


theorem mem_coLindelof' : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t

{X : Type u}
[TopologicalSpace X]
{s : Set X}

s ∈ Filter.coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t


protected theorem heq_ext_iff {k l : ℕ} (h : k = l) {i : Fin k} {j : Fin l} :
    HEq i j ↔ (i : ℕ) = (j : ℕ)


theorem comp_mul_right (hf : IntervalIntegrable f volume a b) (c : ℝ) :
    IntervalIntegrable (fun x => f (x * c)) volume (a / c) (b / c)

(hf : IntervalIntegrable f MeasureTheory.volume a b)

IntervalIntegrable (fun x => f (x * c)) MeasureTheory.volume (a / c) (b / c)


lemma Multiset.range_zero' {n : ℕ} (pn : NormNum.IsNat n 0) :
    Multiset.range n = 0

{n : ℕ}
(pn : Mathlib.Meta.NormNum.IsNat n 0)


theorem isClosed_closedBall (x' : Dual 𝕜 E) (r : ℝ) : IsClosed (toNormedDual ⁻¹' closedBall x' r)

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[SeminormedAddCommGroup E]
[NormedSpace 𝕜 E]
(x' : NormedSpace.Dual 𝕜 E)
(r : ℝ)

IsClosed (⇑WeakDual.toNormedDual ⁻¹' Metric.closedBall x' r)


@[simp]
theorem comap_id : comap (@ContinuousMap.id X _) = @id (LocallyConstant X Z)

{X : Type u_1}
{Z : Type u_3}
[TopologicalSpace X]

LocallyConstant.comap (ContinuousMap.id X) = id


@[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem smul_finset_nonempty : (a • s).Nonempty ↔ s.Nonempty

{α : Type u_2}
{β : Type u_3}
[DecidableEq β]
[VAdd α β]
{s : Finset β}
{a : α}


/-- Show that the functor given by `rightAdjointOfEquiv` is indeed right adjoint to `F`. Dual
to `adjunctionOfEquivRight`. -/
@[simps!]
def adjunctionOfEquivRight (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g) :
    F ⊣ (rightAdjointOfEquiv e he)

(e : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G_obj Y))

(he :
  ∀ (X' X : C) (Y : D) (f : X' ⟶ X) (g : F.obj X ⟶ Y),
    (e X' Y) (CategoryTheory.CategoryStruct.comp (F.map f) g) = CategoryTheory.CategoryStruct.comp f ((e X Y) g))

(CategoryTheory.Adjunction.adjunctionOfEquivRight e he).counit.app Y =
  (e (G_obj Y) Y).symm (CategoryTheory.CategoryStruct.id (G_obj Y))


/-- In a finite-dimensional space, linear maps are inverse to each other on one side if and only if
they are inverse to each other on the other side. -/
theorem comp_eq_id_comm [FiniteDimensional K V] {f g : V →ₗ[K] V} : f.comp g = id ↔ g.comp f = id

{K : Type u}
{V : Type v}
[DivisionRing K]
[AddCommGroup V]
[Module K V]
[FiniteDimensional K V]
{f g : V →ₗ[K] V}

f ∘ₗ g = LinearMap.id ↔ g ∘ₗ f = LinearMap.id


@[to_additive (attr := simp, norm_cast)]
theorem coe_eq_one {x : S'} : (↑x : M₁) = 1 ↔ x = 1

{A : Type u_4}
{M₁ : Type u_5}
[SetLike A M₁]
[One M₁]
[hA : OneMemClass A M₁]
{S' : A}
{x : ↥S'}


theorem coeIdeal_le_coeIdeal' [IsLocalization S P] (h : S ≤ nonZeroDivisors R) {I J : Ideal R} :
    (I : FractionalIdeal S P) ≤ J ↔ I ≤ J

{R : Type u_1}
[CommRing R]
(S : Submonoid R)
{P : Type u_2}
[CommRing P]
[Algebra R P]
[IsLocalization S P]
(h : S ≤ R⁰)
{I J : Ideal R}

↑I ≤ ↑J ↔ I ≤ J


/-- A compositum of splitting fields is a splitting field -/
theorem isSplittingField_iSup {p : ι → K[X]}
    {s : Finset ι} (h0 : ∏ i ∈ s, p i ≠ 0) (h : ∀ i ∈ s, (p i).IsSplittingField K (t i)) :
    (∏ i ∈ s, p i).IsSplittingField K (⨆ i ∈ s, t i : IntermediateField K L)

(h : ∀ i ∈ s, Polynomial.IsSplittingField K (↥(t i)) (p i))

Polynomial.IsSplittingField K (↥(⨆ i ∈ s, t i)) (∏ i ∈ s, p i)


@[simp]
theorem end_mem_tail_support_of_ne {u v : V} (h : u ≠ v) (p : G.Walk u v) : v ∈ p.support.tail

{V : Type u}
{G : SimpleGraph V}
{u v : V}
(h : u ≠ v)
(p : G.Walk u v)


lemma succ_ne_succ : succ m ≠ succ n ↔ m ≠ n


theorem Inducing.of_codRestrict {f : X → Y} {t : Set Y} (ht : ∀ x, f x ∈ t)
    (h : Inducing (t.codRestrict f ht)) : Inducing f

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[TopologicalSpace Y]
{f : X → Y}
{t : Set Y}
(ht : ∀ (x : X), f x ∈ t)
(h : Inducing (Set.codRestrict f t ht))


lemma SupClosed.image [FunLike F α β] [SupHomClass F α β] (hs : SupClosed s) (f : F) :
    SupClosed (f '' s)

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[SemilatticeSup α]
[SemilatticeSup β]
{s : Set α}
[FunLike F α β]
[SupHomClass F α β]
(hs : SupClosed s)
(f : F)


theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c


theorem whiskerLeft_comp_bimod {X Y Z : Mon_ C} (M : Bimod X Y) {N P Q : Bimod Y Z} (f : N ⟶ P)
    (g : P ⟶ Q) : whiskerLeft M (f ≫ g) = whiskerLeft M f ≫ whiskerLeft M g

[(X : C) →
    CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)]

[(X : C) →
    CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
      (CategoryTheory.MonoidalCategory.tensorRight X)]

M.whiskerLeft (f ≫ g) = M.whiskerLeft f ≫ M.whiskerLeft g


theorem castSucc_pred_lt {a : Fin (n + 1)} (ha : a ≠ 0) :
    castSucc (a.pred ha) < a


/-- The `p`-primary component is the submonoid of elements with order prime-power of `p`. -/
@[to_additive (attr := simps)
      "The `p`-primary component is the submonoid of elements with additive
      order prime-power of `p`."]
def primaryComponent : Submonoid G

(G : Type u_1)
[CommMonoid G]
(p : ℕ)
[hp : Fact (Nat.Prime p)]

↑(CommMonoid.primaryComponent G p) = {g | ∃ n, orderOf g = p ^ n}


theorem measure_diff_biUnion : μ (s \ ⋃ p ∈ h.index, h.covering p) = 0

{α : Type u_1}
[MetricSpace α]
{m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{v : VitaliFamily μ}
{f : α → Set (Set α)}
{s : Set α}
(h : v.FineSubfamilyOn f s)


theorem mk_singleton {α : Type u} (x : α) : #({x} : Set α) = 1


lemma shiftFunctorComm_symm (i j : A) :
    (shiftFunctorComm C i j).symm = shiftFunctorComm C j i

(C : Type u)
{A : Type u_1}
[CategoryTheory.Category.{v, u} C]
[AddCommMonoid A]
[CategoryTheory.HasShift C A]
(i j : A)

(CategoryTheory.shiftFunctorComm C i j).symm = CategoryTheory.shiftFunctorComm C j i


@[to_additive]
theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂

[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]

a₁ + b₁ ≤ a₂ + b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂


theorem coe_algHomOfDvd {p q : K[X]} (hpq : q ∣ p) :
    (algHomOfDvd hpq).toFun = liftHom p (root q) (by simp only [aeval_eq, mk_eq_zero, hpq])

{K : Type u_1}
[Field K]
{p q : K[X]}
(hpq : q ∣ p)

(↑↑(AdjoinRoot.algHomOfDvd hpq).toRingHom).toFun = ⇑(AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯)


theorem pderivCLM_eq_lineDeriv (m : E) (f : 𝓢(E, F)) (x : E) :
    pderivCLM 𝕜 m f x = lineDeriv ℝ f x m

(𝕜 : Type u_1)
{E : Type u_4}
{F : Type u_5}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[NormedAddCommGroup F]
[NormedSpace ℝ F]
[RCLike 𝕜]
[NormedSpace 𝕜 F]
[SMulCommClass ℝ 𝕜 F]
(m : E)
(f : SchwartzMap E F)
(x : E)

((SchwartzMap.pderivCLM 𝕜 m) f) x = lineDeriv ℝ (⇑f) x m


theorem tendsto_insertNth' {a : α} :
    ∀ {n : ℕ} {l : List α},
      Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))

{α : Type u_1}
[TopologicalSpace α]
{a : α}
{n : ℕ}
{l : List α}

Filter.Tendsto (fun p => List.insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (List.insertNth n a l))


@[to_additive]
theorem nonempty_iInter_clPrehaar (K₀ : PositiveCompacts G) :
    (haarProduct (K₀ : Set G) ∩ ⋂ V : OpenNhdsOf (1 : G), clPrehaar K₀ V).Nonempty

(K₀ : TopologicalSpace.PositiveCompacts G)

(MeasureTheory.Measure.haar.addHaarProduct ↑K₀ ∩ ⋂ V, MeasureTheory.Measure.haar.clAddPrehaar (↑K₀) V).Nonempty


/-- The equivalence between iterated Hahn series and Hahn series on the lex product. -/
@[simps]
def iterateEquiv {Γ' : Type*} [PartialOrder Γ'] :
    HahnSeries Γ (HahnSeries Γ' R) ≃ HahnSeries (Γ ×ₗ Γ') R

{Γ : Type u_1}
{R : Type u_2}
[PartialOrder Γ]
[Zero R]
{Γ' : Type u_3}
[PartialOrder Γ']
(x : HahnSeries Γ (HahnSeries Γ' R))


/-- If `η_A` is an isomorphism, then `A` is in the essential image of `i`. -/
theorem mem_essImage_of_unit_isIso (A : C)
    [IsIso (h.unit.app A)] : A ∈ R.essImage

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{L : C ⥤ D}
{R : D ⥤ C}
(h : L ⊣ R)
(A : C)
[CategoryTheory.IsIso (h.unit.app A)]


theorem conjAut_pow (f : Aut X) (n : ℕ) : α.conjAut (f ^ n) = α.conjAut f ^ n

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{X Y : C}
(α : X ≅ Y)
(f : CategoryTheory.Aut X)
(n : ℕ)


@[simp]
lemma KaehlerDifferential.mvPolynomialBasis_apply (σ) (i) :
    mvPolynomialBasis R σ i = D R (MvPolynomial σ R) (.X i)

(R : Type u)
[CommRing R]
(σ : Type u_1)
(i : σ)

(KaehlerDifferential.mvPolynomialBasis R σ) i = (KaehlerDifferential.D R (MvPolynomial σ R)) (MvPolynomial.X i)


@[simp]
theorem toPartialHomeomorph_coe (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    (hf.toPartialHomeomorph f : E → F) = f

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[CompleteSpace E]
{f : E → F}
{f' : E ≃L[𝕜] F}
{a : E}
(hf : HasStrictFDerivAt f (↑f') a)

↑(HasStrictFDerivAt.toPartialHomeomorph f hf) = f


@[simp]
theorem adjoin_univ : adjoin R (Set.univ : Set A) = ⊤

(R : Type u)
(A : Type v)
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]


/-- The norm of the identity is at most `1`. It is in fact `1`, except when the space is trivial
where it is `0`. It means that one can not do better than an inequality in general. -/
theorem norm_id_le : ‖id 𝕜 E‖ ≤ 1

{𝕜 : Type u_1}
{E : Type u_4}
[SeminormedAddCommGroup E]
[NontriviallyNormedField 𝕜]
[NormedSpace 𝕜 E]


@[simp]
lemma pushforward_map_app_apply {M N : PresheafOfModules.{v} R} (α : M ⟶ N) (X : Cᵒᵖ)
    (m : (ModuleCat.restrictScalars (φ.app X)).obj (M.obj (Opposite.op (F.obj X.unop)))) :
    ((pushforward φ).map α).app X m = α.app (Opposite.op (F.obj X.unop)) m

(m : ↑((ModuleCat.restrictScalars (φ.app X)).obj (M.obj (Opposite.op (F.obj (Opposite.unop X))))))

(PresheafOfModules.Hom.app ((PresheafOfModules.pushforward φ).map α) X) m =
  (PresheafOfModules.Hom.app α (Opposite.op (F.obj (Opposite.unop X)))) m


@[to_additive]
theorem eq_of_eqOn_top {f g : G →* M} (h : Set.EqOn f g (⊤ : Subgroup G)) : f = g

{G : Type u_1}
[Group G]
{M : Type u_7}
[Monoid M]
{f g : G →* M}
(h : Set.EqOn ⇑f ⇑g ↑⊤)


theorem Products.max_eq_eval [Inhabited I] (l : Products I) (hl : l.val ≠ [])
    (hlh : l.val.head! = term I ho) :
    Linear_CC' C hsC ho (l.eval C) = l.Tail.eval (C' C ho)

(hsC : Profinite.NobelingProof.contained C (Order.succ o))

(ho : o < Ordinal.type fun x x_1 => x < x_1)

(l : Profinite.NobelingProof.Products I)

(hlh : (↑l).head! = Profinite.NobelingProof.term I ho)

(Profinite.NobelingProof.Linear_CC' C hsC ho) (Profinite.NobelingProof.Products.eval C l) =
  Profinite.NobelingProof.Products.eval (Profinite.NobelingProof.C' C ho) l.Tail


theorem toNNReal_apply_of_tsum_ne_top {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' i, f i ≠ ∞) (x : α) :
    (((ENNReal.toNNReal ∘ f) x : ℝ≥0) : ℝ≥0∞) = f x

{α : Type u_4}
{f : α → ℝ≥0∞}
(hf : ∑' (i : α), f i ≠ ⊤)
(x : α)


theorem uniformContinuous_iInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : ι → UniformSpace β} :
    UniformContinuous[u₁, iInf u₂] f ↔ ∀ i, UniformContinuous[u₁, u₂ i] f

{α : Type ua}
{β : Type ub}
{ι : Sort u_1}
{f : α → β}
{u₁ : UniformSpace α}
{u₂ : ι → UniformSpace β}

UniformContinuous f ↔ ∀ (i : ι), UniformContinuous f


@[reassoc (attr := simp)]
theorem ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i

[H : (i j k : D.J) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]

CategoryTheory.CategoryStruct.comp (F.map (D.ι i)) (D.gluedIso F).hom = (D.mapGlueData F).ι i


@[simp]
theorem symm_refl (α : Type*) [MeasurableSpace α] : (refl α).symm = refl α

(MeasurableEquiv.refl α).symm = MeasurableEquiv.refl α


theorem tendsto_pow_atTop_atTop_of_one_lt [LinearOrderedRing α] [Archimedean α] {r : α}
    (h : 1 < r) : Tendsto (fun n : ℕ ↦ r ^ n) atTop atTop

{α : Type u_1}
[LinearOrderedRing α]
[Archimedean α]
{r : α}
(h : 1 < r)

Filter.Tendsto (fun n => r ^ n) Filter.atTop Filter.atTop


/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C)

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

∀ {X Y : C} (f : X ⟶ Y),
  ((CategoryTheory.tensoringRightMonoidal C).obj k).map f = CategoryTheory.MonoidalCategory.whiskerRight f k


/-- We say that a collection of functions form a smooth partition of unity on a set `s` if

* all functions are infinitely smooth and nonnegative;
* the family `fun i ↦ support (f i)` is locally finite;
* for all `x ∈ s` the sum `∑ᶠ i, f i x` equals one;
* for all `x`, the sum `∑ᶠ i, f i x` is less than or equal to one. -/
structure SmoothPartitionOfUnity (s : Set M := univ) where
  /-- The family of functions forming the partition of unity. -/
  toFun : ι → C^∞⟮I, M; 𝓘(ℝ), ℝ⟯
  /-- Around each point, there are only finitely many nonzero functions in the family. -/
  locallyFinite' : LocallyFinite fun i => support (toFun i)
  /-- All the functions in the partition of unity are nonnegative. -/
  nonneg' : ∀ i x, 0 ≤ toFun i x
  /-- The functions in the partition of unity add up to `1` at any point of `s`. -/
  sum_eq_one' : ∀ x ∈ s, ∑ᶠ i, toFun i x = 1
  /-- The functions in the partition of unity add up to at most `1` everywhere. -/
  sum_le_one' : ∀ x, ∑ᶠ i, toFun i x ≤ 1

{ι : Type uι}
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{H : Type uH}
[TopologicalSpace H]
{I : ModelWithCorners ℝ E H}
{M : Type uM}
[TopologicalSpace M]
[ChartedSpace H M]
{s : optParam (Set M) Set.univ}
(self : SmoothPartitionOfUnity ι I M s)
(i : ι)
(x : M)


theorem inv_mem_iff {c d : C} (f : c ⟶ d) :
    Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d

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

CategoryTheory.Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d


/-- If two triangles have two points the same, and twice the angle at the third point the same,
they have the same circumsphere. -/
theorem circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq {t₁ t₂ : Triangle ℝ P}
    {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃)
    (h₁ : t₁.points i₁ = t₂.points i₁) (h₃ : t₁.points i₃ = t₂.points i₃)
    (h₂ : (2 : ℤ) • ∡ (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) =
      (2 : ℤ) • ∡ (t₂.points i₁) (t₂.points i₂) (t₂.points i₃)) :
    t₁.circumsphere = t₂.circumsphere

[hd2 : Fact (FiniteDimensional.finrank ℝ V = 2)]

(h₂ : 2 • ∡ (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) = 2 • ∡ (t₂.points i₁) (t₂.points i₂) (t₂.points i₃))

Affine.Simplex.circumsphere t₁ = Affine.Simplex.circumsphere t₂


@[simps]
instance Endofunctor.coalgebraPreadditive : Preadditive (Endofunctor.Coalgebra F)

(A₁ A₂ : CategoryTheory.Endofunctor.Coalgebra F)


@[simp] theorem eq_iff_eq_cancel_left {b c : α} : (∀ {a}, a = b ↔ a = c) ↔ b = c


@[simp]
theorem toLp_zero (h : Memℒp (0 : α → E) p μ) : h.toLp 0 = 0

{α : Type u_1}
{E : Type u_2}
{m0 : MeasurableSpace α}
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup E]
(h : MeasureTheory.Memℒp 0 p μ)


theorem frequently_even : ∃ᶠ m : ℕ in atTop, Even m


/-- Auxiliary definition for `CategoryTheory.Mat.equivalenceSingleObj`. -/
@[simps]
def equivalenceSingleObjInverse : Mat_ (SingleObj Rᵐᵒᵖ) ⥤ Mat R

∀ {X Y : CategoryTheory.Mat_ (CategoryTheory.SingleObj Rᵐᵒᵖ)} (f : X ⟶ Y) (i : ↑((fun X => FintypeCat.of X.ι) X))
  (j : ↑((fun X => FintypeCat.of X.ι) Y)),
  (CategoryTheory.Mat.equivalenceSingleObjInverse R).map f i j = MulOpposite.unop (f i j)


@[simp]
theorem ofFinsupp_smul {S : Type*} [SMulZeroClass S R] (a : S) (b) :
    (⟨a • b⟩ : R[X]) = (a • ⟨b⟩ : R[X])

{R : Type u}
[Semiring R]
{S : Type u_1}
[SMulZeroClass S R]
(a : S)
(b : R[ℕ])

{ toFinsupp := a • b } = a • { toFinsupp := b }


@[to_additive nsmul_le_nsmul_left_of_nonpos]
theorem pow_le_pow_right_of_le_one' {a : M} {n m : ℕ} (ha : a ≤ 1) (h : n ≤ m) : a ^ m ≤ a ^ n

[CovariantClass M M (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]


theorem compl_F_eq_I : (IF.F : Set P)ᶜ = IF.I

{P : Type u_1}
[Preorder P]
(IF : Order.Ideal.PrimePair P)


/-- The obvious equivalence `ShortComplex (J ⥤ C) ≌ J ⥤ ShortComplex C`. -/
@[simps]
def functorEquivalence : ShortComplex (J ⥤ C) ≌ J ⥤ ShortComplex C

(CategoryTheory.ShortComplex.functorEquivalence J C).inverse =
  CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C


theorem aecover_Ioo_of_Ioo : AECover (μ.restrict <| Ioo A B) l fun i => Ioo (a i) (b i)

{α : Type u_1}
{ι : Type u_2}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
{l : Filter ι}
[LinearOrder α]
[TopologicalSpace α]
[OrderClosedTopology α]
[OpensMeasurableSpace α]
{a b : ι → α}
{A B : α}
(ha : Filter.Tendsto a l (𝓝 A))
(hb : Filter.Tendsto b l (𝓝 B))

MeasureTheory.AECover (μ.restrict (Set.Ioo A B)) l fun i => Set.Ioo (a i) (b i)


theorem terminates_parallel.aux :
    ∀ {l : List (Computation α)} {S c},
      c ∈ l → Terminates c → Terminates (corec parallel.aux1 (l, S))

{α : Type u}
{l : List (Computation α)}
{S : Stream'.WSeq (Computation α)}
{c : Computation α}

c ∈ l → c.Terminates → (Computation.corec Computation.parallel.aux1 (l, S)).Terminates


lemma op_distinguished (T : Triangle C) (hT : T ∈ distTriang C) :
    ((triangleOpEquivalence C).functor.obj (Opposite.op T)) ∈ distTriang Cᵒᵖ

[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]

(T : CategoryTheory.Pretriangulated.Triangle C)

(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)

(CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor.obj (Opposite.op T) ∈
  CategoryTheory.Pretriangulated.distinguishedTriangles


theorem eq_of_getMsb_eq {x y : BitVec w}
    (pred : ∀(i : Fin w), x.getMsb i = y.getMsb i.val) : x = y

(pred : ∀ (i : Fin w), x.getMsb ↑i = y.getMsb ↑i)


theorem limNthHom_zero : limNthHom f_compat 0 = 0

(f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), (ZMod.castHom ⋯ (ZMod (p ^ k1))).comp (f k2) = f k1)


@[simp]
theorem map_mk (f : M →ₗ[R] N) (a : AdicCauchySequence I M) :
    map I f (AdicCompletion.mk I M a) =
      AdicCompletion.mk I N (AdicCauchySequence.map I f a)

(a : AdicCompletion.AdicCauchySequence I M)

(AdicCompletion.map I f) ((AdicCompletion.mk I M) a) =
  (AdicCompletion.mk I N) ((AdicCompletion.AdicCauchySequence.map I f) a)


@[simp]
theorem eval_zero : eval f a 0 = 0

{K : Type u}
[Field K]
{L : Type u}
[Field L]
(f : K →+* L)
(a : L)


/-- In an R₀ space, `Specializes` is equivalent to `Inseparable`. -/
theorem specializes_iff_inseparable : x ⤳ y ↔ Inseparable x y

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


@[to_additive]
theorem CauchySeq.mul {ι : Type*} [Preorder ι] {u v : ι → α} (hu : CauchySeq u)
    (hv : CauchySeq v) : CauchySeq (u * v)

{α : Type u_1}
[UniformSpace α]
[AddGroup α]
[UniformAddGroup α]
{ι : Type u_3}
[Preorder ι]
{u v : ι → α}
(hu : CauchySeq u)
(hv : CauchySeq v)


theorem _root_.Memℓp.infty_mul {f g : ∀ i, B i} (hf : Memℓp f ∞) (hg : Memℓp g ∞) :
    Memℓp (f * g) ∞

{I : Type u_3}
{B : I → Type u_4}
[(i : I) → NonUnitalNormedRing (B i)]
{f g : (i : I) → B i}
(hf : Memℓp f ⊤)
(hg : Memℓp g ⊤)


/-- `(n, m)` is in the reflexive-transitive closure of `~` if `i ~ succ i` and `succ i ~ i`
  for all `i` between `n` and `m`. -/
theorem reflTransGen_of_succ (r : α → α → Prop) {n m : α} (h1 : ∀ i ∈ Ico n m, r i (succ i))
    (h2 : ∀ i ∈ Ico m n, r (succ i) i) : ReflTransGen r n m

(h1 : ∀ i ∈ Set.Ico n m, r i (Order.succ i))

(h2 : ∀ i ∈ Set.Ico m n, r (Order.succ i) i)


theorem derivedLength_zero (I : LieIdeal R L) [hI : IsSolvable R I] :
    derivedLengthOfIdeal R L I = 0 ↔ I = ⊥

{R : Type u}
{L : Type v}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(I : LieIdeal R L)
[hI : LieAlgebra.IsSolvable R ↥↑I]

LieAlgebra.derivedLengthOfIdeal R L I = 0 ↔ I = ⊥


@[to_additive]
theorem quasiMeasurePreserving_inv_of_right_invariant [IsMulRightInvariant μ] :
    QuasiMeasurePreserving (Inv.inv : G → G) μ μ

{G : Type u_1}
[MeasurableSpace G]
[AddGroup G]
[MeasurableAdd₂ G]
(μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ]
[MeasurableNeg G]
[μ.IsAddRightInvariant]

MeasureTheory.Measure.QuasiMeasurePreserving Neg.neg μ μ


@[to_additive]
theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹

[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]


@[simp]
lemma image_subtype_val_Ioc_Iic {a b : α} (c : Ioc a b) : Subtype.val '' Iic c = Ioc a c

{α : Type u_1}
[Preorder α]
{a b : α}
(c : ↑(Set.Ioc a b))


@[simp] lemma unop_mul [Mul α] (a b : αᵃᵒᵖ) : unop (a * b) = unop a * unop b

AddOpposite.unop (a * b) = AddOpposite.unop a * AddOpposite.unop b


/-- If an affine subspace is nonempty and contained in another with the same direction, they are
equal. -/
theorem eq_of_direction_eq_of_nonempty_of_le {s₁ s₂ : AffineSubspace k P}
    (hd : s₁.direction = s₂.direction) (hn : (s₁ : Set P).Nonempty) (hle : s₁ ≤ s₂) : s₁ = s₂

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[S : AffineSpace V P]
{s₁ s₂ : AffineSubspace k P}
(hd : s₁.direction = s₂.direction)
(hn : (↑s₁).Nonempty)
(hle : s₁ ≤ s₂)


@[to_additive (attr := simp)]
lemma card_smul_set (a : α) (s : Set β) : Nat.card ↥(a • s) = Nat.card s

{α : Type u_2}
{β : Type u_3}
[Group α]
[MulAction α β]
(a : α)
(s : Set β)


theorem le_castPred_iff {j : Fin n} {i : Fin (n + 1)} (hi : i ≠ last n) :
    j ≤ castPred i hi ↔ castSucc j ≤ i

{n : ℕ}
{j : Fin n}
{i : Fin (n + 1)}
(hi : i ≠ Fin.last n)


@[to_additive (attr := simp)] theorem fst_apply_inl (x : M) : fst (inl x : M ∗ N) = x

{M : Type u_1}
{N : Type u_2}
[AddMonoid M]
[AddMonoid N]
(x : M)

AddMonoid.Coprod.fst (AddMonoid.Coprod.inl x) = x


theorem u_l_eq [PartialOrder α] [Preorder β] (gi : GaloisCoinsertion l u) (a : α) : u (l a) = a

{α : Type u}
{β : Type v}
{l : α → β}
{u : β → α}
[PartialOrder α]
[Preorder β]
(gi : GaloisCoinsertion l u)
(a : α)


@[simp]
theorem setIntegral_const {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {μ : Measure β} {a : α} {s : Set β} :
    ∫ x in s, f x ∂const α μ a = ∫ x in s, f x ∂μ

{α : Type u_1}
{β : Type u_2}
{mα : MeasurableSpace α}
{mβ : MeasurableSpace β}
{E : Type u_4}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{f : β → E}
{μ : MeasureTheory.Measure β}
{a : α}
{s : Set β}

∫ (x : β) in s, f x ∂(ProbabilityTheory.Kernel.const α μ) a = ∫ (x : β) in s, f x ∂μ


@[fun_prop]
protected theorem continuousWithinAt {s a} : ContinuousWithinAt (fun x => p.eval x) s a

{R : Type u_1}
[Semiring R]
[TopologicalSpace R]
[TopologicalSemiring R]
(p : Polynomial R)
{s : Set R}
{a : R}

ContinuousWithinAt (fun x => Polynomial.eval x p) s a


@[simp]
theorem single_dotProduct (x : α) (i : m) : Pi.single i x ⬝ᵥ v = x * v i

{m : Type u_2}
{α : Type v}
[Fintype m]
[DecidableEq m]
[NonUnitalNonAssocSemiring α]
(v : m → α)
(x : α)
(i : m)


/-- `IsTotal X r` means that the binary relation `r` on `X` is total, that is, that for any
`x y : X` we have `r x y` or `r y x`. -/
class IsTotal (α : Sort u) (r : α → α → Prop) : Prop where
  total : ∀ a b, r a b ∨ r b a

{α : Sort u}
{r : α → α → Prop}
[self : IsTotal α r]
(a b : α)


/-- `ExteriorAlgebra.liftAlternating` is an equivalence. -/
@[simps apply symm_apply]
def liftAlternatingEquiv : (∀ i, M [⋀^Fin i]→ₗ[R] N) ≃ₗ[R] ExteriorAlgebra R M →ₗ[R] N

{R : Type u_1}
{M : Type u_2}
{N : Type u_3}
[CommRing R]
[AddCommGroup M]
[AddCommGroup N]
[Module R M]
[Module R N]
(F : ExteriorAlgebra R M →ₗ[R] N)
(i : ℕ)

ExteriorAlgebra.liftAlternatingEquiv.symm F i = F.compAlternatingMap (ExteriorAlgebra.ιMulti R i)


@[simp]
theorem sym_singleton (a : α) (n : ℕ) : ({a} : Finset α).sym n = {Sym.replicate n a}

{α : Type u_1}
[DecidableEq α]
(a : α)
(n : ℕ)


@[elab_as_elim]
protected theorem induction_on [Nonempty ι] [IsDirected ι (· ≤ ·)] {C : DirectLimit G f → Prop}
    (z : DirectLimit G f) (ih : ∀ i x, C (of R ι G f i x)) : C z

(ih : ∀ (i : ι) (x : G i), C ((Module.DirectLimit.of R ι G f i) x))


@[to_additive sub_image_prod]
theorem image_div_prod : (fun x : α × α => x.fst / x.snd) '' s ×ˢ t = s / t


theorem bernstein_nonneg {n ν : ℕ} {x : I} : 0 ≤ bernstein n ν x


theorem symm_image_eq_source_inter_preimage {s : Set β} (h : s ⊆ e.target) :
    e.symm '' s = e.source ∩ e ⁻¹' s

{α : Type u_1}
{β : Type u_2}
(e : PartialEquiv α β)
{s : Set β}
(h : s ⊆ e.target)


@[simp]
lemma Submodule.toLocalizedQuotient'_mk (x : M) :
    M'.toLocalizedQuotient' S p f (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)

{R : Type u}
(S : Type u')
{M : Type v}
{N : Type v'}
[CommRing R]
[CommRing S]
[AddCommGroup M]
[AddCommGroup N]
[Module R M]
[Module R N]
[Algebra R S]
[Module S N]
[IsScalarTower R S N]
(p : Submonoid R)
[IsLocalization p S]
(f : M →ₗ[R] N)
[IsLocalizedModule p f]
(M' : Submodule R M)
(x : M)

(Submodule.toLocalizedQuotient' S p f M') (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)


theorem norm_le_iff {r : ℝ} (hr : 0 ≤ r) {A : Matrix m n α} : ‖A‖ ≤ r ↔ ∀ i j, ‖A i j‖ ≤ r

{m : Type u_3}
{n : Type u_4}
{α : Type u_5}
[Fintype m]
[Fintype n]
[SeminormedAddCommGroup α]
{r : ℝ}
(hr : 0 ≤ r)
{A : Matrix m n α}

‖A‖ ≤ r ↔ ∀ (i : m) (j : n), ‖A i j‖ ≤ r


theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S)

(h : ∀ (i : ι), Bornology.IsBounded (S i))


theorem symm_bijective :
    Function.Bijective (HomotopyRel.symm : HomotopyRel f₀ f₁ S → HomotopyRel f₁ f₀ S)

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[TopologicalSpace Y]
{f₀ f₁ : C(X, Y)}
{S : Set X}


@[simp]
theorem mk_X_1 : (mk X₀ X₁ X₂ d₀ d₁ s succ).X 1 = X₁

(succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' d₂ ≫ S.f = 0)

(ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 1 = X₁


/-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C

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

∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₄ = φ.τ₄


/-- To give an object in the under category, it suffices to give an arrow with domain `X`. -/
@[simps! right hom]
def mk {X Y : T} (f : X ⟶ Y) : Under X

{T : Type u₁}
[CategoryTheory.Category.{v₁, u₁} T]
{X Y : T}
(f : X ⟶ Y)


theorem IsCompact.image {f : X → Y} (hs : IsCompact s) (hf : Continuous f) : IsCompact (f '' s)

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[TopologicalSpace Y]
{s : Set X}
{f : X → Y}
(hs : IsCompact s)
(hf : Continuous f)


theorem diam_pos_iff' : 0 < diam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y

{γ : Type w}
[EMetricSpace γ]
{s : Set γ}

0 < EMetric.diam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y


theorem IsOpen.exists_subset_affineIndependent_span_eq_top {u : Set P} (hu : IsOpen u)
    (hne : u.Nonempty) : ∃ s ⊆ u, AffineIndependent ℝ ((↑) : s → P) ∧ affineSpan ℝ s = ⊤

{V : Type u_1}
{P : Type u_2}
[NormedAddCommGroup V]
[NormedSpace ℝ V]
[MetricSpace P]
[NormedAddTorsor V P]
{u : Set P}
(hu : IsOpen u)
(hne : u.Nonempty)

∃ s ⊆ u, AffineIndependent ℝ Subtype.val ∧ affineSpan ℝ s = ⊤


@[simp, norm_cast]
theorem coe_sdiff (s₁ s₂ : Finset α) : ↑(s₁ \ s₂) = (s₁ \ s₂ : Set α)

{α : Type u_1}
[DecidableEq α]
(s₁ s₂ : Finset α)


@[simp, reassoc]
lemma sHomWhiskerRight_comp {K K' K'' : C} (f : K ⟶ K') (f' : K' ⟶ K'') (L : C) :
    sHomWhiskerRight (f ≫ f') L = sHomWhiskerRight f' L ≫ sHomWhiskerRight f L

{C : Type u}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.SimplicialCategory C]
{K K' K'' : C}
(f : K ⟶ K')
(f' : K' ⟶ K'')
(L : C)

CategoryTheory.SimplicialCategory.sHomWhiskerRight (f ≫ f') L =
  CategoryTheory.SimplicialCategory.sHomWhiskerRight f' L ≫ CategoryTheory.SimplicialCategory.sHomWhiskerRight f L


@[reassoc (attr := simp)]
theorem leftAdjointUniq_trans {F F' F'' : C ⥤ D} {G : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G)
    (adj3 : F'' ⊣ G) :
    (leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom =
      (leftAdjointUniq adj1 adj3).hom

{C : Type u_1}
{D : Type u_2}
[CategoryTheory.Category.{u_3, u_1} C]
[CategoryTheory.Category.{u_4, u_2} D]
{F F' F'' : C ⥤ D}
{G : D ⥤ C}
(adj1 : F ⊣ G)
(adj2 : F' ⊣ G)
(adj3 : F'' ⊣ G)

(adj1.leftAdjointUniq adj2).hom ≫ (adj2.leftAdjointUniq adj3).hom = (adj1.leftAdjointUniq adj3).hom


protected theorem pow_mem {x : K} (hx : x ∈ s) (n : ℕ) : x ^ n ∈ s

{K : Type u}
[DivisionRing K]
(s : Subfield K)
{x : K}
(hx : x ∈ s)
(n : ℕ)


@[simp]
theorem asModuleEquiv_symm_map_smul (r : k) (x : V) :
    ρ.asModuleEquiv.symm (r • x) = algebraMap k (MonoidAlgebra k G) r • ρ.asModuleEquiv.symm x

{k : Type u_1}
{G : Type u_2}
{V : Type u_3}
[CommSemiring k]
[Monoid G]
[AddCommMonoid V]
[Module k V]
(ρ : Representation k G V)
(r : k)
(x : V)

ρ.asModuleEquiv.symm (r • x) = (algebraMap k (MonoidAlgebra k G)) r • ρ.asModuleEquiv.symm x


theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
    Disjoint (I.splitLower i x) (I.splitUpper i x)

{ι : Type u_1}
(I : BoxIntegral.Box ι)
(i : ι)
(x : ℝ)


@[simp] theorem cases_succ' {n} {motive : Fin (n + 1) → Sort _} {zero succ}
    {i : Nat} (h : i + 1 < n + 1) :
    @Fin.cases n motive zero succ ⟨i.succ, h⟩ = succ ⟨i, Nat.lt_of_succ_lt_succ h⟩

{n : Nat}
{motive : Fin (n + 1) → Sort u_1}
{zero : motive 0}
{succ : (i : Fin n) → motive i.succ}
{i : Nat}
(h : i + 1 < n + 1)

Fin.cases zero succ ⟨i.succ, h⟩ = succ ⟨i, ⋯⟩


theorem modEq_iff_toIcoMod_eq_left : a ≡ b [PMOD p] ↔ toIcoMod hp a b = a

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


lemma W_adj_unit_app (adj : G ⊣ sheafToPresheaf J A) (P : Cᵒᵖ ⥤ A) : J.W (adj.unit.app P)

(J : CategoryTheory.GrothendieckTopology C)

{G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)}

(adj : G ⊣ CategoryTheory.sheafToPresheaf J A)


@[simp]
protected theorem smul_def {A} [AddMonoid A] (f : AddAut A) (a : A) : f • a = f a

{A : Type u_4}
[AddMonoid A]
(f : AddAut A)
(a : A)


theorem lengthParity_comp_simple :
    cs.lengthParity ∘ cs.simple = fun _ ↦ Multiplicative.ofAdd 1

{B : Type u_1}
{W : Type u_2}
[Group W]
{M : CoxeterMatrix B}
(cs : CoxeterSystem M W)

⇑cs.lengthParity ∘ cs.simple = fun x => Multiplicative.ofAdd 1


lemma sq_pos_of_neg (ha : a < 0) : 0 < a ^ 2

{R : Type u_3}
[StrictOrderedRing R]
{a : R}
(ha : a < 0)


theorem cons_same {b : δ a} {f : ∀ a ∈ m, δ a} (h : a ∈ a ::ₘ m) :
    cons m a b f a h = b

{α : Type u_1}
[DecidableEq α]
{δ : α → Sort u_2}
{m : Multiset α}
{a : α}
{b : δ a}
{f : (a : α) → a ∈ m → δ a}
(h : a ∈ a ::ₘ m)


@[simp] theorem run_eq [Monad m] (x : StateCpsT σ m α) (s : σ) : x.run s = x.runK s (fun a s => pure (a, s))

{α σ : Type u}
{m : Type u → Type v}
[Monad m]
(x : StateCpsT σ m α)
(s : σ)

x.run s = x.runK s fun a s => pure { fst := a, snd := s }


/-- An antitone map sends a least element of a set to a greatest element of its image. -/
theorem map_isLeast (Hf : AntitoneOn f t) : IsLeast t a → IsGreatest (f '' t) (f a)

{α : Type u}
{β : Type v}
[Preorder α]
[Preorder β]
{f : α → β}
{t : Set α}
{a : α}
(Hf : AntitoneOn f t)


@[simp] theorem ofInvolutive_symm (f : α → α) (hf : Involutive f) (hf' : Measurable f) :
    (ofInvolutive f hf hf').symm = ofInvolutive f hf hf'

{α : Type u_1}
[MeasurableSpace α]
(f : α → α)
(hf : Function.Involutive f)
(hf' : Measurable f)

(MeasurableEquiv.ofInvolutive f hf hf').symm = MeasurableEquiv.ofInvolutive f hf hf'


/-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G

{G : Type v}
[AddGroup G]
[PseudoEMetricSpace G]
[IsometricVAdd G G]
[IsometricVAdd Gᵃᵒᵖ G]
(c : G)

(IsometryEquiv.subLeft c).toEquiv = Equiv.subLeft c


/-- The canonical bijection with the sigma type, showing that `WType` is a fixed point of
  the polynomial functor `X ↦ Σ a : α, β a → X`. -/
@[simps]
def equivSigma : WType β ≃ Σa : α, β a → WType β

∀ (a : WType β), (WType.equivSigma β) a = a.toSigma


lemma abs_add_mul_I (x y : ℝ) : abs (x + y * I) = (x ^ 2 + y ^ 2).sqrt

Complex.abs (↑x + ↑y * Complex.I) = √(x ^ 2 + y ^ 2)


/-- Inducts on a well-founded `>` relation. -/
theorem induction {C : α → Prop} : ∀ a, (∀ x, (∀ y, x < y → C y) → C x) → C a

{α : Type u}
[LT α]
[WellFoundedGT α]
{C : α → Prop}
(a : α)

(∀ (x : α), (∀ (y : α), x < y → C y) → C x) → C a


theorem mem_image₂_of_mem (ha : a ∈ s) (hb : b ∈ t) : f a b ∈ image₂ f s t

{α : Type u_1}
{β : Type u_3}
{γ : Type u_5}
[DecidableEq γ]
{f : α → β → γ}
{s : Finset α}
{t : Finset β}
{a : α}
{b : β}
(ha : a ∈ s)
(hb : b ∈ t)


/-- The forgetful functor from the category of monads to the category of endofunctors.
-/
@[simps!]
def monadToFunctor : Monad C ⥤ C ⥤ C

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

∀ {X Y : CategoryTheory.Monad C} (f : X ⟶ Y), (CategoryTheory.monadToFunctor C).map f = f.toNatTrans


theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb

(hs : (a : α) → ¬IsMax a → C (Order.succ a))

(hl : (a : α) → Order.IsSuccLimit a → C a)

Order.isSuccLimitRecOn b hs hl = hl b hb


/-- Restrict the codomain of an alternating map to a submodule. -/
@[simps]
def codRestrict (f : M [⋀^ι]→ₗ[R] N) (p : Submodule R N) (h : ∀ v, f v ∈ p) :
    M [⋀^ι]→ₗ[R] p

{R : Type u_1}
[Semiring R]
{M : Type u_2}
[AddCommMonoid M]
[Module R M]
{N : Type u_3}
[AddCommMonoid N]
[Module R N]
{ι : Type u_7}
(f : M [⋀^ι]→ₗ[R] N)
(p : Submodule R N)
(h : ∀ (v : ι → M), f v ∈ p)
(v : ι → M)


theorem setToSimpleFunc_eq_sum_filter {m : MeasurableSpace α} (T : Set α → F →L[ℝ] F')
    (f : α →ₛ F) :
    setToSimpleFunc T f = ∑ x ∈ f.range.filter fun x => x ≠ 0, (T (f ⁻¹' {x})) x

{α : Type u_1}
{F : Type u_3}
{F' : Type u_4}
[NormedAddCommGroup F]
[NormedSpace ℝ F]
[NormedAddCommGroup F']
[NormedSpace ℝ F']
{m : MeasurableSpace α}
(T : Set α → F →L[ℝ] F')
(f : MeasureTheory.SimpleFunc α F)

MeasureTheory.SimpleFunc.setToSimpleFunc T f = ∑ x ∈ Finset.filter (fun x => x ≠ 0) f.range, (T (↑f ⁻¹' {x})) x


/--
The coherent sheaf condition can be checked after precomposing with the equivalence.
-/
theorem precoherent_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.precoherent
    IsSheaf (coherentTopology C) F ↔ IsSheaf (coherentTopology D) (e.inverse.op ⋙ F)

{C : Type u_1}
[CategoryTheory.Category.{u_4, u_1} C]
{D : Type u_2}
[CategoryTheory.Category.{u_6, u_2} D]
(e : C ≌ D)
[CategoryTheory.Precoherent C]
(A : Type u_3)
[CategoryTheory.Category.{u_5, u_3} A]
(F : CategoryTheory.Functor Cᵒᵖ A)

CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology D) (e.inverse.op.comp F)


@[to_additive (attr := simp)]
lemma map_comp_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) (g : ι → G) :
    f ∘ g⁻¹ = (f ∘ g)⁻¹

{ι : Type u_1}
{G : Type u_7}
{H : Type u_8}
{F : Type u_9}
[FunLike F G H]
[Group G]
[DivisionMonoid H]
[MonoidHomClass F G H]
(f : F)
(g : ι → G)

⇑f ∘ g⁻¹ = (⇑f ∘ g)⁻¹


theorem le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x


theorem cauchy_map_iff {l : Filter β} {f : β → α} :
    Cauchy (l.map f) ↔ NeBot l ∧ Tendsto (fun p : β × β => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α)

{α : Type u}
{β : Type v}
[uniformSpace : UniformSpace α]
{l : Filter β}
{f : β → α}

Cauchy (Filter.map f l) ↔ l.NeBot ∧ Filter.Tendsto (fun p => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α)


@[simp]
theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a

{α : Type u_1}
[PartialOrder α]
[PredOrder α]
{a : α}


theorem neg_pi_div_two_ne_zero : ((-π / 2 : ℝ) : Angle) ≠ 0


@[simp]
theorem product_cons : s ×ˢ (b ::ₘ t) = (s.map fun a => (a, b)) + s ×ˢ t

{α : Type u_1}
{β : Type v}
(b : β)
(s : Multiset α)
(t : Multiset β)

s ×ˢ (b ::ₘ t) = Multiset.map (fun a => (a, b)) s + s ×ˢ t


@[to_additive]
theorem lt_mul_of_one_lt_of_lt [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c : α} (ha : 1 < a)
    (hbc : b < c) :
    b < a * c

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


@[simp]
theorem gcdA_zero_right {s : ℕ} (h : s ≠ 0) : gcdA s 0 = 1


theorem lowerSemicontinuous_sum {f : ι → α → γ} {a : Finset ι}
    (ha : ∀ i ∈ a, LowerSemicontinuous (f i)) : LowerSemicontinuous fun z => ∑ i ∈ a, f i z

{f : ι → α → γ}


/-- Given any distinguished triangle
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
the composition `g ≫ h = 0`.
See <https://stacks.math.columbia.edu/tag/0146>
-/
@[reassoc]
theorem comp_distTriang_mor_zero₂₃ (T : Triangle C) (H : T ∈ distTriang C) :
    T.mor₂ ≫ T.mor₃ = 0

[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]

(T : CategoryTheory.Pretriangulated.Triangle C)

(H : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)


theorem tendsto_mul_self_atTop : Tendsto (fun x : α => x * x) atTop atTop

Filter.Tendsto (fun x => x * x) Filter.atTop Filter.atTop


theorem sublist_insert (a : α) (l : List α) : l <+ l.insert a

{α : Type u_1}
[DecidableEq α]
(a : α)
(l : List α)


@[simp]
theorem comp_hom' {M N K : Bimon_ C} (f : M ⟶ N) (g : N ⟶ K) : (f ≫ g).hom = f.hom ≫ g.hom

(C : Type u₁)
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
[CategoryTheory.BraidedCategory C]
{M N K : Bimon_ C}
(f : M ⟶ N)
(g : N ⟶ K)


@[fun_prop]
theorem Differentiable.sub_const (hf : Differentiable 𝕜 f) (c : F) :
    Differentiable 𝕜 fun y => f y - c

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


/-- The set of points for which a sequence of measurable functions converges to a given value
is measurable. -/
@[measurability]
lemma measurableSet_tendsto {_ : MeasurableSpace β} [MeasurableSpace γ]
    [Countable δ] {l : Filter δ} [l.IsCountablyGenerated]
    (l' : Filter γ) [l'.IsCountablyGenerated] [hl' : l'.IsMeasurablyGenerated]
    {f : δ → β → γ} (hf : ∀ i, Measurable (f i)) :
    MeasurableSet { x | Tendsto (fun n ↦ f n x) l l' }

{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}

∀ {x : MeasurableSpace β} [inst : MeasurableSpace γ] [inst_1 : Countable δ] {l : Filter δ}
  [inst_2 : l.IsCountablyGenerated] (l' : Filter γ) [inst_3 : l'.IsCountablyGenerated] [hl' : l'.IsMeasurablyGenerated]
  {f : δ → β → γ}, (∀ (i : δ), Measurable (f i)) → MeasurableSet {x | Filter.Tendsto (fun n => f n x) l l'}


@[simp] lemma swapLeft_prodMkLeft (κ : Kernel α β) (γ : Type*) [MeasurableSpace γ] :
    swapLeft (prodMkLeft γ κ) = prodMkRight γ κ

{α : Type u_1}
{β : Type u_2}
{mα : MeasurableSpace α}
{mβ : MeasurableSpace β}
(κ : ProbabilityTheory.Kernel α β)
(γ : Type u_6)
[MeasurableSpace γ]

(ProbabilityTheory.Kernel.prodMkLeft γ κ).swapLeft = ProbabilityTheory.Kernel.prodMkRight γ κ


@[to_additive, simp]
lemma smul_mk_apply {M α : Type*} [Monoid M] [SMul M α] (m n : M) (h₁) (h₂) (a : α) :
    (⟨m, n, h₁, h₂⟩ : Mˣ) • a = m • a

{M : Type u_6}
{α : Type u_7}
[Monoid M]
[SMul M α]
(m n : M)
(h₁ : m * n = 1)
(h₂ : n * m = 1)
(a : α)

{ val := m, inv := n, val_inv := h₁, inv_val := h₂ } • a = m • a


/-- The disjoint union of antidiagonal tuples `Σ n, antidiagonalTuple k n` is equivalent to the
`k`-tuple `Fin k → ℕ`. This is such an equivalence, obtained by mapping `(n, x)` to `x`.

This is the tuple version of `Finset.sigmaAntidiagonalEquivProd`. -/
@[simps]
def sigmaAntidiagonalTupleEquivTuple (k : ℕ) : (Σ n, antidiagonalTuple k n) ≃ (Fin k → ℕ)

(x : (n : ℕ) × { x // x ∈ Finset.Nat.antidiagonalTuple k n })

∀ (a : Fin k), (Finset.Nat.sigmaAntidiagonalTupleEquivTuple k) x a = ↑x.snd a


@[ext]
theorem ext {p q : AffineSubspace k P} (h : ∀ x, x ∈ p ↔ x ∈ q) : p = q

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{p q : AffineSubspace k P}
(h : ∀ (x : P), x ∈ p ↔ x ∈ q)


theorem pairwise_of_reflexive_of_forall_ne {l : List α} {r : α → α → Prop} (hr : Reflexive r)
    (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) : l.Pairwise r

(h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b)


@[simp]
theorem inter_union_compl (s t : Set α) : s ∩ t ∪ s ∩ tᶜ = s


@[simp]
theorem mul_coe {k_1 k_2 : ℤ} {Γ : Subgroup SL(2, ℤ)} (f : ModularForm Γ k_1)
    (g : ModularForm Γ k_2) : (f.mul g : ℍ → ℂ) = f * g


@[simp]
theorem colimit.desc_cocone {F : J ⥤ C} [HasColimit F] :
    colimit.desc F (colimit.cocone F) = 𝟙 (colimit F)

{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u}
[CategoryTheory.Category.{v, u} C]
{F : J ⥤ C}
[CategoryTheory.Limits.HasColimit F]

CategoryTheory.Limits.colimit.desc F (CategoryTheory.Limits.colimit.cocone F) = 𝟙 (CategoryTheory.Limits.colimit F)


lemma iCondIndep_iff_iCondIndepSets (m : ι → MeasurableSpace Ω)
    (μ : @Measure Ω mΩ) [IsFiniteMeasure μ] :
    iCondIndep m' hm' m μ ↔ iCondIndepSets m' hm' (fun x ↦ {s | MeasurableSet[m x] s}) μ

{Ω : Type u_1}
{ι : Type u_2}
(m' : MeasurableSpace Ω)
{mΩ : MeasurableSpace Ω}
[StandardBorelSpace Ω]
[Nonempty Ω]
(hm' : m' ≤ mΩ)
(m : ι → MeasurableSpace Ω)
(μ : MeasureTheory.Measure Ω)
[MeasureTheory.IsFiniteMeasure μ]

ProbabilityTheory.iCondIndep m' hm' m μ ↔ ProbabilityTheory.iCondIndepSets m' hm' (fun x => {s | MeasurableSet s}) μ


@[to_additive (attr := simp)]
theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1


@[simp]
lemma nonempty_iff : Nonempty U.toScheme ↔ (U : Set X).Nonempty

{X : AlgebraicGeometry.Scheme}
(U : X.Opens)

Nonempty ↑↑(↑U).toPresheafedSpace ↔ (↑U).Nonempty


theorem leastGE_mono {n m : ℕ} (hnm : n ≤ m) (r : ℝ) (ω : Ω) : leastGE f r n ω ≤ leastGE f r m ω

{Ω : Type u_1}
{f : ℕ → Ω → ℝ}
{n m : ℕ}
(hnm : n ≤ m)
(r : ℝ)
(ω : Ω)

MeasureTheory.leastGE f r n ω ≤ MeasureTheory.leastGE f r m ω


theorem Indep.subset_basis_of_subset (hI : M.Indep I) (hIX : I ⊆ X) (hX : X ⊆ M.E := by aesop_mat) :
    ∃ J, M.Basis J X ∧ I ⊆ J

{α : Type u_1}
{M : Matroid α}
{I X : Set α}
(hI : M.Indep I)
(hIX : I ⊆ X)
(hX : X ⊆ M.E := by aesop_mat)


@[to_additive (attr := simp, nolint simpComm)]
theorem unop_inj {x y : αᵐᵒᵖ} : unop x = unop y ↔ x = y

MulOpposite.unop x = MulOpposite.unop y ↔ x = y


theorem ascPochhammer_nat_eq_descFactorial (a b : ℕ) :
    (ascPochhammer ℕ b).eval a = (a + b - 1).descFactorial b

Polynomial.eval a (ascPochhammer ℕ b) = (a + b - 1).descFactorial b


theorem separable_C (r : R) : (C r).Separable ↔ IsUnit r


/-- Laplacian expansion of the determinant of an `n+1 × n+1` matrix along row 0. -/
theorem det_succ_row_zero {n : ℕ} (A : Matrix (Fin n.succ) (Fin n.succ) R) :
    det A = ∑ j : Fin n.succ, (-1) ^ (j : ℕ) * A 0 j * det (A.submatrix Fin.succ j.succAbove)

A.det = ∑ j : Fin n.succ, (-1) ^ ↑j * A 0 j * (A.submatrix Fin.succ j.succAbove).det


theorem eval₂_finset_prod (s : Finset ι) (g : ι → R[X]) (x : S) :
    (∏ i ∈ s, g i).eval₂ f x = ∏ i ∈ s, (g i).eval₂ f x

{R : Type u}
{S : Type v}
{ι : Type y}
[CommSemiring R]
[CommSemiring S]
(f : R →+* S)
(s : Finset ι)
(g : ι → R[X])
(x : S)

Polynomial.eval₂ f x (∏ i ∈ s, g i) = ∏ i ∈ s, Polynomial.eval₂ f x (g i)


lemma exists_nat_one_div_lt (hε : 0 < ε) : ∃ n : ℕ, 1 / (n + 1 : α) < ε

{α : Type u_1}
[LinearOrderedSemifield α]
[Archimedean α]
{ε : α}
(hε : 0 < ε)


theorem AtPrime.localRing [IsLocalization.AtPrime S P] : LocalRing S

{R : Type u_1}
[CommSemiring R]
(S : Type u_2)
[CommSemiring S]
[Algebra R S]
(P : Ideal R)
[hp : P.IsPrime]
[IsLocalization.AtPrime S P]


{α : Type u_2}
{β : Type u_3}
[Lattice α]
[Lattice β]
{f : LatticeHom α β}


@[simp, rclike_simps]
theorem reCLM_apply : ((reCLM : K →L[ℝ] ℝ) : K → ℝ) = re


theorem Kernel.integral_integral_add' ⦃f g : β × γ → E⦄ (hf : Integrable f ((κ ⊗ₖ η) a))
    (hg : Integrable g ((κ ⊗ₖ η) a)) :
    ∫ x, ∫ y, (f + g) (x, y) ∂η (a, x) ∂κ a =
      ∫ x, ∫ y, f (x, y) ∂η (a, x) ∂κ a + ∫ x, ∫ y, g (x, y) ∂η (a, x) ∂κ a

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

⦃f g : β × γ → E⦄

(hf : MeasureTheory.Integrable f ((κ ⊗ₖ η) a))

(hg : MeasureTheory.Integrable g ((κ ⊗ₖ η) a))

∫ (x : β), ∫ (y : γ), (f + g) (x, y) ∂η (a, x) ∂κ a =
  ∫ (x : β), ∫ (y : γ), f (x, y) ∂η (a, x) ∂κ a + ∫ (x : β), ∫ (y : γ), g (x, y) ∂η (a, x) ∂κ a


@[simp]
theorem Ioo_insert_left (h : a < b) : insert a (Ioo a b) = Ico a b

{α : Type u_2}
[PartialOrder α]
[LocallyFiniteOrder α]
{a b : α}
[DecidableEq α]
(h : a < b)

insert a (Finset.Ioo a b) = Finset.Ico a b


theorem MeasurableEmbedding.aemeasurable_comp_iff {g : β → γ} (hg : MeasurableEmbedding g)
    {μ : Measure α} : AEMeasurable (g ∘ f) μ ↔ AEMeasurable f μ

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
{m0 : MeasurableSpace α}
[MeasurableSpace β]
[MeasurableSpace γ]
{f : α → β}
{g : β → γ}
(hg : MeasurableEmbedding g)
{μ : MeasureTheory.Measure α}


@[simp]
theorem map_comp (g : ContinuousMonoidHom B C) (f : ContinuousMonoidHom A B) :
    map (comp g f) = ContinuousMonoidHom.comp (map f) (map g)

{A : Type u_1}
{B : Type u_2}
{C : Type u_3}
[Monoid A]
[Monoid B]
[Monoid C]
[TopologicalSpace A]
[TopologicalSpace B]
[TopologicalSpace C]
(g : ContinuousMonoidHom B C)
(f : ContinuousMonoidHom A B)

PontryaginDual.map (g.comp f) = (PontryaginDual.map f).comp (PontryaginDual.map g)


@[simp]
theorem map_Iio (f : α ≃o β) (a : α) : map f (Iio a) = Iio (f a)

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]
(f : α ≃o β)
(a : α)

(LowerSet.map f) (LowerSet.Iio a) = LowerSet.Iio (f a)


theorem continuousFunctionalCalculus_map_id :
    continuousFunctionalCalculus a ((ContinuousMap.id ℂ).restrict (spectrum ℂ a)) =
      ⟨a, self_mem ℂ a⟩

{A : Type u_1}
[NormedRing A]
[NormedAlgebra ℂ A]
[StarRing A]
[CstarRing A]
[StarModule ℂ A]
[CompleteSpace A]
(a : A)
[IsStarNormal a]

(continuousFunctionalCalculus a) (ContinuousMap.restrict (spectrum ℂ a) (ContinuousMap.id ℂ)) = ⟨a, ⋯⟩


theorem cosh_conj : cosh (conj x) = conj (cosh x)

Complex.cosh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.cosh x)


@[to_additive]
theorem IsCyclic.exists_monoid_generator [Finite α] [IsCyclic α] :
    ∃ x : α, ∀ y : α, y ∈ Submonoid.powers x

{α : Type u}
[AddGroup α]
[Finite α]
[IsAddCyclic α]

∃ x, ∀ (y : α), y ∈ AddSubmonoid.multiples x


theorem mem_support_map_iff : b ∈ (map f p).support ↔ ∃ a ∈ p.support, f a = b

{α : Type u_1}
{β : Type u_2}
(f : α → β)
(p : PMF α)
(b : β)

b ∈ (PMF.map f p).support ↔ ∃ a ∈ p.support, f a = b


@[simp]
theorem reverse_v (m : M) : reverse (Q := Q' Q) (v Q m) = v Q m

{R : Type u_1}
{M : Type u_2}
[CommRing R]
[AddCommGroup M]
[Module R M]
(Q : QuadraticForm R M)
(m : M)

CliffordAlgebra.reverse ((CliffordAlgebra.EquivEven.v Q) m) = (CliffordAlgebra.EquivEven.v Q) m


theorem eq_last_of_not_lt {i : Fin (n + 1)} (h : ¬(i : Nat) < n) : i = last n

{n : Nat}
{i : Fin (n + 1)}
(h : ¬↑i < n)


/-- The canonical bijection between `α` and `αᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn) apply symm_apply)
  "The canonical bijection between `α` and `αᵃᵒᵖ`."]
def opEquiv : α ≃ αᵐᵒᵖ


@[to_additive (attr := simp)]
theorem smul_some : a • some b = some (a • b)

{M : Type u_1}
{α : Type u_3}
[VAdd M α]
(a : M)
(b : α)


@[simp]
theorem toLinearEquiv_refl : (AlgEquiv.refl : A₁ ≃ₐ[R] A₁).toLinearEquiv = LinearEquiv.refl R A₁

{R : Type uR}
{A₁ : Type uA₁}
[CommSemiring R]
[Semiring A₁]
[Algebra R A₁]

AlgEquiv.refl.toLinearEquiv = LinearEquiv.refl R A₁


theorem Convex.add_smul_sub_mem (h : Convex 𝕜 s) {x y : E} (hx : x ∈ s) (hy : y ∈ s) {t : 𝕜}
    (ht : t ∈ Icc (0 : 𝕜) 1) : x + t • (y - x) ∈ s

{𝕜 : Type u_1}
{E : Type u_2}
[OrderedRing 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
{s : Set E}
(h : Convex 𝕜 s)
{x y : E}
(hx : x ∈ s)
(hy : y ∈ s)
{t : 𝕜}
(ht : t ∈ Set.Icc 0 1)


@[to_additive]
theorem mul_inv_eq_iff_eq_mul {a c : α} : a * ↑b⁻¹ = c ↔ a = c * b

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


@[simp]
theorem isConnected_univ_pi [∀ i, TopologicalSpace (π i)] {s : ∀ i, Set (π i)} :
    IsConnected (pi univ s) ↔ ∀ i, IsConnected (s i)

{ι : Type u_1}
{π : ι → Type u_2}
[(i : ι) → TopologicalSpace (π i)]
{s : (i : ι) → Set (π i)}

IsConnected (Set.univ.pi s) ↔ ∀ (i : ι), IsConnected (s i)


@[to_additive (attr := simp) add_mem_addCentralizer]
lemma mul_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a * b ∈ centralizer S

{M : Type u_1}
{S : Set M}
[Semigroup M]
{a b : M}
(ha : a ∈ S.centralizer)
(hb : b ∈ S.centralizer)


@[to_additive (attr := simp)]
theorem mul_univ (hs : s.Nonempty) : s * (univ : Set α) = univ

{α : Type u_2}
[Group α]
{s : Set α}
(hs : s.Nonempty)


theorem lt_toNNReal_iff_coe_lt {r : ℝ≥0} {p : ℝ} : r < Real.toNNReal p ↔ ↑r < p


@[mono]
theorem prod_mono {f₁ f₂ : α →o β} (hf : f₁ ≤ f₂) {g₁ g₂ : α →o γ} (hg : g₁ ≤ g₂) :
    f₁.prod g₁ ≤ f₂.prod g₂

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[Preorder α]
[Preorder β]
[Preorder γ]
{f₁ f₂ : α →o β}
(hf : f₁ ≤ f₂)
{g₁ g₂ : α →o γ}
(hg : g₁ ≤ g₂)


lemma abs_sum_le_sum_abs [LinearOrderedAddCommGroup α] {s : Multiset α} :
    |s.sum| ≤ (s.map abs).sum

{α : Type u_2}
[LinearOrderedAddCommGroup α]
{s : Multiset α}


@[simp]
theorem mk_inf (a b) : (mk (a ⊓ b) : ℝ) = mk a ⊓ mk b


protected lemma IsClosed.upperClosure_pi (hs : IsClosed s) (hs' : BddBelow s) :
    IsClosed (upperClosure s : Set (ι → ℝ))

{ι : Type u_2}
[Finite ι]
{s : Set (ι → ℝ)}
(hs : IsClosed s)
(hs' : BddBelow s)


theorem isCoprime_zero_right : IsCoprime x 0 ↔ IsUnit x


theorem Normal.conjAct {G : Type*} [Group G] {H : Subgroup G} (hH : H.Normal) (g : ConjAct G) :
    g • H = H

{G : Type u_5}
[Group G]
{H : Subgroup G}
(hH : H.Normal)
(g : ConjAct G)


@[to_additive]
lemma orderOf_pow_orderOf_div {x : G} {n : ℕ} (hx : orderOf x ≠ 0) (hn : n ∣ orderOf x) :
    orderOf (x ^ (orderOf x / n)) = n

{G : Type u_1}
[Monoid G]
{x : G}
{n : ℕ}
(hx : orderOf x ≠ 0)
(hn : n ∣ orderOf x)


/-- A small set of surreals is bounded below. -/
lemma bddBelow_of_small (s : Set Surreal.{u}) [Small.{u} s] : BddBelow s


theorem tangentMapWithin_univ : tangentMapWithin I I' f univ = tangentMap I I' f

{𝕜 : 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 : M → M'}
[Is : SmoothManifoldWithCorners I M]
[I's : SmoothManifoldWithCorners I' M']

tangentMapWithin I I' f Set.univ = tangentMap I I' f


@[simp]
theorem minpoly_toLin (b : Basis n R N) (M : Matrix n n R) :
    minpoly R (toLin b b M) = minpoly R M

{R : Type u}
[CommRing R]
{n : Type v}
[DecidableEq n]
[Fintype n]
{N : Type w}
[AddCommGroup N]
[Module R N]
(b : Basis n R N)
(M : Matrix n n R)

minpoly R ((Matrix.toLin b b) M) = minpoly R M


theorem _root_.HasCompactSupport.convolutionExists_right (hcg : HasCompactSupport g)
    (hf : LocallyIntegrable f μ) (hg : Continuous g) : ConvolutionExists f g L μ

(hf : MeasureTheory.LocallyIntegrable f μ)


/-- The set of points which are isolated on the left is countable when the space is
second-countable. -/
theorem countable_of_isolated_left' [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, y < x ∧ Ioo y x = ∅ }

{α : Type u}
[TopologicalSpace α]
[LinearOrder α]
[OrderTopology α]
[SecondCountableTopology α]

{x | ∃ y < x, Set.Ioo y x = ∅}.Countable


lemma StrictMono.mapsTo_Ioo (h : StrictMono f) : MapsTo f (Ioo a b) (Ioo (f a) (f b))

{α : Type u_1}
{β : Type u_2}
{f : α → β}
[Preorder α]
[Preorder β]
{a b : α}
(h : StrictMono f)

Set.MapsTo f (Set.Ioo a b) (Set.Ioo (f a) (f b))


/-- In a non-trivial module, zero is not non-degenerate. -/
theorem not_separatingLeft_zero [Nontrivial M₁] : ¬(0 : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M).SeparatingLeft

{R : Type u_1}
{R₁ : Type u_2}
{R₂ : Type u_3}
{M : Type u_5}
(M₁ : Type u_6)
(M₂ : Type u_7)
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
[CommSemiring R₁]
[AddCommMonoid M₁]
[Module R₁ M₁]
[CommSemiring R₂]
[AddCommMonoid M₂]
[Module R₂ M₂]
(I₁ : R₁ →+* R)
(I₂ : R₂ →+* R)
[Nontrivial M₁]


@[to_additive (attr := mono)]
theorem hasProd_mono (hf : HasProd f a₁) (hg : HasProd g a₂) (h : f ≤ g) : a₁ ≤ a₂

{ι : Type u_1}
{α : Type u_3}
[OrderedCommMonoid α]
[TopologicalSpace α]
[OrderClosedTopology α]
{f g : ι → α}
{a₁ a₂ : α}
(hf : HasProd f a₁)
(hg : HasProd g a₂)
(h : f ≤ g)


theorem map_eq_bot_iff_le_ker {I : Ideal R} (f : F) : I.map f = ⊥ ↔ I ≤ RingHom.ker f

{R : Type u_1}
{S : Type u_2}
{F : Type u_3}
[Semiring R]
[Semiring S]
[FunLike F R S]
[rc : RingHomClass F R S]
{I : Ideal R}
(f : F)


theorem Antiperiodic.const_inv_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
    (ha : a ≠ 0) : Antiperiodic (fun x => f (a⁻¹ * x)) (a * c)

{α : Type u_1}
{β : Type u_2}
{f : α → β}
{c : α}
[DivisionSemiring α]
[Neg β]
(h : Function.Antiperiodic f c)
{a : α}
(ha : a ≠ 0)

Function.Antiperiodic (fun x => f (a⁻¹ * x)) (a * c)


/-- An open embedding is an embedding with open range. -/
@[mk_iff]
structure OpenEmbedding (f : X → Y) extends Embedding f : Prop where
  /-- The range of an open embedding is an open set. -/
  isOpen_range : IsOpen <| range f

{X : Type u_1}
{Y : Type u_2}
[tX : TopologicalSpace X]
[tY : TopologicalSpace Y]
(f : X → Y)

OpenEmbedding f ↔ Embedding f ∧ IsOpen (Set.range f)


/-- The integral valuation of the power series `X : K⟦X⟧` equals `(ofAdd -1) : ℤₘ₀`-/
@[simp]
theorem intValuation_X : (idealX K).intValuationDef X = ↑(Multiplicative.ofAdd (-1 : ℤ))

(PowerSeries.idealX K).intValuationDef PowerSeries.X = ↑(Multiplicative.ofAdd (-1))


@[simp]
theorem Ioc_disjoint_Ioi (h : b ≤ c) : Disjoint (Ioc a b) (Ioi c)

{α : Type v}
[Preorder α]
{a b c : α}
(h : b ≤ c)


theorem continuous_compContinuous {δ : Type*} [TopologicalSpace δ] (g : C(δ, α)) :
    Continuous fun f : α →ᵇ β => f.compContinuous g

{α : Type u}
{β : Type v}
[TopologicalSpace α]
[PseudoMetricSpace β]
{δ : Type u_2}
[TopologicalSpace δ]
(g : C(δ, α))


theorem MapsTo.piecewise_ite {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {f₁ f₂ : α → β}
    [∀ i, Decidable (i ∈ s)] (h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t))
    (h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)) :
    MapsTo (s.piecewise f₁ f₂) (s.ite s₁ s₂) (t.ite t₁ t₂)

{f₁ f₂ : α → β}

(h₂ : Set.MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ))

Set.MapsTo (s.piecewise f₁ f₂) (s.ite s₁ s₂) (t.ite t₁ t₂)


theorem extentClosure_iUnion₂ (f : ∀ i, κ i → Set β) :
    extentClosure r (⋃ (i) (j), f i j) = ⋂ (i) (j), extentClosure r (f i j)

{ι : Sort u_1}
{α : Type u_2}
{β : Type u_3}
{κ : ι → Sort u_5}
(r : α → β → Prop)
(f : (i : ι) → κ i → Set β)

extentClosure r (⋃ i, ⋃ j, f i j) = ⋂ i, ⋂ j, extentClosure r (f i j)


theorem eq_zero_of_image_eq_zero {X Y : C} {f : X ⟶ Y} [HasImage f] (w : image.ι f = 0) :
    f = 0

(w : CategoryTheory.Limits.image.ι f = 0)


@[to_additive (attr := simp, norm_cast)]
lemma coe_mul_coe [SetLike S G] [DivInvMonoid G] [SubgroupClass S G] (H : S) :
    H * H = (H : Set G)

{G : Type u_2}
{S : Type u_4}
[SetLike S G]
[DivInvMonoid G]
[SubgroupClass S G]
(H : S)


theorem sum_apply [AddCommMonoid β] [ContinuousAdd β] {ι : Type*} (s : Finset ι) (f : ι → C_c(α, β))
    (a : α) : (∑ i in s, f i) a = ∑ i in s, f i a

{α : Type u_2}
{β : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
[AddCommMonoid β]
[ContinuousAdd β]
{ι : Type u_5}
(s : Finset ι)
(f : ι → α →C_c β)
(a : α)


@[simp] theorem isPrefixOf_append {n m : Name} : ¬ n.hasMacroScopes → ¬ m.hasMacroScopes → n.isPrefixOf (n ++ m)

¬n.hasMacroScopes = true → ¬m.hasMacroScopes = true → n.isPrefixOf (n ++ m) = true


/-- Class that expresses the fact that two ring homomorphisms are inverses of each other. This is
used to handle `symm` for semilinear equivalences. -/
class RingHomInvPair (σ : R₁ →+* R₂) (σ' : outParam (R₂ →+* R₁)) : Prop where
  /-- `σ'` is a left inverse of `σ` -/
  comp_eq : σ'.comp σ = RingHom.id R₁
  /-- `σ'` is a left inverse of `σ'` -/
  comp_eq₂ : σ.comp σ' = RingHom.id R₂

{R₁ : Type u_1}
{R₂ : Type u_2}
[Semiring R₁]
[Semiring R₂]
{σ : R₁ →+* R₂}
{σ' : outParam (R₂ →+* R₁)}
[self : RingHomInvPair σ σ']


@[to_additive subset_add_normalizer]
theorem subset_normalizer {s : Set G} (hs : IsSubgroup s) : s ⊆ normalizer s

{G : Type u_1}
[AddGroup G]
{s : Set G}
(hs : IsAddSubgroup s)


/-- Given a subset `s` of a set `t`, of sizes at most and at least `n` respectively, there exists a
set `u` of size `n` which is both a superset of `s` and a subset of `t`. -/
lemma exists_subsuperset_card_eq {n : ℕ} (hst : s ⊆ t) (hsn : s.ncard ≤ n) (hnt : n ≤ t.ncard) :
    ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.ncard = n

{α : Type u_1}
{s t : Set α}
{n : ℕ}
(hst : s ⊆ t)
(hsn : s.ncard ≤ n)
(hnt : n ≤ t.ncard)


lemma le_chainBotCoeff_of_rootSpace_ne_top (n : ℤ) (hn : rootSpace H (-n • α + β) ≠ ⊥) :
    n ≤ chainBotCoeff α β

(hn : LieAlgebra.rootSpace H (-n • ⇑α + ⇑β) ≠ ⊥)


@[simp] -- Porting note (#10618): was @[simp]
theorem smul_integral_comp_mul_right (c) :
    (c • ∫ x in a..b, f (x * c)) = ∫ x in a * c..b * c, f x

{E : Type u_3}
[NormedAddCommGroup E]
[CompleteSpace E]
[NormedSpace ℝ E]
{a b : ℝ}
(f : ℝ → E)
(c : ℝ)

c • ∫ (x : ℝ) in a..b, f (x * c) = ∫ (x : ℝ) in a * c..b * c, f x


theorem integral_trim_simpleFunc (hm : m ≤ m0) (f : @SimpleFunc β m F) (hf_int : Integrable f μ) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm

(hf_int : MeasureTheory.Integrable (↑f) μ)

∫ (x : β), ↑f x ∂μ = ∫ (x : β), ↑f x ∂μ.trim hm


theorem ContDiff.comp_contDiffWithinAt {g : F → G} {f : E → F} (h : ContDiff 𝕜 n g)
    (hf : ContDiffWithinAt 𝕜 n f t x) : ContDiffWithinAt 𝕜 n (g ∘ f) t x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type uG}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{t : Set E}
{x : E}
{n : ℕ∞}
{g : F → G}
{f : E → F}
(h : ContDiff 𝕜 n g)
(hf : ContDiffWithinAt 𝕜 n f t x)


/-- If `φ : S₁ ⟶ S₂` is a morphism of short complexes such that `φ.τ₁` is epi, `φ.τ₂` is an iso
and `φ.τ₃` is mono, then a left homology data for `S₂` induces a left homology data for `S₁` with
the same `K` and `H` fields. The inverse construction is `ofEpiOfIsIsoOfMono`. -/
@[simps]
noncomputable def ofEpiOfIsIsoOfMono' (φ : S₁ ⟶ S₂) (h : LeftHomologyData S₂)
    [Epi φ.τ₁] [IsIso φ.τ₂] [Mono φ.τ₃] : LeftHomologyData S₁

(CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono' φ h).π = h.π


@[simp]
theorem norm_of_mem_unitary [Nontrivial E] {U : E} (hU : U ∈ unitary E) : ‖U‖ = 1

{E : Type u_2}
[NormedRing E]
[StarRing E]
[CstarRing E]
[Nontrivial E]
{U : E}
(hU : U ∈ unitary E)


theorem le_enum_succ {o : Ordinal} (a : (succ o).out.α) :
    a ≤
      @enum (succ o).out.α (· < ·) _ o
        (by
          rw [type_lt]
          exact lt_succ o)

{o : Ordinal.{u_3}}
(a : (Quotient.out (Order.succ o)).α)

a ≤ Ordinal.enum (fun x x_1 => x < x_1) o ⋯


/-- The relation used to construct colimits in types for `J : SingleObj G ⥤ Type u` is
equivalent to the `MulAction.orbitRel` equivalence relation on `J.obj  (SingleObj.star G)`. -/
lemma Types.Quot.Rel.iff_orbitRel (x y : J.obj (SingleObj.star G)) :
    Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩
    ↔ Setoid.Rel (MulAction.orbitRel G (J.obj (SingleObj.star G))) x y

(J : CategoryTheory.Functor (CategoryTheory.SingleObj G) (Type u))

(x y : J.obj (CategoryTheory.SingleObj.star G))

CategoryTheory.Limits.Types.Quot.Rel J ⟨CategoryTheory.SingleObj.star G, x⟩ ⟨CategoryTheory.SingleObj.star G, y⟩ ↔
  (MulAction.orbitRel G (J.obj (CategoryTheory.SingleObj.star G))).Rel x y


@[to_additive]
protected lemma div_self (h : IsUnit a) : a / a = 1

{α : Type u}
[DivisionMonoid α]
{a : α}
(h : IsUnit a)


@[to_additive (attr := simp)]
theorem units_inv_right_iff {a : M} {x y : Mˣ} : SemiconjBy a ↑x⁻¹ ↑y⁻¹ ↔ SemiconjBy a x y

{M : Type u_1}
[AddMonoid M]
{a : M}
{x y : AddUnits M}

AddSemiconjBy a ↑(-x) ↑(-y) ↔ AddSemiconjBy a ↑x ↑y


lemma mem_memPartitionSet (f : ℕ → Set α) (n : ℕ) (a : α) : a ∈ memPartitionSet f n a

{α : Type u_1}
(f : ℕ → Set α)
(n : ℕ)
(a : α)


/-- Given a point `p₀` in a set of points, that set is collinear if and
only if the points can all be expressed as multiples of the same
vector, added to `p₀`. -/
theorem collinear_iff_of_mem {s : Set P} {p₀ : P} (h : p₀ ∈ s) :
    Collinear k s ↔ ∃ v : V, ∀ p ∈ s, ∃ r : k, p = r • v +ᵥ p₀

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[DivisionRing k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{s : Set P}
{p₀ : P}
(h : p₀ ∈ s)

Collinear k s ↔ ∃ v, ∀ p ∈ s, ∃ r, p = r • v +ᵥ p₀


@[simp] theorem getLsb_concat_succ : (concat x b).getLsb (i + 1) = x.getLsb i

∀ {w : Nat} {x : BitVec w} {b : Bool} {i : Nat}, (x.concat b).getLsb (i + 1) = x.getLsb i


@[simp]
theorem chain_coe_cons (r : α → α → Prop) (a : α) (l : List α) :
    Chain r (a :: l) ↔ List.Chain r a (l ++ [a])

{α : Type u_1}
(r : α → α → Prop)
(a : α)
(l : List α)

Cycle.Chain r ↑(a :: l) ↔ List.Chain r a (l ++ [a])


@[simp]
theorem coe_mk (f h) : ⇑(mk f h : ι →ᵇᵃ[I₀] M) = f

(h :
  ∀ (J : BoxIntegral.Box ι), ↑J ≤ I₀ → ∀ (π : BoxIntegral.Prepartition J), π.IsPartition → ∑ Ji ∈ π.boxes, f Ji = f J)

⇑{ toFun := f, sum_partition_boxes' := h } = f


theorem mem_seq_iff {f : Filter (α → β)} {g : Filter α} {s : Set β} :
    s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, Set.seq u t ⊆ s

{α : Type u}
{β : Type v}
{f : Filter (α → β)}
{g : Filter α}
{s : Set β}

s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, u.seq t ⊆ s


theorem toSubgraph_adj_iff {u v u' v'} (w : G.Walk u v) :
    w.toSubgraph.Adj u' v' ↔ ∃ i, s(w.getVert i, w.getVert (i + 1)) =
      s(u', v') ∧ i < w.length

{V : Type u}
{G : SimpleGraph V}
{u v u' v' : V}
(w : G.Walk u v)


@[simp]
theorem symm_toEquiv (e : P₁ ≃ᵃ[k] P₂) : e.toEquiv.symm = e.symm.toEquiv

{k : Type u_1}
{P₁ : Type u_2}
{P₂ : Type u_3}
{V₁ : Type u_6}
{V₂ : Type u_7}
[Ring k]
[AddCommGroup V₁]
[Module k V₁]
[AffineSpace V₁ P₁]
[AddCommGroup V₂]
[Module k V₂]
[AffineSpace V₂ P₂]
(e : P₁ ≃ᵃ[k] P₂)


theorem mem_interedges_iff {x : α × β} : x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2

{α : Type u_4}
{β : Type u_5}
{r : α → β → Prop}
[(a : α) → DecidablePred (r a)]
{s : Finset α}
{t : Finset β}
{x : α × β}

x ∈ Rel.interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2


theorem integral_sqrt_one_sub_sq : ∫ x in (-1 : ℝ)..1, √(1 - x ^ 2 : ℝ) = π / 2


@[to_additive (attr := simp)]
theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H

{G : Type u_1}
[Group G]
{g : G}
{H : Subgroup G}


theorem norm_toContinuousLinearMap_le (f : E →ₛₗᵢ[σ₁₂] F) : ‖f.toContinuousLinearMap‖ ≤ 1

{𝕜 : Type u_1}
{𝕜₂ : Type u_2}
{E : Type u_4}
{F : Type u_6}
[SeminormedAddCommGroup E]
[SeminormedAddCommGroup F]
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜₂]
[NormedSpace 𝕜 E]
[NormedSpace 𝕜₂ F]
{σ₁₂ : 𝕜 →+* 𝕜₂}
(f : E →ₛₗᵢ[σ₁₂] F)


@[to_additive (attr := measurability)]
theorem measurable_oneLePart : Measurable (oneLePart : α → α)

{α : Type u_1}
[Lattice α]
[Group α]
[MeasurableSpace α]
[MeasurableSup α]


/-- A special case of `integral_Ioi_of_hasDerivAt_of_tendsto` where we assume that `f` is C^1 with
compact support. -/
theorem _root_.HasCompactSupport.integral_Ioi_deriv_eq (hf : ContDiff ℝ 1 f)
    (h2f : HasCompactSupport f) (b : ℝ) : ∫ x in Ioi b, deriv f x = - f b

{E : Type u_1}
{f : ℝ → E}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[CompleteSpace E]
(hf : ContDiff ℝ 1 f)
(h2f : HasCompactSupport f)
(b : ℝ)

∫ (x : ℝ) in Set.Ioi b, deriv f x = -f b


@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_whiskerRight {X Y : C} [HasRightDual X]
    [HasRightDual Y] (f : X ⟶ Y) :
    (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ f ▷ (Xᘁ)) = (ρ_ _).hom ≫ fᘁ

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
{X Y : C}
[CategoryTheory.HasRightDual X]
[CategoryTheory.HasRightDual Y]
(f : X ⟶ Y)

(CategoryTheory.tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ f ▷ Xᘁ) = (ρ_ Yᘁ).hom ≫ fᘁ


theorem map_toAddSubmonoid (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) :
    (p.map f).toAddSubmonoid = p.toAddSubmonoid.map (f : M →+ M₂)

{R : Type u_1}
{R₂ : Type u_3}
{M : Type u_5}
{M₂ : Type u_7}
[Semiring R]
[Semiring R₂]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R₂ M₂]
{σ₁₂ : R →+* R₂}
[RingHomSurjective σ₁₂]
(f : M →ₛₗ[σ₁₂] M₂)
(p : Submodule R M)

(Submodule.map f p).toAddSubmonoid = AddSubmonoid.map (↑f) p.toAddSubmonoid


@[simp]
theorem coe_real_preimage_closedBall_period_zero (x ε : ℝ) :
    (↑) ⁻¹' closedBall (x : AddCircle (0 : ℝ)) ε = closedBall x ε

QuotientAddGroup.mk ⁻¹' Metric.closedBall (↑x) ε = Metric.closedBall x ε


theorem RingHom.charZero_iff {ϕ : R →+* S} (hϕ : Function.Injective ϕ) : CharZero R ↔ CharZero S

{R : Type u_1}
{S : Type u_2}
[NonAssocSemiring R]
[NonAssocSemiring S]
{ϕ : R →+* S}
(hϕ : Function.Injective ⇑ϕ)


theorem dist_comm (x y : α) : dist x y = dist y x

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


theorem eq_nil_of_card_zero (s : Sym α 0) : s = nil


/-- A constructor that multiplies a `NormalWord` by an element, with condition to make
sure the underlying list does get longer.  -/
@[simps!]
noncomputable def cons {i} (g : G i) (w : NormalWord d) (hmw : w.fstIdx ≠ some i)
    (hgr : g ∉ (φ i).range) : NormalWord d

{d : Monoid.PushoutI.NormalWord.Transversal φ}

(Monoid.PushoutI.NormalWord.cons g w hmw hgr).head = (MonoidHom.ofInjective ⋯).symm (⋯.equiv (g * (φ i) w.head)).1


theorem exists_lt (f : CauSeq α abs) : ∃ a : α, const a < f

{α : Type u_1}
[LinearOrderedField α]
(f : CauSeq α abs)


@[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} :
    a • S ≤ a • T ↔ S ≤ T

{α : Type u_1}
{A : Type u_5}
[AddMonoid A]
[Group α]
[DistribMulAction α A]
{a : α}
{S T : AddSubmonoid A}


@[simp]
theorem mul_left_self_sup : J * I ⊔ I = I

{R : Type u}
[CommSemiring R]
{I J : Ideal R}


lemma indicator_mul_right (s : Set ι) (f g : ι → M₀) :
    indicator s (fun j ↦ f j * g j) i = f i * indicator s g i

{ι : Type u_1}
{M₀ : Type u_4}
[MulZeroClass M₀]
{i : ι}
(s : Set ι)
(f g : ι → M₀)

s.indicator (fun j => f j * g j) i = f i * s.indicator g i


@[continuity]
theorem _root_.Continuous.path_trans {f : Y → Path x y} {g : Y → Path y z} :
    Continuous f → Continuous g → Continuous fun t => (f t).trans (g t)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
{x y z : X}
{f : Y → Path x y}
{g : Y → Path y z}


@[simp]
theorem sub_apply (m : ∀ i, M₁ i) : (f - g) m = f m - g m

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


lemma isIntegralCurve_iff_isIntegralCurveOn : IsIntegralCurve γ v ↔ IsIntegralCurveOn γ v univ

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{H : Type u_2}
[TopologicalSpace H]
{I : ModelWithCorners ℝ E H}
{M : Type u_3}
[TopologicalSpace M]
[ChartedSpace H M]
[SmoothManifoldWithCorners I M]
{γ : ℝ → M}
{v : (x : M) → TangentSpace I x}

IsIntegralCurve γ v ↔ IsIntegralCurveOn γ v Set.univ


/-- The composition of left homology map data. -/
@[simps]
def comp {φ : S₁ ⟶ S₂} {φ' : S₂ ⟶ S₃}
    {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData} {h₃ : S₃.LeftHomologyData}
    (ψ : LeftHomologyMapData φ h₁ h₂) (ψ' : LeftHomologyMapData φ' h₂ h₃) :
    LeftHomologyMapData (φ ≫ φ') h₁ h₃

{S₁ S₂ S₃ : CategoryTheory.ShortComplex C}

(ψ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂)

(ψ' : CategoryTheory.ShortComplex.LeftHomologyMapData φ' h₂ h₃)

(ψ.comp ψ').φK = CategoryTheory.CategoryStruct.comp ψ.φK ψ'.φK


theorem mem_diff_singleton {x y : α} {s : Set α} : x ∈ s \ {y} ↔ x ∈ s ∧ x ≠ y


theorem reduce_to_affine_nbhd (P : ∀ (X : Scheme) (_ : X), Prop)
    (h₁ : ∀ R x, P (Spec R) x)
    (h₂ : ∀ {X Y} (f : X ⟶ Y) [IsOpenImmersion f] (x : X), P X x → P Y (f.1.base x)) :
    ∀ (X : Scheme) (x : X), P X x

(P : (X : AlgebraicGeometry.Scheme) → ↑↑X.toPresheafedSpace → Prop)

(h₁ : ∀ (R : CommRingCat) (x : ↑↑(AlgebraicGeometry.Spec R).toPresheafedSpace), P (AlgebraicGeometry.Spec R) x)

(h₂ :
  ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f]
    (x : ↑↑X.toPresheafedSpace), P X x → P Y (f.val.base x))


theorem ext {Y : Type*} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
    (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g

{α : Type u_1}
[UniformSpace α]
{Y : Type u_4}
[TopologicalSpace Y]
[T2Space Y]
{f g : UniformSpace.Completion α → Y}
(hf : Continuous f)
(hg : Continuous g)
(h : ∀ (a : α), f (↑α a) = g (↑α a))


theorem CovBy.unique_left (ha : a ⋖ c) (hb : b ⋖ c) : a = b

{α : Type u_1}
[LinearOrder α]
{a b c : α}
(ha : a ⋖ c)
(hb : b ⋖ c)


/-- **Structure theorem of finite abelian groups** : Any finite abelian group is a direct sum of
some `ZMod (q i)` for some prime powers `q i > 1`. -/
lemma equiv_directSum_zmod_of_finite' (G : Type*) [AddCommGroup G] [Finite G] :
    ∃ (ι : Type) (_ : Fintype ι) (n : ι → ℕ),
      (∀ i, 1 < n i) ∧ Nonempty (G ≃+ ⨁ i, ZMod (n i))

(G : Type u_1)
[AddCommGroup G]
[Finite G]

∃ ι x n, (∀ (i : ι), 1 < n i) ∧ Nonempty (G ≃+ ⨁ (i : ι), ZMod (n i))


protected theorem Prefunctor.symmetrifyCostar (u : U) :
    φ.symmetrify.costar u =
      (Quiver.symmetrifyCostar _).symm ∘
        Sum.map (φ.costar u) (φ.star u) ∘ Quiver.symmetrifyCostar u

{U : Type u_1}
[Quiver U]
{V : Type u_2}
[Quiver V]
(φ : U ⥤q V)
(u : U)

φ.symmetrify.costar u =
  ⇑(Quiver.symmetrifyCostar (φ.obj u)).symm ∘ Sum.map (φ.costar u) (φ.star u) ∘ ⇑(Quiver.symmetrifyCostar u)


theorem All.imp {P Q : α → Prop} (H : ∀ a, P a → Q a) : ∀ {t}, All P t → All Q t

{α : Type u_1}
{P Q : α → Prop}
(H : ∀ (a : α), P a → Q a)
{t : Ordnode α}