@[mono]
theorem toAntisymmetrization_mono : Monotone (@toAntisymmetrization α (· ≤ ·) _)

Monotone (toAntisymmetrization fun x x_1 => x ≤ x_1)


theorem respectsIso_mk {P : AffineTargetMorphismProperty}
    (h₁ : ∀ {X Y Z} (e : X ≅ Y) (f : Y ⟶ Z) [IsAffine Z], P f → P (e.hom ≫ f))
    (h₂ : ∀ {X Y Z} (e : Y ≅ Z) (f : X ⟶ Y) [h : IsAffine Y],
      P f → @P _ _ (f ≫ e.hom) (isAffine_of_isIso e.inv)) :
    P.toProperty.RespectsIso

(h₁ :
  ∀ {X Y Z : AlgebraicGeometry.Scheme} (e : X ≅ Y) (f : Y ⟶ Z) [inst : AlgebraicGeometry.IsAffine Z],
    P f → P (e.hom ≫ f))

(h₂ :
  ∀ {X Y Z : AlgebraicGeometry.Scheme} (e : Y ≅ Z) (f : X ⟶ Y) [h : AlgebraicGeometry.IsAffine Y], P f → P (f ≫ e.hom))


theorem single_zero_mul_apply [AddZeroClass G] (f : k[G]) (r : k) (x : G) :
    (single (0 : G) r * f) x = r * f x

{k : Type u₁}
{G : Type u₂}
[Semiring k]
[AddZeroClass G]
(f : AddMonoidAlgebra k G)
(r : k)
(x : G)

(AddMonoidAlgebra.single 0 r * f) x = r * f x


/-- `invertibleOfInvertibleMul` and `invertibleMul` as an equivalence. -/
@[simps apply symm_apply]
def Invertible.mulLeft {a : α} (_ : Invertible a) (b : α) : Invertible b ≃ Invertible (a * b)

∀ (x : Invertible a) (b : α) (x_1 : Invertible b), (x.mulLeft b) x_1 = invertibleMul a b


@[simp]
theorem withConstants_funMap_sum_inl [L[[α]].Structure M] [(lhomWithConstants L α).IsExpansionOn M]
    {n} {f : L.Functions n} {x : Fin n → M} : @funMap (L[[α]]) M _ n (Sum.inl f) x = funMap f x

FirstOrder.Language.Structure.funMap (Sum.inl f) x = FirstOrder.Language.Structure.funMap f x


theorem IciExtend_of_mem (f : Ici a → β) (hx : x ∈ Ici a) : IciExtend f x = f ⟨x, hx⟩

{α : Type u_1}
{β : Type u_2}
[LinearOrder α]
{a x : α}
(f : ↑(Set.Ici a) → β)
(hx : x ∈ Set.Ici a)


@[deprecated measure_le_inter_add_diff (since := "2024-05-14")]
theorem le_inter_add_diff {m : OuterMeasure α} {t : Set α} (s : Set α) :
    m t ≤ m (t ∩ s) + m (t \ s)

{α : Type u_1}
{m : MeasureTheory.OuterMeasure α}
{t : Set α}
(s : Set α)


/-- The reflection in `(𝕜 ∙ v)ᗮ` of `v` is `-v`. -/
theorem reflection_orthogonalComplement_singleton_eq_neg (v : E) : reflection (𝕜 ∙ v)ᗮ v = -v

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
(v : E)

(reflection (Submodule.span 𝕜 {v})ᗮ) v = -v


@[ext]
lemma sections_ext {M : PresheafOfModules.{v} R} (s t : M.sections)
    (h : ∀ (X : Cᵒᵖ), s.val X = t.val X) : s = t

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{R : Cᵒᵖ ⥤ RingCat}
{M : PresheafOfModules R}
(s t : M.sections)
(h : ∀ (X : Cᵒᵖ), ↑s X = ↑t X)


@[to_additive (attr := simp) add_le_iff_nonpos_left]
theorem mul_le_iff_le_one_left' [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} :
    a * b ≤ b ↔ a ≤ 1

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

[ContravariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]


theorem mul_def (f g : G →+c[a, a] G) : f * g = f.comp g

{G : Type u_1}
[Add G]
{a : G}
(f g : AddConstMap G G a a)


/-- Mapping by the identity morphism is just the identity functor. -/
theorem mapId_eq (Y : T) : map (𝟙 Y) = 𝟭 _

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

CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y)


/-- The translation of a convex set is also convex. -/
theorem Convex.translate_preimage_left (hs : Convex 𝕜 s) (z : E) :
    Convex 𝕜 ((fun x => x + z) ⁻¹' s)

{𝕜 : Type u_1}
{E : Type u_2}
[OrderedSemiring 𝕜]
[AddCommMonoid E]
[Module 𝕜 E]
{s : Set E}
(hs : Convex 𝕜 s)
(z : E)


nonrec theorem GradedAlgebra.ι_sq_scalar (m : M) :
    GradedAlgebra.ι Q m * GradedAlgebra.ι Q m = algebraMap R _ (Q m)

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

(CliffordAlgebra.GradedAlgebra.ι Q) m * (CliffordAlgebra.GradedAlgebra.ι Q) m =
  (algebraMap R (DirectSum (ZMod 2) fun i => ↥(CliffordAlgebra.evenOdd Q i))) (Q m)


theorem lintegral_congr {f g : α → ℝ≥0∞} (h : ∀ a, f a = g a) : ∫⁻ a, f a ∂μ = ∫⁻ a, g a ∂μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f g : α → ℝ≥0∞}
(h : ∀ (a : α), f a = g a)


theorem ContDiff.comp_contDiff_on₃ {g : E₁ × E₂ × E₃ → G} {f₁ : F → E₁} {f₂ : F → E₂} {f₃ : F → E₃}
    {s : Set F} (hg : ContDiff 𝕜 n g) (hf₁ : ContDiffOn 𝕜 n f₁ s) (hf₂ : ContDiffOn 𝕜 n f₂ s)
    (hf₃ : ContDiffOn 𝕜 n f₃ s) : ContDiffOn 𝕜 n (fun x => g (f₁ x, f₂ x, f₃ x)) s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type uG}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{n : ℕ∞}
{E₁ : Type u_3}
{E₂ : Type u_4}
{E₃ : Type u_5}
[NormedAddCommGroup E₁]
[NormedAddCommGroup E₂]
[NormedAddCommGroup E₃]
[NormedSpace 𝕜 E₁]
[NormedSpace 𝕜 E₂]
[NormedSpace 𝕜 E₃]
{g : E₁ × E₂ × E₃ → G}
{f₁ : F → E₁}
{f₂ : F → E₂}
{f₃ : F → E₃}
{s : Set F}
(hg : ContDiff 𝕜 n g)
(hf₁ : ContDiffOn 𝕜 n f₁ s)
(hf₂ : ContDiffOn 𝕜 n f₂ s)
(hf₃ : ContDiffOn 𝕜 n f₃ s)


/-- The measurable space generated by a family of sets `𝒜` is the same as the one generated
by the algebra of sets generated by `𝒜`. -/
@[simp]
theorem generateFrom_generateSetAlgebra_eq :
    generateFrom (generateSetAlgebra 𝒜) = generateFrom 𝒜

MeasurableSpace.generateFrom (MeasureTheory.generateSetAlgebra 𝒜) = MeasurableSpace.generateFrom 𝒜


@[simp]
theorem presheafToTop_obj (T : TopCat.{v}) (U : (Opens X)ᵒᵖ) :
    (presheafToTop X T).obj U = ((Opens.toTopCat X).obj (unop U) ⟶ T)

(X T : TopCat)
(U : (TopologicalSpace.Opens ↑X)ᵒᵖ)

(X.presheafToTop T).obj U = ((TopologicalSpace.Opens.toTopCat X).obj (Opposite.unop U) ⟶ T)


@[csimp] theorem filterMap_eq_filterMapTR : @List.filterMap = @filterMapTR


@[simp]
theorem leibniz : D (a * b) = a • D b + b • D a

{R : Type u_1}
{A : Type u_2}
{M : Type u_4}
[CommSemiring R]
[CommSemiring A]
[AddCommMonoid M]
[Algebra R A]
[Module A M]
[Module R M]
(D : Derivation R A M)
(a b : A)


@[simp]
theorem equivProdOfSurjectiveOfIsCompl_apply {f : E →ₗ[R] F} {g : E →ₗ[R] G} (hf : range f = ⊤)
    (hg : range g = ⊤) (hfg : IsCompl (ker f) (ker g)) (x : E) :
    equivProdOfSurjectiveOfIsCompl f g hf hg hfg x = (f x, g x)

(hfg : IsCompl (LinearMap.ker f) (LinearMap.ker g))

(f.equivProdOfSurjectiveOfIsCompl g hf hg hfg) x = (f x, g x)


@[to_additive] lemma monovaryOn_inv : MonovaryOn f⁻¹ g⁻¹ s ↔ MonovaryOn f g s

{ι : Type u_1}
{α : Type u_2}
{β : Type u_3}
[OrderedCommGroup α]
[OrderedCommGroup β]
{s : Set ι}
{f : ι → α}
{g : ι → β}


protected theorem eq' {x y : M} : (mk x : M ⧸ p) = (mk : M → M ⧸ p) y ↔ -x + y ∈ p

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

Submodule.Quotient.mk x = Submodule.Quotient.mk y ↔ -x + y ∈ p


theorem IsBigO.exists_mem_basis {ι} {p : ι → Prop} {s : ι → Set α} (h : f =O[l] g')
    (hb : l.HasBasis p s) :
    ∃ c > 0, ∃ i : ι, p i ∧ ∀ x ∈ s i, ‖f x‖ ≤ c * ‖g' x‖

{α : Type u_1}
{E : Type u_3}
{F' : Type u_7}
[Norm E]
[SeminormedAddCommGroup F']
{f : α → E}
{g' : α → F'}
{l : Filter α}
{ι : Sort u_17}
{p : ι → Prop}
{s : ι → Set α}
(h : f =O[l] g')
(hb : l.HasBasis p s)

∃ c > 0, ∃ i, p i ∧ ∀ x ∈ s i, ‖f x‖ ≤ c * ‖g' x‖


@[simp]
theorem map_sup_ker_eq_map' :
    LieIdeal.map f I ⊔ LieIdeal.map f (LieHom.ker f) = LieIdeal.map f I

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

LieIdeal.map f I ⊔ LieIdeal.map f f.ker = LieIdeal.map f I


theorem mem_range_self (φ : F) (x : A) :
    φ x ∈ (NonUnitalAlgHom.range φ : NonUnitalSubalgebra R B)

{F : Type v'}
{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[NonUnitalNonAssocSemiring B]
[Module R B]
[FunLike F A B]
[NonUnitalAlgHomClass F R A B]
(φ : F)
(x : A)


/-- The canonical map `Φ.op.RightResolution X₂ → Φ.LeftResolution X₂`. -/
@[simps]
def RightResolution.unop {X₂ : C₂ᵒᵖ} (L : Φ.op.RightResolution X₂) :
    Φ.LeftResolution X₂.unop

{W₁ : CategoryTheory.MorphismProperty C₁}

{W₂ : CategoryTheory.MorphismProperty C₂}

{Φ : CategoryTheory.LocalizerMorphism W₁ W₂}


theorem isSFiniteKernel_sum_of_denumerable [Denumerable ι] {κs : ι → Kernel α β}
    (hκs : ∀ n, IsSFiniteKernel (κs n)) : IsSFiniteKernel (Kernel.sum κs)

(hκs : ∀ (n : ι), ProbabilityTheory.IsSFiniteKernel (κs n))


@[to_additive]
theorem mono (h : IsFundamentalDomain G s μ) {ν : Measure α} (hle : ν ≪ μ) :
    IsFundamentalDomain G s ν

(h : MeasureTheory.IsFundamentalDomain G s μ)


/-- A lax monoidal functor takes monoid objects to monoid objects.

That is, a lax monoidal functor `F : C ⥤ D` induces a functor `Mon_ C ⥤ Mon_ D`.
-/
@[simps]
def mapMon (F : LaxMonoidalFunctor C D) : Mon_ C ⥤ Mon_ D

(F : CategoryTheory.LaxMonoidalFunctor C D)


theorem nat (n : ℕ) (x y : E) : inner_ 𝕜 ((n : 𝕜) • x) y = (n : 𝕜) * inner_ 𝕜 x y

{𝕜 : Type u_1}
[RCLike 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[InnerProductSpaceable E]
(n : ℕ)
(x y : E)


theorem toMultiset_sum_single (s : Finset ι) (n : ℕ) :
    Finsupp.toMultiset (∑ i ∈ s, single i n) = n • s.val

Finsupp.toMultiset (∑ i ∈ s, Finsupp.single i n) = n • s.val


theorem Nodup.take_eq_filter_mem [DecidableEq α] :
    ∀ {l : List α} {n : ℕ} (_ : l.Nodup), l.take n = l.filter (l.take n).elem

{α : Type u}
[DecidableEq α]
{l : List α}
{n : ℕ}

l.Nodup → List.take n l = List.filter (fun a => List.elem a (List.take n l)) l


theorem castSucc_fin_succ (n : Nat) (j : Fin n) :
    castSucc (Fin.succ j) = Fin.succ (castSucc j)


@[simp]
theorem coe_zeroRootSubalgebra : (zeroRootSubalgebra R L H : Submodule R L) = rootSpace H 0

(R : Type u_1)
(L : Type u_2)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(H : LieSubalgebra R L)
[LieAlgebra.IsNilpotent R ↥H]

(LieAlgebra.zeroRootSubalgebra R L H).toSubmodule = ↑(LieAlgebra.rootSpace H 0)


/-- The affine open sets of an open subscheme corresponds to
the affine open sets containing in the image. -/
@[simps]
def _root_.AlgebraicGeometry.IsOpenImmersion.affineOpensEquiv (f : X ⟶ Y) [H : IsOpenImmersion f] :
    X.affineOpens ≃ { U : Y.affineOpens // U ≤ f.opensRange }

[H : AlgebraicGeometry.IsOpenImmersion f]

↑↑((AlgebraicGeometry.IsOpenImmersion.affineOpensEquiv f) U) = (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj ↑U


@[simp]
theorem closure_le_closed_iff_le (x : α) {y : α} (hy : l.closed y) : u (l x) ≤ y ↔ x ≤ y

{α : Type u_1}
{β : Type u_4}
[PartialOrder α]
[PartialOrder β]
{u : β → α}
(l : LowerAdjoint u)
(x : α)
{y : α}
(hy : l.closed y)


@[fun_prop]
theorem Continuous.log (hf : Continuous f) (h₀ : ∀ x, f x ≠ 0) : Continuous fun x => log (f x)

{α : Type u_1}
[TopologicalSpace α]
{f : α → ℝ}
(hf : Continuous f)
(h₀ : ∀ (x : α), f x ≠ 0)


@[to_additive]
theorem zpow_smul_eq_iff_period_dvd {j : ℤ} {g : G} {a : α} :
    g ^ j • a = a ↔ (period g a : ℤ) ∣ j

{α : Type v}
{G : Type u}
[Group G]
[MulAction G α]
{j : ℤ}
{g : G}
{a : α}

g ^ j • a = a ↔ ↑(MulAction.period g a) ∣ j


@[simp]
theorem rightComm_symm_tmul (m : M) (p : P) (q : Q) :
    (rightComm R A M P Q).symm ((m ⊗ₜ q) ⊗ₜ p) = (m ⊗ₜ p) ⊗ₜ q

(R : Type uR)
(A : Type uA)
{M : Type uM}
{P : Type uP}
{Q : Type uQ}
[CommSemiring R]
[CommSemiring A]
[Algebra R A]
[AddCommMonoid M]
[Module R M]
[Module A M]
[IsScalarTower R A M]
[AddCommMonoid P]
[Module A P]
[AddCommMonoid Q]
[Module R Q]
(m : M)
(p : P)
(q : Q)

(TensorProduct.AlgebraTensorModule.rightComm R A M P Q).symm ((m ⊗ₜ[R] q) ⊗ₜ[A] p) = (m ⊗ₜ[A] p) ⊗ₜ[R] q


theorem setIntegral_nonpos_le {s : Set X} (hs : MeasurableSet s) (hf : StronglyMeasurable f)
    (hfi : Integrable f μ) : ∫ x in {y | f y ≤ 0}, f x ∂μ ≤ ∫ x in s, f x ∂μ

(hf : MeasureTheory.StronglyMeasurable f)

∫ (x : X) in {y | f y ≤ 0}, f x ∂μ ≤ ∫ (x : X) in s, f x ∂μ


@[to_additive]
theorem isClopen [ContinuousMul G] (U : OpenSubgroup G) : IsClopen (U : Set G)

{G : Type u_1}
[Group G]
[TopologicalSpace G]
[ContinuousMul G]
(U : OpenSubgroup G)


theorem Basis.exists_basis_inter_eq_of_superset (hI : M.Basis I X) (hXY : X ⊆ Y)
    (hY : Y ⊆ M.E := by aesop_mat) : ∃ J, M.Basis J Y ∧ J ∩ X = I

{α : Type u_1}
{M : Matroid α}
{I X Y : Set α}
(hI : M.Basis I X)
(hXY : X ⊆ Y)
(hY : Y ⊆ M.E := by aesop_mat)


theorem sSupClosed {s : Set α} (h : s ⊆ L) : sSup s ∈ L

{α : Type u_1}
[CompleteLattice α]
{L : CompleteSublattice α}
{s : Set α}
(h : s ⊆ ↑L)


theorem proj_surjOn_baseSet [Nonempty F] : Set.SurjOn proj e.source e.baseSet

{B : Type u_2}
{F : Type u_3}
{Z : Type u_5}
[TopologicalSpace B]
[TopologicalSpace F]
{proj : Z → B}
[TopologicalSpace Z]
(e : Trivialization F proj)
[Nonempty F]


@[to_additive]
theorem prod_multiset_map_count [DecidableEq α] (s : Multiset α) {M : Type*} [CommMonoid M]
    (f : α → M) : (s.map f).prod = ∏ m ∈ s.toFinset, f m ^ s.count m

{α : Type u_3}
[DecidableEq α]
(s : Multiset α)
{M : Type u_6}
[CommMonoid M]
(f : α → M)

(Multiset.map f s).prod = ∏ m ∈ s.toFinset, f m ^ Multiset.count m s


@[simp] theorem add_mod_right (x z : Nat) : (x + z) % z = x % z


protected lemma Iff.ne {α β : Sort*} {a b : α} {c d : β} : (a = b ↔ c = d) → (a ≠ b ↔ c ≠ d)

{α : Sort u_1}
{β : Sort u_2}
{a b : α}
{c d : β}


private lemma tens_surj : Function.Surjective (lTensorf I M f)

{R : Type u}
[CommRing R]
(I : Ideal R)
(M : Type u)
[AddCommGroup M]
[Module R M]
{ι : Type}
(f : (ι → R) →ₗ[R] M)
(hf : Function.Surjective ⇑f)

Function.Surjective ⇑(AdicCompletion.lTensorf I M f)


theorem fromUnitLift_injective [Fact <| 0 < n] :
    Function.Injective <| @fromUnitLift R _ _ K _ _ _ n _

{R : Type u}
[CommRing R]
[IsDedekindDomain R]
{K : Type v}
[Field K]
[Algebra R K]
[IsFractionRing R K]
{n : ℕ}
[Fact (0 < n)]


theorem injOn_insertNth_index_of_not_mem (l : List α) (x : α) (hx : x ∉ l) :
    Set.InjOn (fun k => insertNth k x l) { n | n ≤ l.length }

{α : Type u_1}
(l : List α)
(x : α)
(hx : x ∉ l)

Set.InjOn (fun k => List.insertNth k x l) {n | n ≤ l.length}


theorem lowerBounds_mono ⦃s t : Set α⦄ (hst : s ⊆ t) ⦃a b⦄ (hab : a ≤ b) :
    b ∈ lowerBounds t → a ∈ lowerBounds s

{α : Type u}
[Preorder α]
⦃s t : Set α⦄
(hst : s ⊆ t)
⦃a b : α⦄
(hab : a ≤ b)


/-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J)

{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C)
(c : CategoryTheory.Limits.Cocone F)

((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).hom = c.ι


theorem Ico_succ_right : Ico a b.succ = Icc a b


@[simp, norm_cast]
theorem coe_iSup (f : ι → UpperSet α) : (↑(⨆ i, f i) : Set α) = ⋂ i, f i

{α : Type u_1}
{ι : Sort u_4}
[LE α]
(f : ι → UpperSet α)


@[simp] theorem inseparable_prod {x₁ x₂ : X} {y₁ y₂ : Y} :
    ((x₁, y₁) ~ᵢ (x₂, y₂)) ↔ (x₁ ~ᵢ x₂) ∧ (y₁ ~ᵢ y₂)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
{x₁ x₂ : X}
{y₁ y₂ : Y}


theorem liftR_map {α β : TypeVec n} {F' : TypeVec n → Type u} [MvFunctor F'] [LawfulMvFunctor F']
    (R : β ⊗ β ⟹ «repeat» n Prop) (x : F' α) (f g : α ⟹ β) (h : α ⟹ Subtype_ R)
    (hh : subtypeVal _ ⊚ h = (f ⊗' g) ⊚ prod.diag) : LiftR' R (f <$$> x) (g <$$> x)

(hh : TypeVec.subtypeVal R ⊚ h = (f ⊗' g) ⊚ TypeVec.prod.diag)

MvFunctor.LiftR' R (f <$$> x) (g <$$> x)


theorem _root_.fourierIntegral_gaussian_pi (hb : 0 < b.re) :
    (𝓕 fun (x : ℝ) ↦ cexp (-π * b * x ^ 2)) =
    fun t : ℝ ↦ 1 / b ^ (1 / 2 : ℂ) * cexp (-π / b * t ^ 2)


theorem isUnit_iff_constantCoeff {φ : MvPowerSeries σ R} :
    IsUnit φ ↔ IsUnit (constantCoeff σ R φ)

{σ : Type u_1}
{R : Type u_2}
[Ring R]
{φ : MvPowerSeries σ R}

IsUnit φ ↔ IsUnit ((MvPowerSeries.constantCoeff σ R) φ)


@[simp]
theorem coe_id : ((id : M →ₗ⁅R,L⁆ M) : M → M) = _root_.id

{R : Type u}
{L : Type v}
{M : Type w}
[CommRing R]
[LieRing L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]


/-- `limsup` over a general filter is measurable. See `measurable_limsup` for the version over `ℕ`.
-/
theorem measurable_limsup' {ι ι'} {f : ι → δ → α} {u : Filter ι} (hf : ∀ i, Measurable (f i))
    {p : ι' → Prop} {s : ι' → Set ι} (hu : u.HasCountableBasis p s) (hs : ∀ i, (s i).Countable) :
    Measurable fun x => limsup (fun i => f i x) u

{α : Type u_1}
{δ : Type u_4}
[TopologicalSpace α]
[MeasurableSpace α]
[BorelSpace α]
[MeasurableSpace δ]
[ConditionallyCompleteLinearOrder α]
[OrderTopology α]
[SecondCountableTopology α]
{ι : Type u_5}
{ι' : Type u_6}
{f : ι → δ → α}
{u : Filter ι}
(hf : ∀ (i : ι), Measurable (f i))
{p : ι' → Prop}
{s : ι' → Set ι}
(hu : u.HasCountableBasis p s)
(hs : ∀ (i : ι'), (s i).Countable)

Measurable fun x => Filter.limsup (fun i => f i x) u


theorem continuous_coe : Continuous fun (f : α →ᵇ β) x => f x

{α : Type u}
{β : Type v}
[TopologicalSpace α]
[PseudoMetricSpace β]


theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b


theorem measurable_uncurry_of_continuous_of_measurable {α β ι : Type*} [TopologicalSpace ι]
    [MetrizableSpace ι] [MeasurableSpace ι] [SecondCountableTopology ι] [OpensMeasurableSpace ι]
    {mβ : MeasurableSpace β} [TopologicalSpace β] [PseudoMetrizableSpace β] [BorelSpace β]
    {m : MeasurableSpace α} {u : ι → α → β} (hu_cont : ∀ x, Continuous fun i => u i x)
    (h : ∀ i, Measurable (u i)) : Measurable (Function.uncurry u)

{u : ι → α → β}

(hu_cont : ∀ (x : α), Continuous fun i => u i x)


theorem limsup_eq_sInf_sSup {ι R : Type*} (F : Filter ι) [CompleteLattice R] (a : ι → R) :
    limsup a F = sInf ((fun I => sSup (a '' I)) '' F.sets)

{ι : Type u_6}
{R : Type u_7}
(F : Filter ι)
[CompleteLattice R]
(a : ι → R)

Filter.limsup a F = sInf ((fun I => sSup (a '' I)) '' F.sets)


theorem sMod_nonneg (p : ℕ) (hp : p ≠ 0) (i : ℕ) : 0 ≤ sMod p i


/-- Transfer `IsLittleO` over a `Homeomorph`. -/
theorem isLittleO_congr (e : α ≃ₜ β) {b : β} {f : β → E} {g : β → F} :
    f =o[𝓝 b] g ↔ (f ∘ e) =o[𝓝 (e.symm b)] (g ∘ e)

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
{E : Type u_3}
[Norm E]
{F : Type u_4}
[Norm F]
(e : α ≃ₜ β)
{b : β}
{f : β → E}
{g : β → F}

f =o[𝓝 b] g ↔ (f ∘ ⇑e) =o[𝓝 (e.symm b)] (g ∘ ⇑e)


@[simp] lemma biUnion_empty : Finset.biUnion ∅ t = ∅

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


@[simp] theorem prevn_zero (s : Substring) : ∀ n, s.prevn n 0 = 0


/-- Shrink `α` to a smaller universe preserves algebra structure. -/
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α

(α : Type u)
(R : Type u_1)
[CommSemiring R]
[Small.{v, u} α]
[Semiring α]
[Algebra R α]

∀ (a : α), (Shrink.algEquiv α R).symm a = (equivShrink α) a


@[simp]
theorem isLeftRegular_star_iff [Mul R] [StarMul R] {x : R} :
    IsLeftRegular (star x) ↔ IsRightRegular x

{R : Type u}
[Mul R]
[StarMul R]
{x : R}


theorem hasBasis_biInf_of_directed {ι : Type*} {ι' : Sort _} {dom : Set ι} (hdom : dom.Nonempty)
    {l : ι → Filter α} (s : ι → ι' → Set α) (p : ι → ι' → Prop)
    (hl : ∀ i ∈ dom, (l i).HasBasis (p i) (s i)) (h : DirectedOn (l ⁻¹'o GE.ge) dom) :
    (⨅ i ∈ dom, l i).HasBasis (fun ii' : ι × ι' => ii'.1 ∈ dom ∧ p ii'.1 ii'.2) fun ii' =>
      s ii'.1 ii'.2

(⨅ i ∈ dom, l i).HasBasis (fun ii' => ii'.1 ∈ dom ∧ p ii'.1 ii'.2) fun ii' => s ii'.1 ii'.2


theorem fderivWithin_arctan (hf : DifferentiableWithinAt ℝ f s x) (hxs : UniqueDiffWithinAt ℝ s x) :
    fderivWithin ℝ (fun x => arctan (f x)) s x = (1 / (1 + f x ^ 2)) • fderivWithin ℝ f s x

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{f : E → ℝ}
{x : E}
{s : Set E}
(hf : DifferentiableWithinAt ℝ f s x)
(hxs : UniqueDiffWithinAt ℝ s x)

fderivWithin ℝ (fun x => Real.arctan (f x)) s x = (1 / (1 + f x ^ 2)) • fderivWithin ℝ f s x


theorem reachable_comm {u v : V} : G.Reachable u v ↔ G.Reachable v u

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


protected theorem inf_eq_left {a b : CauSeq α abs} (h : a ≤ b) : a ⊓ b ≈ a

{α : Type u_1}
[LinearOrderedField α]
{a b : CauSeq α abs}
(h : a ≤ b)


lemma LSeries.term_sub_apply (f g : ℕ → ℂ) (s : ℂ) (n : ℕ) :
    term (f - g) s n = term f s n - term g s n

LSeries.term (f - g) s n = LSeries.term f s n - LSeries.term g s n


theorem mul_lt_one_of_nonneg_of_lt_one_right [MulPosMono α]
    (ha : a ≤ 1) (hb₀ : 0 ≤ b) (hb : b < 1) : a * b < 1

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


@[to_additive]
theorem tendsto_inv (a : G) : Tendsto Inv.inv (𝓝 a) (𝓝 a⁻¹)

{G : Type w}
[TopologicalSpace G]
[Neg G]
[ContinuousNeg G]
(a : G)


theorem isSatisfiable_empty (L : Language.{u, v}) : IsSatisfiable (∅ : L.Theory)


@[simp]
theorem transpose_zero [Zero α] : (0 : Matrix m n α)ᵀ = 0

{m : Type u_2}
{n : Type u_3}
{α : Type v}
[Zero α]


@[simp]
theorem midpoint_self_neg (x : V) : midpoint R x (-x) = 0

(R : Type u_1)
{V : Type u_2}
[Ring R]
[Invertible 2]
[AddCommGroup V]
[Module R V]
(x : V)


lemma map_weightSpace_le :
    (weightSpace M χ).map f ≤ weightSpace M₂ χ

{R : Type u_2}
{L : Type u_3}
{M : Type u_4}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[LieAlgebra.IsNilpotent R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
{M₂ : Type u_5}
[AddCommGroup M₂]
[Module R M₂]
[LieRingModule L M₂]
[LieModule R L M₂]
{χ : L → R}
(f : M →ₗ⁅R,L⁆ M₂)

LieSubmodule.map f (LieModule.weightSpace M χ) ≤ LieModule.weightSpace M₂ χ


@[to_additive]
lemma prod_fiberwise_of_maps_to {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : ι → α) :
    ∏ j ∈ t, ∏ i ∈ s.filter fun i ↦ g i = j, f i = ∏ i ∈ s, f i

{ι : Type u_6}
{κ : Type u_7}
{α : Type u_8}
[AddCommMonoid α]
{s : Finset ι}
{t : Finset κ}
[DecidableEq κ]
{g : ι → κ}
(h : ∀ i ∈ s, g i ∈ t)
(f : ι → α)

∑ j ∈ t, ∑ i ∈ Finset.filter (fun i => g i = j) s, f i = ∑ i ∈ s, f i


@[simp, norm_cast]
lemma cast_abs : (↑|a| : R) = |(a : R)|

{R : Type u_1}
[LinearOrderedRing R]
{a : ℤ}


@[simp]
theorem coe_mk {f : A →ₗc[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₐc[R] B) : A → B) = f

(h₁ : ∀ (x y : A), f.toFun (x * y) = f.toFun x * f.toFun y)

⇑{ toCoalgHom := f, map_one' := h, map_mul' := h₁ } = ⇑f


@[fun_prop]
theorem Differentiable.mul_const (ha : Differentiable 𝕜 a) (b : 𝔸) :
    Differentiable 𝕜 fun y => a y * b

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{𝔸 : Type u_6}
[NormedRing 𝔸]
[NormedAlgebra 𝕜 𝔸]
{a : E → 𝔸}
(ha : Differentiable 𝕜 a)
(b : 𝔸)


/--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A

(X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A)

∀ (X_1 : Cᵒᵖ),
  ((e.sheafCongrPrecoherent A).unitIso.hom.app X).val.app X_1 = X.val.map (e.unitIso.inv.app (Opposite.unop X_1)).op


theorem ncard_diff_add_ncard (s t : Set α) (hs : s.Finite := by toFinite_tac)
  (ht : t.Finite := by toFinite_tac) :
    (s \ t).ncard + t.ncard = (s ∪ t).ncard

{α : Type u_1}
(s t : Set α)
(hs : s.Finite := by toFinite_tac)
(ht : t.Finite := by toFinite_tac)


theorem IsLittleO.mul_isBigO {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =o[l] g₁) (h₂ : f₂ =O[l] g₂) :
    (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x

{α : Type u_1}
{R : Type u_13}
{𝕜 : Type u_15}
[SeminormedRing R]
[NormedDivisionRing 𝕜]
{l : Filter α}
{f₁ f₂ : α → R}
{g₁ g₂ : α → 𝕜}
(h₁ : f₁ =o[l] g₁)
(h₂ : f₂ =O[l] g₂)


/-- If `a` is divisible by `4` and `b` is odd, then we can remove the factor `4` from `a`. -/
theorem jacobiSymNat.double_even (a b c : ℕ) (r : ℤ) (ha : a % 4 = 0) (hb : b % 2 = 1)
    (hc : a / 4 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = r

(hr : Mathlib.Meta.NormNum.jacobiSymNat c b = r)

Mathlib.Meta.NormNum.jacobiSymNat a b = r


@[simp]
lemma map_dualCoannihilator_linearEquiv_flip (p : Submodule R (Dual R M)) :
    p.dualCoannihilator.map e.flip = (p.map e.symm).dualAnnihilator

{R : Type u_1}
{M : Type u_2}
{N : Type u_3}
[CommRing R]
[AddCommGroup M]
[Module R M]
[AddCommGroup N]
[Module R N]
[Module.IsReflexive R M]
(e : N ≃ₗ[R] Module.Dual R M)
(p : Submodule R (Module.Dual R M))

Submodule.map e.flip p.dualCoannihilator = (Submodule.map e.symm p).dualAnnihilator


@[to_additive add_center_normal]
theorem center_normal : IsNormalSubgroup (center G)


/-- Shows that `fib` indeed satisfies the Fibonacci recurrence `Fₙ₊₂ = Fₙ + Fₙ₊₁.` -/
theorem fib_add_two {n : ℕ} : fib (n + 2) = fib n + fib (n + 1)

Nat.fib (n + 2) = Nat.fib n + Nat.fib (n + 1)


/-- The extension of functors functor `(C ⥤ D) ⥤ (Karoubi C ⥤ D)`
when `D` is idempotent complete. -/
@[simps!]
noncomputable def functorExtension : (C ⥤ D) ⥤ Karoubi C ⥤ D

(C : Type u_1)
(D : Type u_2)
[CategoryTheory.Category.{u_4, u_1} C]
[CategoryTheory.Category.{u_5, u_2} D]
[CategoryTheory.IsIdempotentComplete D]
(X : CategoryTheory.Functor C D)

∀ (X_1 : CategoryTheory.Idempotents.Karoubi C),
  ((CategoryTheory.Idempotents.functorExtension C D).obj X).obj X_1 =
    (CategoryTheory.Idempotents.toKaroubiEquivalence D).inverse.obj
      (((CategoryTheory.Idempotents.functorExtension₂ C D).obj X).obj X_1)


theorem unsym_mul_self [Semiring α] [Invertible (2 : α)] (a : αˢʸᵐ) :
    unsym (a * a) = unsym a * unsym a

{α : Type u_1}
[Semiring α]
[Invertible 2]
(a : αˢʸᵐ)

SymAlg.unsym (a * a) = SymAlg.unsym a * SymAlg.unsym a


/-- The trace of the identity endomorphism is the dimension of the free module -/
@[simp]
theorem trace_one : trace R M 1 = (finrank R M : R)

(R : Type u_1)
[CommRing R]
(M : Type u_2)
[AddCommGroup M]
[Module R M]
[Module.Free R M]
[Module.Finite R M]

(LinearMap.trace R M) 1 = ↑(FiniteDimensional.finrank R M)


theorem of_comp
    (H : ∀ {R S T : Type u} [CommRing R] [CommRing S] [CommRing T],
      ∀ (f : R →+* S) (g : S →+* T), Q (g.comp f) → Q g)
    {X Y Z : Scheme.{u}} {f : X ⟶ Y} {g : Y ⟶ Z} (h : P (f ≫ g)) : P f

{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}

{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}

(H :
  ∀ {R S T : Type u} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] (f : R →+* S) (g : S →+* T),
    Q (g.comp f) → Q g)


theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s)

{ι : Type u_1}
(I : BoxIntegral.Box ι)
(s : Finset (ι × ℝ))


@[simp]
theorem opRingEquiv_symm_C (a : Rᵐᵒᵖ) : (opRingEquiv R).symm (C a) = op (C (unop a))

(Polynomial.opRingEquiv R).symm (Polynomial.C a) = MulOpposite.op (Polynomial.C (MulOpposite.unop a))


/-- Constructor for objects of the category `Functor.RightExtension L F`. -/
@[simps!]
def RightExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) :
    RightExtension L F

{C : Type u_1}
{H : Type u_3}
{D : Type u_5}
[CategoryTheory.Category.{u_7, u_1} C]
[CategoryTheory.Category.{u_8, u_3} H]
[CategoryTheory.Category.{u_9, u_5} D]
(F' : CategoryTheory.Functor D H)
{L : CategoryTheory.Functor C D}
{F : CategoryTheory.Functor C H}
(α : L.comp F' ⟶ F)

(CategoryTheory.Functor.RightExtension.mk F' α).hom = α


@[simp]
theorem coe_one : ↑ₘ(1 : SpecialLinearGroup n R) = (1 : Matrix n n R)

{n : Type u}
[DecidableEq n]
[Fintype n]
{R : Type v}
[CommRing R]


lemma contractible_distinguished (X : HomotopyCategory C (ComplexShape.up ℤ)) :
    Pretriangulated.contractibleTriangle X ∈ distinguishedTriangles C

CategoryTheory.Pretriangulated.contractibleTriangle X ∈ HomotopyCategory.Pretriangulated.distinguishedTriangles C


@[simp]
theorem integral_mul_const {𝕜 : Type*} [RCLike 𝕜] (r : 𝕜) (f : ℝ → 𝕜) :
    ∫ x in a..b, f x * r ∂μ = (∫ x in a..b, f x ∂μ) * r

{a b : ℝ}
{μ : MeasureTheory.Measure ℝ}
{𝕜 : Type u_6}
[RCLike 𝕜]
(r : 𝕜)
(f : ℝ → 𝕜)

∫ (x : ℝ) in a..b, f x * r ∂μ = (∫ (x : ℝ) in a..b, f x ∂μ) * r


/-- If `G` acts on `A`, then it acts also on `A → B`, by `(g • F) a = F (g⁻¹ • a)`. -/
@[to_additive (attr := simps) arrowAddAction
      "If `G` acts on `A`, then it acts also on `A → B`, by `(g +ᵥ F) a = F (g⁻¹ +ᵥ a)`"]
def arrowAction {G A B : Type*} [DivisionMonoid G] [MulAction G A] : MulAction G (A → B)

{G : Type u_4}
{A : Type u_5}
{B : Type u_6}
[SubtractionMonoid G]
[AddAction G A]
(g : G)
(F : A → B)
(a : A)


@[to_additive]
theorem Multipliable.sigma_factor {γ : β → Type*} {f : (Σb : β, γ b) → α}
    (ha : Multipliable f) (b : β) :
    Multipliable fun c ↦ f ⟨b, c⟩

{α : Type u_1}
{β : Type u_2}
[AddCommGroup α]
[UniformSpace α]
[UniformAddGroup α]
[CompleteSpace α]
{γ : β → Type u_5}
{f : (b : β) × γ b → α}
(ha : Summable f)
(b : β)


/-- Restriction of a monoid hom to a submonoid of the codomain. -/
@[to_additive (attr := simps apply)
  "Restriction of an `AddMonoid` hom to an `AddSubmonoid` of the codomain."]
def codRestrict {S} [SetLike S N] [SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ x, f x ∈ s) :
    M →* s

{M : Type u_1}
{N : Type u_2}
[AddZeroClass M]
[AddZeroClass N]
{S : Type u_6}
[SetLike S N]
[AddSubmonoidClass S N]
(f : M →+ N)
(s : S)
(h : ∀ (x : M), f x ∈ s)
(n : M)


/-- Constructor for `ComposableArrows C 0`. -/
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0

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

∀ {X_1 Y : Fin 1} (x : X_1 ⟶ Y), (CategoryTheory.ComposableArrows.mk₀ X).map x = CategoryTheory.CategoryStruct.id X


theorem sigmaFinite_of_le (μ : Measure α) [hs : SigmaFinite μ] (h : ν ≤ μ) : SigmaFinite ν

{α : Type u_1}
{m0 : MeasurableSpace α}
{ν : MeasureTheory.Measure α}
(μ : MeasureTheory.Measure α)
[hs : MeasureTheory.SigmaFinite μ]
(h : ν ≤ μ)


/-- The norm, relative to `ℤ`, of `ζ ^ p ^ s - 1` in a `p ^ (k + 1)`-th cyclotomic extension of `ℚ`
is p ^ p ^ s` if `s ≤ k` and `p ^ (k - s + 1) ≠ 2`. -/
lemma norm_toInteger_pow_sub_one_of_prime_pow_ne_two [IsCyclotomicExtension {p ^ (k + 1)} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))) {s : ℕ} (hs : s ≤ k) (htwo : p ^ (k - s + 1) ≠ 2) :
    Algebra.norm ℤ (hζ.toInteger ^ (p : ℕ) ^ s - 1) = p ^ (p : ℕ) ^ s

(Algebra.norm ℤ) (hζ.toInteger ^ ↑p ^ s - 1) = ↑↑p ^ ↑p ^ s


/-- `HasForget₂ C D`, where `C` and `D` are both concrete categories, provides a functor
`forget₂ C D : C ⥤ D` and a proof that `forget₂ ⋙ (forget D) = forget C`.
-/
class HasForget₂ (C : Type u) (D : Type u') [Category.{v} C] [ConcreteCategory.{w} C]
  [Category.{v'} D] [ConcreteCategory.{w} D] where
  /-- A functor from `C` to `D` -/
  forget₂ : C ⥤ D
  /-- It covers the `ConcreteCategory.forget` for `C` and `D` -/
  forget_comp : forget₂ ⋙ forget D = forget C := by aesop

{C : Type u}
{D : Type u'}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.ConcreteCategory C]
[CategoryTheory.Category.{v', u'} D]
[CategoryTheory.ConcreteCategory D]
[self : CategoryTheory.HasForget₂ C D]

CategoryTheory.HasForget₂.forget₂.comp (CategoryTheory.forget D) = CategoryTheory.forget C


/-- Euler's homogeneous function theorem. -/
theorem polynomial_relation (P : Fin 3 → R) : 3 * eval P W.polynomial =
    P x * eval P W.polynomialX + P y * eval P W.polynomialY + P z * eval P W.polynomialZ

{R : Type u}
[CommRing R]
(W : WeierstrassCurve.Projective R)
(P : Fin 3 → R)

3 * (MvPolynomial.eval P) W.polynomial =
  P 0 * (MvPolynomial.eval P) W.polynomialX + P 1 * (MvPolynomial.eval P) W.polynomialY +
    P 2 * (MvPolynomial.eval P) W.polynomialZ


theorem Indep.indep_restrict_of_subset (h : M.Indep I) (hIR : I ⊆ R) : (M ↾ R).Indep I

{α : Type u_1}
{M : Matroid α}
{R I : Set α}
(h : M.Indep I)
(hIR : I ⊆ R)


theorem odd_of_mod_four_eq_three {n : ℕ} : n % 4 = 3 → n % 2 = 1


theorem toDual_apply_left (m : M) (i : ι) : b.toDual m (b i) = b.repr m i

{R : Type uR}
{M : Type uM}
{ι : Type uι}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
[DecidableEq ι]
(b : Basis ι R M)
(m : M)
(i : ι)


/-- The sum of two `C^n`functions is `C^n`. -/
theorem ContDiff.add {f g : E → F} (hf : ContDiff 𝕜 n f) (hg : ContDiff 𝕜 n g) :
    ContDiff 𝕜 n fun x => f x + g x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{n : ℕ∞}
{f g : E → F}
(hf : ContDiff 𝕜 n f)
(hg : ContDiff 𝕜 n g)


theorem mk' (l : sq.LiftStruct) : HasLift sq

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


protected theorem lipschitz : LipschitzWith 1 f

{𝕜 : Type u_1}
{V : Type u_2}
{V₂ : Type u_5}
{P : Type u_10}
{P₂ : Type u_11}
[NormedField 𝕜]
[SeminormedAddCommGroup V]
[NormedSpace 𝕜 V]
[PseudoMetricSpace P]
[NormedAddTorsor V P]
[SeminormedAddCommGroup V₂]
[NormedSpace 𝕜 V₂]
[PseudoMetricSpace P₂]
[NormedAddTorsor V₂ P₂]
(f : P →ᵃⁱ[𝕜] P₂)


@[simp]
theorem contDiffAt_tan {n x} : ContDiffAt ℝ n tan x ↔ cos x ≠ 0

ContDiffAt ℝ n Real.tan x ↔ Real.cos x ≠ 0


theorem lt_length_left_of_zip {i : ℕ} {l : List α} {l' : List β} (h : i < (zip l l').length) :
    i < l.length

{α : Type u}
{β : Type u_1}
{i : ℕ}
{l : List α}
{l' : List β}
(h : i < (l.zip l').length)


@[to_additive (attr := simp) snd_comp_prod]
theorem snd_comp_prod (f : M →ₙ* N) (g : M →ₙ* P) : (snd N P).comp (f.prod g) = g

{M : Type u_5}
{N : Type u_6}
{P : Type u_7}
[Mul M]
[Mul N]
[Mul P]
(f : M →ₙ* N)
(g : M →ₙ* P)


/-- Conjugation by a fixed element is continuous when `mul` is continuous. -/
@[to_additive (attr := continuity)
  "Conjugation by a fixed element is continuous when `add` is continuous."]
theorem TopologicalGroup.continuous_conj (g : G) : Continuous fun h : G => g * h * g⁻¹

{G : Type w}
[TopologicalSpace G]
[Neg G]
[Add G]
[ContinuousAdd G]
(g : G)


lemma IsNilpotent.pow_of_pos {n} {S : Type*} [MonoidWithZero S] {x : S}
    (hx : IsNilpotent x) (hn : n ≠ 0) : IsNilpotent (x ^ n)

{n : ℕ}
{S : Type u_3}
[MonoidWithZero S]
{x : S}
(hx : IsNilpotent x)
(hn : n ≠ 0)


@[to_additive]
theorem isClosedMap_div_left (a : G) : IsClosedMap (a / ·)

{G : Type w}
[AddGroup G]
[TopologicalSpace G]
[TopologicalAddGroup G]
(a : G)


/-- Conjugation by a unit preserves the spectrum, inverse on right. -/
@[simp]
lemma spectrum.units_conjugate {a : A} {u : Aˣ} :
    spectrum R (u * a * u⁻¹) = spectrum R a

{R : Type u_1}
{A : Type u_2}
[CommSemiring R]
[Ring A]
[Algebra R A]
{a : A}
{u : Aˣ}

spectrum R (↑u * a * ↑u⁻¹) = spectrum R a


theorem zag_of_zag_obj (F : J ⥤ K) [F.Full] {j₁ j₂ : J} (h : Zag (F.obj j₁) (F.obj j₂)) :
    Zag j₁ j₂

(h : CategoryTheory.Zag (F.obj j₁) (F.obj j₂))


lemma map₂_coe_coe (f : α → β → γ) (a : α) (b : β) : map₂ f a b = f a b

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(f : α → β → γ)
(a : α)
(b : β)


@[simp]
theorem LinearEquiv.isometryOfInner_toLinearEquiv (f : E ≃ₗ[𝕜] E') (h) :
    (f.isometryOfInner h).toLinearEquiv = f

(h : ∀ (x y : E), ⟪f x, f y⟫_𝕜 = ⟪x, y⟫_𝕜)


theorem IsCompact.union (hs : IsCompact s) (ht : IsCompact t) : IsCompact (s ∪ t)

{X : Type u}
[TopologicalSpace X]
{s t : Set X}
(hs : IsCompact s)
(ht : IsCompact t)


lemma pairwiseDisjoint_range_iff {α β : Type*} {f : α → (Set β)} :
    (Set.range f).PairwiseDisjoint id ↔ ∀ x y, f x = f y ∨ Disjoint (f x) (f y)

{α : Type u_6}
{β : Type u_7}
{f : α → Set β}

(Set.range f).PairwiseDisjoint id ↔ ∀ (x y : α), f x = f y ∨ Disjoint (f x) (f y)


theorem condexpL1CLM_indicatorConst (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : F') :
    (condexpL1CLM F' hm μ) ↑(simpleFunc.indicatorConst 1 hs hμs x) = condexpInd F' hm μ s x

{α : Type u_1}
{F' : Type u_4}
[NormedAddCommGroup F']
[NormedSpace ℝ F']
[CompleteSpace F']
{m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{hm : m ≤ m0}
[MeasureTheory.SigmaFinite (μ.trim hm)]
{s : Set α}
(hs : MeasurableSet s)
(hμs : μ s ≠ ⊤)
(x : F')

(MeasureTheory.condexpL1CLM F' hm μ) ↑(MeasureTheory.Lp.simpleFunc.indicatorConst 1 hs hμs x) =
  (MeasureTheory.condexpInd F' hm μ s) x


lemma card_filter_le_iff (s : Multiset α) (P : α → Prop) [DecidablePred P] (n : ℕ) :
    card (s.filter P) ≤ n ↔ ∀ s' ≤ s, n < card s' → ∃ a ∈ s', ¬ P a

{α : Type u_1}
(s : Multiset α)
(P : α → Prop)
[DecidablePred P]
(n : ℕ)

Multiset.card (Multiset.filter P s) ≤ n ↔ ∀ s' ≤ s, n < Multiset.card s' → ∃ a ∈ s', ¬P a


theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter f l a ↔ IsMinFilter g l a

{α : Type u_1}
{β : Type u_2}
[Preorder β]
{f g : α → β}
{a : α}
{l : Filter α}
(heq : f =ᶠ[l] g)
(hfga : f a = g a)


@[simp]
theorem integral_const_mul {𝕜 : Type*} [RCLike 𝕜] (r : 𝕜) (f : ℝ → 𝕜) :
    ∫ x in a..b, r * f x ∂μ = r * ∫ x in a..b, f x ∂μ

{a b : ℝ}
{μ : MeasureTheory.Measure ℝ}
{𝕜 : Type u_6}
[RCLike 𝕜]
(r : 𝕜)
(f : ℝ → 𝕜)

∫ (x : ℝ) in a..b, r * f x ∂μ = r * ∫ (x : ℝ) in a..b, f x ∂μ


@[to_additive]
theorem IsOpen.exists_smul_mem [IsMinimal M α] (x : α) {U : Set α} (hUo : IsOpen U)
    (hne : U.Nonempty) : ∃ c : M, c • x ∈ U

(M : Type u_1)
{α : Type u_3}
[Monoid M]
[TopologicalSpace α]
[MulAction M α]
[MulAction.IsMinimal M α]
(x : α)
{U : Set α}
(hUo : IsOpen U)
(hne : U.Nonempty)


theorem hasFiniteIntegral_toReal_of_lintegral_ne_top {f : α → ℝ≥0∞} (hf : (∫⁻ x, f x ∂μ) ≠ ∞) :
    HasFiniteIntegral (fun x => (f x).toReal) μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : α → ℝ≥0∞}
(hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤)

MeasureTheory.HasFiniteIntegral (fun x => (f x).toReal) μ


lemma Measurable.imp (hp : Measurable p) (hq : Measurable q) : Measurable fun a ↦ p a → q a

{α : Type u_1}
[MeasurableSpace α]
{p q : α → Prop}
(hp : Measurable p)
(hq : Measurable q)


theorem BinaryCofan.isPullback_initial_to_of_isVanKampen [HasInitial C] {c : BinaryCofan X Y}
    (h : IsVanKampenColimit c) : IsPullback (initial.to _) (initial.to _) c.inl c.inr

{c : CategoryTheory.Limits.BinaryCofan X Y}

(h : CategoryTheory.IsVanKampenColimit c)

CategoryTheory.IsPullback
  (CategoryTheory.Limits.initial.to
    ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left }))
  (CategoryTheory.Limits.initial.to
    ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right }))
  c.inl c.inr


theorem inv_rpow (x : ℝ≥0∞) (y : ℝ) : x⁻¹ ^ y = (x ^ y)⁻¹


@[to_additive]
theorem UniformGroup.ext_iff {G : Type*} [Group G] {u v : UniformSpace G}
    (hu : @UniformGroup G u _) (hv : @UniformGroup G v _) :
    u = v ↔ @nhds _ u.toTopologicalSpace 1 = @nhds _ v.toTopologicalSpace 1

{G : Type u_3}
[Group G]
{u v : UniformSpace G}
(hu : UniformGroup G)
(hv : UniformGroup G)


theorem UniformContinuous.prod_map [UniformSpace δ] {f : α → γ} {g : β → δ}
    (hf : UniformContinuous f) (hg : UniformContinuous g) : UniformContinuous (Prod.map f g)

{α : Type ua}
{β : Type ub}
{γ : Type uc}
{δ : Type ud}
[UniformSpace α]
[UniformSpace β]
[UniformSpace γ]
[UniformSpace δ]
{f : α → γ}
{g : β → δ}
(hf : UniformContinuous f)
(hg : UniformContinuous g)


theorem unfold_smul {α} [AddCommMonoid α] (n) (x y : α)
    (h : smul n x = y) : n • x = y

{α : Type u_1}
[AddCommMonoid α]
(n : ℕ)
(x y : α)
(h : Mathlib.Tactic.Abel.smul n x = y)


lemma cfcHom_real_eq_restrict {a : A} (ha : IsSelfAdjoint a) :
    cfcHom ha = ha.spectrumRestricts.starAlgHom (cfcHom ha.isStarNormal) (f := Complex.reCLM)

cfcHom ha = SpectrumRestricts.starAlgHom (cfcHom ⋯) ⋯


/-- A topological space is called a *regular space* if for any closed set `s` and `a ∉ s`, there
exist disjoint open sets `U ⊇ s` and `V ∋ a`. We formulate this condition in terms of `Disjoint`ness
of filters `𝓝ˢ s` and `𝓝 a`. -/
@[mk_iff]
class RegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `a` is a point that does not belong to a closed set `s`, then `a` and `s` admit disjoint
  neighborhoods.  -/
  regular : ∀ {s : Set X} {a}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)

RegularSpace X ↔ ∀ {s : Set X} {a : X}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)


theorem liftPropWithinAt_congr (h : LiftPropWithinAt P g s x) (h₁ : ∀ y ∈ s, g' y = g y)
    (hx : g' x = g x) : LiftPropWithinAt P g' s x

(h : ChartedSpace.LiftPropWithinAt P g s x)


@[simp]
theorem coe_toElementaryEmbedding (f : M ≃[L] N) :
    (f.toElementaryEmbedding : M → N) = (f : M → N)

{L : FirstOrder.Language}
{M : Type u_1}
{N : Type u_2}
[L.Structure M]
[L.Structure N]
(f : M ≃[L] N)


theorem infinite_of_charZero (R A : Type*) [CommRing R] [IsDomain R] [Ring A] [Algebra R A]
    [CharZero A] : { x : A | IsAlgebraic R x }.Infinite

(R : Type u_1)
(A : Type u_2)
[CommRing R]
[IsDomain R]
[Ring A]
[Algebra R A]
[CharZero A]


protected theorem lt_tsub_iff_left_of_le (hc : AddLECancellable c) (h : c ≤ b) :
    a < b - c ↔ c + a < b

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


/-- If a function `f : α → ℝ≥0` is measurable and the measure is σ-finite, then there exists
spanning measurable sets with finite measure on which `f` is bounded.
See also `StronglyMeasurable.exists_spanning_measurableSet_norm_le` for functions into normed
groups. -/
theorem exists_spanning_measurableSet_le {m : MeasurableSpace α} {f : α → ℝ≥0}
    (hf : Measurable f) (μ : Measure α) [SigmaFinite μ] :
    ∃ s : ℕ → Set α,
      (∀ n, MeasurableSet (s n) ∧ μ (s n) < ∞ ∧ ∀ x ∈ s n, f x ≤ n) ∧
      ⋃ i, s i = Set.univ

{α : Type u_1}
{m : MeasurableSpace α}
{f : α → ℝ≥0}
(hf : Measurable f)
(μ : MeasureTheory.Measure α)
[MeasureTheory.SigmaFinite μ]

∃ s, (∀ (n : ℕ), MeasurableSet (s n) ∧ μ (s n) < ⊤ ∧ ∀ x ∈ s n, f x ≤ ↑n) ∧ ⋃ i, s i = Set.univ


@[to_additive (attr := simp)]
theorem inv_apply (μ : Measure G) (s : Set G) : μ.inv s = μ s⁻¹

{G : Type u_2}
[MeasurableSpace G]
[InvolutiveNeg G]
[MeasurableNeg G]
(μ : MeasureTheory.Measure G)
(s : Set G)


@[simp]
theorem coe_range (φ : A →ₐ[R] B) : (φ.range : Set B) = Set.range φ

{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[Semiring A]
[Algebra R A]
[Semiring B]
[Algebra R B]
(φ : A →ₐ[R] B)


/-- The left fraction in the opposite category corresponding to a right fraction. -/
@[simps]
def RightFraction.op {X Y : C} (φ : W.RightFraction X Y) :
    W.op.LeftFraction (Opposite.op Y) (Opposite.op X)

{C : Type u_1}
[CategoryTheory.Category.{u_3, u_1} C]
{W : CategoryTheory.MorphismProperty C}
{X Y : C}
(φ : W.RightFraction X Y)


theorem lift'_lift'_assoc {g : Set α → Set β} {h : Set β → Set γ} (hg : Monotone g)
    (hh : Monotone h) : (f.lift' g).lift' h = f.lift' fun s => h (g s)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{f : Filter α}
{g : Set α → Set β}
{h : Set β → Set γ}
(hg : Monotone g)
(hh : Monotone h)


@[simp]
theorem zeroth_conv_eq_h : g.convs 0 = g.h

{K : Type u_1}
{g : GenContFract K}
[DivisionRing K]


theorem take_one_drop_eq_of_lt_length {l : List α} {n : ℕ} (h : n < l.length) :
    (l.drop n).take 1 = [l.get ⟨n, h⟩]

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

List.take 1 (List.drop n l) = [l.get ⟨n, h⟩]


@[to_additive (attr := simp) nsmul_univ]
theorem univ_pow [Fintype α] (hn : n ≠ 0) : (univ : Finset α) ^ n = univ

{α : Type u_2}
[DecidableEq α]
[Monoid α]
{n : ℕ}
[Fintype α]
(hn : n ≠ 0)


theorem source_inter_preimage_target_inter (s : Set (B × F)) :
    e.source ∩ e ⁻¹' (e.target ∩ s) = e.source ∩ e ⁻¹' s

{B : Type u_2}
{F : Type u_3}
{Z : Type u_5}
[TopologicalSpace B]
[TopologicalSpace F]
{proj : Z → B}
[TopologicalSpace Z]
(e : Trivialization F proj)
(s : Set (B × F))

e.source ∩ ↑e ⁻¹' (e.target ∩ s) = e.source ∩ ↑e ⁻¹' s


/-- Relabellings preserve being numeric. -/
theorem Relabelling.numeric_congr {x y : PGame} (r : x ≡r y) : Numeric x ↔ Numeric y


theorem foldr_eq (f : Char → α → α) (s a) : foldr f a s = s.1.foldr f a

{α : Type u_1}
(f : Char → α → α)
(s : String)
(a : α)

String.foldr f a s = List.foldr f a s.data


theorem tr_eval_rev {σ₁ σ₂ f₁ f₂} {tr : σ₁ → σ₂ → Prop} (H : Respects f₁ f₂ tr) {a₁ b₂ a₂}
    (aa : tr a₁ a₂) (ab : b₂ ∈ eval f₂ a₂) : ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ eval f₁ a₁

{σ₁ : Type u_1}
{σ₂ : Type u_2}
{f₁ : σ₁ → Option σ₁}
{f₂ : σ₂ → Option σ₂}
{tr : σ₁ → σ₂ → Prop}
(H : Turing.Respects f₁ f₂ tr)
{a₁ : σ₁}
{b₂ a₂ : σ₂}
(aa : tr a₁ a₂)
(ab : b₂ ∈ Turing.eval f₂ a₂)


lemma ShortComplex.eq_liftCycles_homologyπ_up_to_refinements {A : C} (γ : A ⟶ S.homology) :
    ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (z : A' ⟶ S.X₂) (hz : z ≫ S.g = 0),
      π ≫ γ = S.liftCycles z hz ≫ S.homologyπ

{C : Type u_2}
[CategoryTheory.Category.{u_1, u_2} C]
[CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C}
{A : C}
(γ : A ⟶ S.homology)

∃ A' π,
  ∃ (_ : CategoryTheory.Epi π),
    ∃ z,
      ∃ (hz : CategoryTheory.CategoryStruct.comp z S.g = 0),
        CategoryTheory.CategoryStruct.comp π γ = CategoryTheory.CategoryStruct.comp (S.liftCycles z hz) S.homologyπ


theorem finite_of_finite_mul_right {a b c : α} : Finite a (b * c) → Finite a b

multiplicity.Finite a (b * c) → multiplicity.Finite a b


@[to_additive (attr := simp)]
theorem mulRothNumber_singleton (a : α) : mulRothNumber ({a} : Finset α) = 1

{α : Type u_2}
[DecidableEq α]
[Monoid α]
(a : α)


/-- Bijection between a subring `S` and `MulOpposite` of its opposite. -/
@[simps!]
def ringEquivOpMop (S : Subring R) : S ≃+* (S.op)ᵐᵒᵖ

∀ (a : ↥S.toSubsemiring), S.ringEquivOpMop a = MulOpposite.op (S.addEquivOp a)


@[simp]
lemma toMvPolynomial_one [DecidableEq n] : (1 : Matrix n n R).toMvPolynomial = X

{n : Type u_2}
{R : Type u_4}
[Fintype n]
[CommSemiring R]
[DecidableEq n]

Matrix.toMvPolynomial 1 = MvPolynomial.X


protected theorem neg_neg_of_pos {a : Int} (h : 0 < a) : -a < 0


@[to_additive]
theorem subset_interior_mul_left : interior s * t ⊆ interior (s * t)

{α : Type u}
[TopologicalSpace α]
[Group α]
[ContinuousConstSMul αᵐᵒᵖ α]
{s t : Set α}


/-- A homomorphism between isocrystals respects the Frobenius map. -/
-- Porting note(#5171): this linter isn't ported yet. @[nolint has_nonempty_instance]
structure IsocrystalHom extends V →ₗ[K(p, k)] V₂ where
  frob_equivariant : ∀ x : V, Φ(p, k) (toLinearMap x) = toLinearMap (Φ(p, k) x)

(self : WittVector.IsocrystalHom p k V V₂)

(WittVector.Isocrystal.frobenius p k) (self.toLinearMap x) = self.toLinearMap ((WittVector.Isocrystal.frobenius p k) x)


theorem sups_union_right : s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂

{α : Type u_2}
[DecidableEq α]
[SemilatticeSup α]
{s t₁ t₂ : Finset α}


@[simp]
theorem setOf_eq_eq_singleton {a : α} : { n | n = a } = {a}


theorem Ioi_def (a : α) : { x | a < x } = Ioi a


theorem prod_mono_right : t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]
{s : LowerSet α}
{t₁ t₂ : LowerSet β}

t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂


lemma mem_quasispectrum_iff {R A : Type*} [Semifield R] [Ring A]
    [Algebra R A] {a : A} {x : R} :
    x ∈ quasispectrum R a ↔ x = 0 ∨ x ∈ spectrum R a

{R : Type u_3}
{A : Type u_4}
[Semifield R]
[Ring A]
[Algebra R A]
{a : A}
{x : R}


@[simp]
theorem dual_comp (g : TopHom β γ) (f : TopHom α β) :
    TopHom.dual (g.comp f) = g.dual.comp (TopHom.dual f)

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[LE α]
[OrderTop α]
[LE β]
[OrderTop β]
[LE γ]
[OrderTop γ]
(g : TopHom β γ)
(f : TopHom α β)

TopHom.dual (g.comp f) = (TopHom.dual g).comp (TopHom.dual f)


/-- A non-cyclic multiplicative group is non-trivial. -/
@[to_additive "A non-cyclic additive group is non-trivial."]
theorem Nontrivial.of_not_isCyclic (nc : ¬IsCyclic α) : Nontrivial α

{α : Type u}
[Group α]
(nc : ¬IsCyclic α)


theorem stereographic_apply (hv : ‖v‖ = 1) (x : sphere (0 : E) 1) :
    stereographic hv x = (2 / ((1 : ℝ) - inner v x)) • orthogonalProjection (ℝ ∙ v)ᗮ x

{E : Type u_1}
[NormedAddCommGroup E]
[InnerProductSpace ℝ E]
{v : E}
(hv : ‖v‖ = 1)
(x : ↑(Metric.sphere 0 1))

↑(stereographic hv) x = (2 / (1 - ⟪v, ↑x⟫_ℝ)) • (orthogonalProjection (Submodule.span ℝ {v})ᗮ) ↑x


/-- A vector added to the first point lies in the affine span of two points if and only if it is
a multiple of their difference. -/
theorem vadd_left_mem_affineSpan_pair {p₁ p₂ : P} {v : V} :
    v +ᵥ p₁ ∈ line[k, p₁, p₂] ↔ ∃ r : k, r • (p₂ -ᵥ p₁) = v

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{p₁ p₂ : P}
{v : V}

v +ᵥ p₁ ∈ affineSpan k {p₁, p₂} ↔ ∃ r, r • (p₂ -ᵥ p₁) = v


theorem span_singleton_mul_le_span_singleton_mul {x y : R} {I J : Ideal R} :
    span {x} * I ≤ span {y} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ

{R : Type u}
[CommSemiring R]
{x y : R}
{I J : Ideal R}

Ideal.span {x} * I ≤ Ideal.span {y} * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ


@[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
lemma all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l) : x = 1

{M : Type u_3}
[OrderedCommMonoid M]
{l : List M}
(hl₁ : ∀ x ∈ l, 1 ≤ x)
(hl₂ : l.prod = 1)
{x : M}
(hx : x ∈ l)


@[simp]
theorem lTensor_comp_map (g' : Q →ₗ[R] S) (f : M →ₗ[R] P) (g : N →ₗ[R] Q) :
    (g'.lTensor _).comp (map f g) = map f (g'.comp g)

{R : Type u_1}
[CommSemiring R]
(M : Type u_4)
{N : Type u_5}
{P : Type u_6}
{Q : Type u_7}
{S : Type u_8}
[AddCommMonoid M]
[AddCommMonoid N]
[AddCommMonoid P]
[AddCommMonoid Q]
[AddCommMonoid S]
[Module R M]
[Module R N]
[Module R P]
[Module R Q]
[Module R S]
(g' : Q →ₗ[R] S)
(f : M →ₗ[R] P)
(g : N →ₗ[R] Q)

LinearMap.lTensor P g' ∘ₗ TensorProduct.map f g = TensorProduct.map f (g' ∘ₗ g)


theorem subsingleton_of_rank_adjoin_eq_one (h : ∀ x : E, Module.rank F F⟮x⟯ = 1) :
    Subsingleton (IntermediateField F E)

(h : ∀ (x : E), Module.rank F ↥F⟮x⟯ = 1)


@[to_additive]
theorem Dense.smul (c : G) {s : Set α} (hs : Dense s) : Dense (c • s)

{α : Type u_2}
{G : Type u_4}
[TopologicalSpace α]
[AddGroup G]
[AddAction G α]
[ContinuousConstVAdd G α]
(c : G)
{s : Set α}
(hs : Dense s)


@[reassoc, simp]
theorem whisker_assoc (X : C) {Y Y' : C} (f : Y ⟶ Y') (Z : C) :
    (X ◁ f) ▷ Z = (α_ X Y Z).hom ≫ X ◁ f ▷ Z ≫ (α_ X Y' Z).inv

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

CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.whiskerLeft X f) Z =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.whiskerRight f Z))
      (CategoryTheory.MonoidalCategory.associator X Y' Z).inv)


theorem zero_apply (a : A) : (0 : A →⋆ₙₐ[R] B) a = 0

{R : Type u_1}
{A : Type u_2}
{B : Type u_3}
[Monoid R]
[NonUnitalNonAssocSemiring A]
[DistribMulAction R A]
[StarAddMonoid A]
[NonUnitalNonAssocSemiring B]
[DistribMulAction R B]
[StarAddMonoid B]
(a : A)


theorem eval_sum {ι : Type*} (s : Finset ι) (f : ι → MvPolynomial σ R) (g : σ → R) :
    eval g (∑ i ∈ s, f i) = ∑ i ∈ s, eval g (f i)

{R : Type u}
{σ : Type u_1}
[CommSemiring R]
{ι : Type u_2}
(s : Finset ι)
(f : ι → MvPolynomial σ R)
(g : σ → R)

(MvPolynomial.eval g) (∑ i ∈ s, f i) = ∑ i ∈ s, (MvPolynomial.eval g) (f i)


protected theorem injective [DecidableEq α] (f : InjectiveFunction α) : Injective (apply f)

{α : Type u}
[DecidableEq α]
(f : SlimCheck.InjectiveFunction α)


lemma isIso_unit_of_iso  (adj : L ⊣ R) (i : L ⋙ R ≅ 𝟭 C) : IsIso adj.unit

(i : L.comp R ≅ CategoryTheory.Functor.id C)


@[reassoc (attr := simp)]
lemma colimitCoconeιApp_naturality {i j : J} (f : i ⟶ j) :
    F.map f ≫ colimitCoconeιApp F j = colimitCoconeιApp F i

[{X Y : Cᵒᵖ} →
    (f : X ⟶ Y) →
      CategoryTheory.Limits.PreservesColimit (F ⋙ PresheafOfModules.evaluation R Y)
        (ModuleCat.restrictScalars (R.map f))]

[∀ (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (F ⋙ PresheafOfModules.evaluation R X)]

F.map f ≫ PresheafOfModules.colimitCoconeιApp F j = PresheafOfModules.colimitCoconeιApp F i


theorem restrict_le_restrict_subset {i j : Set α} (hi₁ : MeasurableSet i) (hi₂ : v ≤[i] w)
    (hij : j ⊆ i) : v ≤[j] w

{α : Type u_1}
{m : MeasurableSpace α}
{M : Type u_3}
[TopologicalSpace M]
[AddCommMonoid M]
[PartialOrder M]
(v w : MeasureTheory.VectorMeasure α M)
{i j : Set α}
(hi₁ : MeasurableSet i)
(hi₂ : v.restrict i ≤ w.restrict i)
(hij : j ⊆ i)


@[to_additive (attr := simp)]
theorem map_id (h : N ≤ Subgroup.comap (MonoidHom.id _) N := (Subgroup.comap_id N).le) :
    map N N (MonoidHom.id _) h = MonoidHom.id _

(h : N ≤ AddSubgroup.comap (AddMonoidHom.id G) N := ⋯)

QuotientAddGroup.map N N (AddMonoidHom.id G) h = AddMonoidHom.id (G ⧸ N)


lemma eq_affineLocally : P = affineLocally Q

(P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme)

{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}

P = AlgebraicGeometry.affineLocally fun {R S} [CommRing R] [CommRing S] => Q


@[simp]
theorem cons_bind : (a ::ₘ s).bind f = f a + s.bind f

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


/-- Automorphization of a function into an `R`-`Module` distributes, that is, commutes with the
`R`-scalar multiplication. -/
lemma MulAction.automorphize_smul_left [Group α] [MulAction α β] (f : β → M)
    (g : Quotient (MulAction.orbitRel α β) → R) :
    MulAction.automorphize ((g ∘ (@Quotient.mk' _ (_))) • f)
      = g • (MulAction.automorphize f : Quotient (MulAction.orbitRel α β) → M)

MulAction.automorphize (g ∘ Quotient.mk' • f) = g • MulAction.automorphize f


theorem mk_quot_out [Monoid α] (a : α) : Quot.out (Associates.mk a) ~ᵤ a


theorem hom_C (f : MvPolynomial σ ℤ →+* S) (n : ℤ) : f (C n) = (n : S)

{S : Type v}
{σ : Type u_1}
[CommRing S]
(f : MvPolynomial σ ℤ →+* S)
(n : ℤ)


theorem LinearIndependent.subset_span_extend (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : t ⊆ span K (hs.extend hst)

(hs : LinearIndependent K fun (x : ↑s) => ↑x)


/-- Convert a `BinaryBicone` into a `Bicone` over a pair. -/
@[simps]
def toBiconeFunctor {X Y : C} : BinaryBicone X Y ⥤ Bicone (pairFunction X Y)

(b : CategoryTheory.Limits.BinaryBicone X Y)

(CategoryTheory.Limits.BinaryBicone.toBiconeFunctor.obj b).π j = CategoryTheory.Limits.WalkingPair.casesOn j b.fst b.snd


@[simp]
theorem Matrix.toLin_self (M : Matrix m n R) (i : n) :
    Matrix.toLin v₁ v₂ M (v₁ i) = ∑ j, M j i • v₂ j

{R : Type u_1}
[CommSemiring R]
{m : Type u_3}
{n : Type u_4}
[Fintype n]
[Fintype m]
[DecidableEq n]
{M₁ : Type u_5}
{M₂ : Type u_6}
[AddCommMonoid M₁]
[AddCommMonoid M₂]
[Module R M₁]
[Module R M₂]
(v₁ : Basis n R M₁)
(v₂ : Basis m R M₂)
(M : Matrix m n R)
(i : n)

((Matrix.toLin v₁ v₂) M) (v₁ i) = ∑ j : m, M j i • v₂ j


@[to_additive]
theorem image_mul : (s * t).image (f : α → β) = s.image f * t.image f

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[DecidableEq α]
[DecidableEq β]
[Mul α]
[Mul β]
[FunLike F α β]
[MulHomClass F α β]
(f : F)
{s t : Finset α}

Finset.image (⇑f) (s * t) = Finset.image (⇑f) s * Finset.image (⇑f) t


/-- Construct a unit from limits of units and their inverses. -/
@[to_additive (attr := simps)
  "Construct an additive unit from limits of additive units and their negatives."]
def Filter.Tendsto.units [TopologicalSpace N] [Monoid N] [ContinuousMul N] [T2Space N]
    {f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [l.NeBot] (h₁ : Tendsto (fun x => ↑(f x)) l (𝓝 r₁))
    (h₂ : Tendsto (fun x => ↑(f x)⁻¹) l (𝓝 r₂)) : Nˣ

(h₁ : Filter.Tendsto (fun x => ↑(f x)) l (𝓝 r₁))

(h₂ : Filter.Tendsto (fun x => ↑(f x)⁻¹) l (𝓝 r₂))


theorem condexpIndL1_of_measure_eq_top (hμs : μ s = ∞) (x : G) : condexpIndL1 hm μ s x = 0

{α : Type u_1}
{G : Type u_5}
[NormedAddCommGroup G]
{m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{s : Set α}
[NormedSpace ℝ G]
{hm : m ≤ m0}
[MeasureTheory.SigmaFinite (μ.trim hm)]
(hμs : μ s = ⊤)
(x : G)


/-- Congruence relation of a ring preserves finite sum indexed by a multiset. -/
protected lemma multisetSum {ι S : Type*} [AddCommMonoid S] [Mul S] (t : RingCon S)
    (s : Multiset ι) {f g : ι → S} (h : ∀ i ∈ s, t (f i) (g i)) :
    t (s.map f).sum (s.map g).sum

{ι : Type u_1}
{S : Type u_2}
[AddCommMonoid S]
[Mul S]
(t : RingCon S)
(s : Multiset ι)
{f g : ι → S}
(h : ∀ i ∈ s, t (f i) (g i))

t (Multiset.map f s).sum (Multiset.map g s).sum


theorem Eventually.curry {la : Filter α} {lb : Filter β} {p : α × β → Prop}
    (h : ∀ᶠ x in la ×ˢ lb, p x) : ∀ᶠ x in la, ∀ᶠ y in lb, p (x, y)

{α : Type u_1}
{β : Type u_2}
{la : Filter α}
{lb : Filter β}
{p : α × β → Prop}
(h : ∀ᶠ (x : α × β) in la ×ˢ lb, p x)

∀ᶠ (x : α) in la, ∀ᶠ (y : β) in lb, p (x, y)


@[simp]
theorem inter_compl_self (s : Set α) : s ∩ sᶜ = ∅


@[to_additive]
lemma ite_lt_one [LT α] (ha : a < 1) (hb : b < 1) : ite p a b < 1

{α : Type u_2}
[One α]
{p : Prop}
[Decidable p]
{a b : α}
[LT α]
(ha : a < 1)
(hb : b < 1)


theorem gameAdd_swap_swap_mk (a₁ a₂ : α) (b₁ b₂ : β) :
    GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ GameAdd rβ rα (b₁, a₁) (b₂, a₂)

{α : Type u_1}
{β : Type u_2}
(rα : α → α → Prop)
(rβ : β → β → Prop)
(a₁ a₂ : α)
(b₁ b₂ : β)

Prod.GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ Prod.GameAdd rβ rα (b₁, a₁) (b₂, a₂)


theorem encard_mono {α : Type*} : Monotone (encard : Set α → ℕ∞)


theorem pdf_eq {X : Ω → E} {s : Set E} (hms : MeasurableSet s)
    (hu : IsUniform X s ℙ μ) : pdf X ℙ μ =ᵐ[μ] s.indicator ((μ s)⁻¹ • (1 : E → ℝ≥0∞))

{E : Type u_1}
[MeasurableSpace E]
{μ : MeasureTheory.Measure E}
{Ω : Type u_2}

∀ {x : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω} {X : Ω → E} {s : Set E},
  MeasurableSet s → MeasureTheory.pdf.IsUniform X s ℙ μ → MeasureTheory.pdf X ℙ μ =ᵐ[μ] s.indicator ((μ s)⁻¹ • 1)


/-- **Chernoff bound** on the lower tail of a real random variable. -/
theorem measure_le_le_exp_cgf [IsFiniteMeasure μ] (ε : ℝ) (ht : t ≤ 0)
    (h_int : Integrable (fun ω => exp (t * X ω)) μ) :
    (μ {ω | X ω ≤ ε}).toReal ≤ exp (-t * ε + cgf X μ t)

(h_int : MeasureTheory.Integrable (fun ω => rexp (t * X ω)) μ)

(μ {ω | X ω ≤ ε}).toReal ≤ rexp (-t * ε + ProbabilityTheory.cgf X μ t)


lemma vsub.instNeBot [NeBot f] [NeBot g] : NeBot (f -ᵥ g)

{α : Type u_2}
{β : Type u_3}
[VSub α β]
{f g : Filter β}
[f.NeBot]
[g.NeBot]


/-- The centroid of a face of a simplex as the centroid of a subset of
the points. -/
@[simp]
theorem face_centroid_eq_centroid {n : ℕ} (s : Simplex k P n) {fs : Finset (Fin (n + 1))} {m : ℕ}
    (h : fs.card = m + 1) : Finset.univ.centroid k (s.face h).points = fs.centroid k s.points

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[DivisionRing k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{n : ℕ}
(s : Affine.Simplex k P n)
{fs : Finset (Fin (n + 1))}
{m : ℕ}
(h : fs.card = m + 1)

Finset.centroid k Finset.univ (s.face h).points = Finset.centroid k fs s.points


@[simp] lemma zero_ssubset : 0 ⊂ s ↔ s ≠ 0


/-- A functor `G : C ⥤ D` sends bicones over `F` to bicones over `G.obj ∘ F` functorially. -/
@[simps]
def functoriality (G : C ⥤ D) [Functor.PreservesZeroMorphisms G] :
    Bicone F ⥤ Bicone (G.obj ∘ F)

((CategoryTheory.Limits.Bicones.functoriality F G).obj A).ι j = G.map (A.ι j)


lemma diffs_inter_subset_right : s \\ (t₁ ∩ t₂) ⊆ s \\ t₁ ∩ s \\ t₂

{α : Type u_2}
[DecidableEq α]
[GeneralizedBooleanAlgebra α]
{s t₁ t₂ : Finset α}

s.diffs (t₁ ∩ t₂) ⊆ s.diffs t₁ ∩ s.diffs t₂


lemma UniformConvexOn.sub (hf : UniformConvexOn s φ f) (hg : UniformConcaveOn s ψ g) :
    UniformConvexOn s (φ + ψ) (f - g)

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{φ ψ : ℝ → ℝ}
{s : Set E}
{f g : E → ℝ}
(hf : UniformConvexOn s φ f)
(hg : UniformConcaveOn s ψ g)


lemma Odd.sub_even (h : n ≤ m) (hm : Odd m) (hn : Even n) : Odd (m - n)

{m n : ℕ}
(h : n ≤ m)
(hm : Odd m)
(hn : Even n)


/-- The isomorphism between `P⁺ ⋙ F` and `(P ⋙ F)⁺`, functorially in `P`. -/
@[simps! hom_app inv_app]
def plusFunctorWhiskerRightIso :
    J.plusFunctor D ⋙ (whiskeringRight _ _ _).obj F ≅
      (whiskeringRight _ _ _).obj F ⋙ J.plusFunctor E

(J : CategoryTheory.GrothendieckTopology C)

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

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

[∀ (α β : Type (max v u)) (fst snd : β → α),
    CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan fst snd) D]

[∀ (α β : Type (max v u)) (fst snd : β → α),
    CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan fst snd) E]

[(X : C) →
    (W : J.Cover X) →
      (P : CategoryTheory.Functor Cᵒᵖ D) → CategoryTheory.Limits.PreservesLimit (W.index P).multicospan F]

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

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

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

(J.plusFunctorWhiskerRightIso F).hom.app X = (J.plusCompIso F X).hom


/-- The empty word -/
@[simps]
def empty : NormalWord d

{d : HNNExtension.NormalWord.TransversalPair G A B}


/-- A helper lemma: the characteristic is prime if it is non-zero. -/
theorem char_prime_of_ne_zero {p : ℕ} [hp : CharP R p] (p_ne_zero : p ≠ 0) : Nat.Prime p

(R : Type u)
[Semiring R]
[Nontrivial R]
[NoZeroDivisors R]
{p : ℕ}
[hp : CharP R p]
(p_ne_zero : p ≠ 0)


lemma not_disjoint_iff : ¬Disjoint s t ↔ ∃ x, x ∈ s ∧ x ∈ t


private theorem mul_comm : ∀ (a b : ZNum), a * b = b * a


theorem ofMeasurableSpace_le_ofMeasurableSpace_iff {m₁ m₂ : MeasurableSpace α} :
    ofMeasurableSpace m₁ ≤ ofMeasurableSpace m₂ ↔ m₁ ≤ m₂

{α : Type u_1}
{m₁ m₂ : MeasurableSpace α}

MeasurableSpace.DynkinSystem.ofMeasurableSpace m₁ ≤ MeasurableSpace.DynkinSystem.ofMeasurableSpace m₂ ↔ m₁ ≤ m₂


theorem RightInverse.prodMap :
    RightInverse f₁ f₂ → RightInverse g₁ g₂ → RightInverse (map f₁ g₁) (map f₂ g₂)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}
{f₁ : α → β}
{g₁ : γ → δ}
{f₂ : β → α}
{g₂ : δ → γ}

Function.RightInverse f₁ f₂ → Function.RightInverse g₁ g₂ → Function.RightInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂)


@[to_additive (attr := simp)]
theorem ker_restrict (f : G →* N) : (f.restrict K).ker = f.ker.subgroupOf K

{G : Type u_1}
[AddGroup G]
{N : Type u_5}
[AddGroup N]
(K : AddSubgroup G)
(f : G →+ N)

(f.restrict K).ker = f.ker.addSubgroupOf K


theorem div_zero (h : a ≠ 0) : a / 0 = ∞


/-- The Law of Quadratic Reciprocity for the Jacobi symbol -/
theorem quadratic_reciprocity {a b : ℕ} (ha : Odd a) (hb : Odd b) :
    J(a | b) = (-1) ^ (a / 2 * (b / 2)) * J(b | a)

jacobiSym (↑a) b = (-1) ^ (a / 2 * (b / 2)) * jacobiSym (↑b) a


lemma coe_restrictScalars' (f : A →ₙₐ[S] B) : (f.restrictScalars R : A → B) = f

(R : Type u_1)
{S : Type u_2}
{A : Type u_3}
{B : Type u_4}
[Monoid R]
[Monoid S]
[NonUnitalNonAssocSemiring A]
[NonUnitalNonAssocSemiring B]
[MulAction R S]
[DistribMulAction S A]
[DistribMulAction S B]
[DistribMulAction R A]
[DistribMulAction R B]
[IsScalarTower R S A]
[IsScalarTower R S B]
(f : A →ₙₐ[S] B)

⇑(NonUnitalAlgHom.restrictScalars R f) = ⇑f


theorem isGLB_of_u_image [Preorder α] [Preorder β] (gi : GaloisInsertion l u) {s : Set β} {a : α}
    (hs : IsGLB (u '' s) a) : IsGLB s (l a)

{α : Type u}
{β : Type v}
{l : α → β}
{u : β → α}
[Preorder α]
[Preorder β]
(gi : GaloisInsertion l u)
{s : Set β}
{a : α}
(hs : IsGLB (u '' s) a)


/-- If `(⊥ : SubAlgebra A B) = ⊤`, then `IsCyclotomicExtension ∅ A B`. -/
theorem singleton_zero_of_bot_eq_top (h : (⊥ : Subalgebra A B) = ⊤) :
    IsCyclotomicExtension ∅ A B

{A : Type u}
{B : Type v}
[CommRing A]
[CommRing B]
[Algebra A B]
(h : ⊥ = ⊤)


@[to_additive (attr := simp)]
theorem Units.coe_opEquiv_symm {M} [Monoid M] (u : Mˣᵐᵒᵖ) :
    (Units.opEquiv.symm u : Mᵐᵒᵖ) = op (u.unop : M)

{M : Type u_2}
[AddMonoid M]
(u : (AddUnits M)ᵃᵒᵖ)

↑(AddUnits.opEquiv.symm u) = AddOpposite.op ↑(AddOpposite.unop u)


lemma zsmul (hxy : x ≡ y [SMOD U]) (n : ℤ) : n • x ≡ n • y [SMOD U]

{R : Type u_1}
[Ring R]
{M : Type u_3}
[AddCommGroup M]
[Module R M]
{U : Submodule R M}
{x y : M}
(hxy : x ≡ y [SMOD U])
(n : ℤ)


theorem dfinsupp_sumAddHom_apply [AddZeroClass R] [AddCommMonoid S] [∀ i, AddZeroClass (β i)]
    (f : Π₀ i, β i) (g : ∀ i, β i →+ R →+ S) (r : R) :
    (sumAddHom g f) r = sumAddHom (fun i => (eval r).comp (g i)) f

{ι : Type u}
{β : ι → Type v}
[DecidableEq ι]
{R : Type u_1}
{S : Type u_2}
[AddZeroClass R]
[AddCommMonoid S]
[(i : ι) → AddZeroClass (β i)]
(f : Π₀ (i : ι), β i)
(g : (i : ι) → β i →+ R →+ S)
(r : R)

((DFinsupp.sumAddHom g) f) r = (DFinsupp.sumAddHom fun i => (AddMonoidHom.eval r).comp (g i)) f


/-- Evaluation of functions into an indexed collection of monoids at a point is a monoid
homomorphism.
This is `Function.eval i` as a `MonoidHom`. -/
@[to_additive (attr := simps) "Evaluation of functions into an indexed collection of additive
monoids at a point is an additive monoid homomorphism. This is `Function.eval i` as an
`AddMonoidHom`."]
def Pi.evalMonoidHom (i : I) : (∀ i, f i) →* f i

{I : Type u}
(f : I → Type v)
[(i : I) → AddZeroClass (f i)]
(i : I)
(g : (i : I) → f i)


theorem eq_univ_iff_forall {A : Class.{u}} : A = univ ↔ ∀ x : ZFSet, A x


@[simp, mfld_simps]
theorem refl_source : (PartialEquiv.refl α).source = univ


theorem IsTopologicalBasis.exists_nonempty_subset {B : Set (Set α)} (hb : IsTopologicalBasis B)
    {u : Set α} (hu : u.Nonempty) (ou : IsOpen u) : ∃ v ∈ B, Set.Nonempty v ∧ v ⊆ u

(hb : TopologicalSpace.IsTopologicalBasis B)


/-- A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. -/
class IsCoxeterGroup.{u} (W : Type u) [Group W] : Prop where
  nonempty_system : ∃ B : Type u, ∃ M : CoxeterMatrix B, Nonempty (CoxeterSystem M W)

{W : Type u}
[Group W]
[self : IsCoxeterGroup W]


@[to_additive]
theorem not_mem_bot {x : M} : x ∉ (⊥ : Subsemigroup M)


theorem sqrtTwoAddSeries_lt_two : ∀ n : ℕ, sqrtTwoAddSeries 0 n < 2


@[to_additive (attr := simp)]
lemma toFun_apply (x : M) (y : α) : MulAction.toFun M α y x = x • y

{M : Type u_1}
{α : Type u_7}
[AddMonoid M]
[AddAction M α]
(x : M)
(y : α)


theorem zip_inits_tails (s : Stream' α) : zip appendStream' (inits s) (tails s) = const s

Stream'.zip Stream'.appendStream' s.inits s.tails = Stream'.const s


theorem differentiableOn_id' : DifferentiableOn K (fun x : E => x) s

{K : Type u_1}
[NontriviallyNormedField K]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace K E]
{s : Set E}


lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h
    shiftFunctorZero C A = h.zero

{C : Type u}
{A : Type u_1}
[CategoryTheory.Category.{v, u} C]
[AddMonoid A]
(h : CategoryTheory.ShiftMkCore C A)

CategoryTheory.shiftFunctorZero C A = h.zero


@[simp]
theorem mulLeft_toAddMonoidHom (a : A) : (mulLeft R a : A →+ A) = AddMonoidHom.mulLeft a

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

↑(LinearMap.mulLeft R a) = AddMonoidHom.mulLeft a


@[simp] protected theorem min_eq_and : min = and


/-- A bicategory is called `Strict` if the left unitors, the right unitors, and the associators are
isomorphisms given by equalities.
-/
class Bicategory.Strict : Prop where
  /-- Identity morphisms are left identities for composition. -/
  id_comp : ∀ {a b : B} (f : a ⟶ b), 𝟙 a ≫ f = f := by aesop_cat
  /-- Identity morphisms are right identities for composition. -/
  comp_id : ∀ {a b : B} (f : a ⟶ b), f ≫ 𝟙 b = f := by aesop_cat
  /-- Composition in a bicategory is associative. -/
  assoc : ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d), (f ≫ g) ≫ h = f ≫ g ≫ h := by
    aesop_cat
  /-- The left unitors are given by equalities -/
  leftUnitor_eqToIso : ∀ {a b : B} (f : a ⟶ b), λ_ f = eqToIso (id_comp f) := by aesop_cat
  /-- The right unitors are given by equalities -/
  rightUnitor_eqToIso : ∀ {a b : B} (f : a ⟶ b), ρ_ f = eqToIso (comp_id f) := by aesop_cat
  /-- The associators are given by equalities -/
  associator_eqToIso :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d), α_ f g h = eqToIso (assoc f g h) := by
    aesop_cat

[self : CategoryTheory.Bicategory.Strict B]

CategoryTheory.Bicategory.rightUnitor f = CategoryTheory.eqToIso ⋯


theorem acc_antisymmetrization_iff : Acc (· < ·)
    (@toAntisymmetrization α (· ≤ ·) _ a) ↔ Acc (· < ·) a

Acc (fun x x_1 => x < x_1) (toAntisymmetrization (fun x x_1 => x ≤ x_1) a) ↔ Acc (fun x x_1 => x < x_1) a


/-- Formula for `completedCosZeta` as a Dirichlet series in the convergence range
(first version, with sum over `ℤ`). -/
lemma hasSum_int_completedCosZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ Gammaℝ s * cexp (2 * π * I * a * n) / (↑|n| : ℂ) ^ s / 2)
    (completedCosZeta a s)

HasSum (fun n => s.Gammaℝ * cexp (2 * ↑π * Complex.I * ↑a * ↑n) / ↑|n| ^ s / 2) (HurwitzZeta.completedCosZeta (↑a) s)


theorem CPolynomialAt.exists_mem_nhds_cPolynomialOn {f : E → F} {x : E} (h : CPolynomialAt 𝕜 f x) :
    ∃ s ∈ 𝓝 x, CPolynomialOn 𝕜 f s

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


/-- The `Submodule.LinearDisjoint.rank_inf_le_one_of_commute_of_flat_left`
for commutative rings. -/
theorem rank_inf_le_one_of_flat_left [Module.Flat R M] : Module.rank R ↥(M ⊓ N) ≤ 1

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
{M N : Submodule R S}
(H : M.LinearDisjoint N)
[Module.Flat R ↥M]


@[local simp] theorem neg_negSucc (n : Nat) : -(-[n+1]) = succ n


theorem exists_seq_forall_of_frequently {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] (h : ∃ᶠ n in l, p n) :
    ∃ ns : ℕ → ι, Tendsto ns atTop l ∧ ∀ n, p (ns n)

{ι : Type u_6}
{l : Filter ι}
{p : ι → Prop}
[l.IsCountablyGenerated]
(h : ∃ᶠ (n : ι) in l, p n)

∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n)


theorem lTensor_id_apply (x : M ⊗[R] N) : (LinearMap.id : N →ₗ[R] N).lTensor M x = x

{R : Type u_1}
[CommSemiring R]
(M : Type u_4)
(N : Type u_5)
[AddCommMonoid M]
[AddCommMonoid N]
[Module R M]
[Module R N]
(x : TensorProduct R M N)

(LinearMap.lTensor M LinearMap.id) x = x


@[simp]
theorem decompose_coe {i : ι} (x : ℳ i) : decompose ℳ (x : M) = DirectSum.of _ i x

{ι : Type u_1}
{M : Type u_3}
{σ : Type u_4}
[DecidableEq ι]
[AddCommMonoid M]
[SetLike σ M]
[AddSubmonoidClass σ M]
(ℳ : ι → σ)
[DirectSum.Decomposition ℳ]
{i : ι}
(x : ↥(ℳ i))

(DirectSum.decompose ℳ) ↑x = (DirectSum.of (fun i => ↥(ℳ i)) i) x


lemma quasispectrum_eq_spectrum_inr' (R S : Type*) {A : Type*} [Semifield R]
    [Field S] [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] (a : A) :
    quasispectrum R a = spectrum R (a : Unitization S A)

(R : Type u_3)
(S : Type u_4)
{A : Type u_5}
[Semifield R]
[Field S]
[NonUnitalRing A]
[Algebra R S]
[Module S A]
[IsScalarTower S A A]
[SMulCommClass S A A]
[Module R A]
[IsScalarTower R S A]
(a : A)


@[simp]
theorem Prop.codisjoint_iff {P Q : Prop} : Codisjoint P Q ↔ P ∨ Q


/-- The triangle in `CochainComplex C ℤ` attached to a degreewise split short exact sequence
of cochain complexes. -/
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂ mor₃]
def triangleOfDegreewiseSplit : Triangle (CochainComplex C ℤ)

(S : CategoryTheory.ShortComplex (CochainComplex C ℤ))

(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting)

(CochainComplex.triangleOfDegreewiseSplit S σ).obj₁ = S.X₁


@[simp]
theorem subtypeDomain_sub [∀ i, AddGroup (β i)] {p : ι → Prop} [DecidablePred p]
    {v v' : Π₀ i, β i} : (v - v').subtypeDomain p = v.subtypeDomain p - v'.subtypeDomain p

{ι : Type u}
{β : ι → Type v}
[(i : ι) → AddGroup (β i)]
{p : ι → Prop}
[DecidablePred p]
{v v' : Π₀ (i : ι), β i}

DFinsupp.subtypeDomain p (v - v') = DFinsupp.subtypeDomain p v - DFinsupp.subtypeDomain p v'


theorem ssubset_def : (s ⊂ t) = (s ⊆ t ∧ ¬t ⊆ s)


private lemma ite_nonneg [LE α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ ite p a b

{α : Type u_1}
[Zero α]
(p : Prop)
[Decidable p]
{a b : α}
[LE α]
(ha : 0 ≤ a)
(hb : 0 ≤ b)


@[to_additive]
protected lemma div_mul_cancel_right (h : IsUnit b) (a : α) : b / (a * b) = a⁻¹

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


theorem StrictRestriction.ne (h : N <r M) : N ≠ M

{α : Type u_1}
{M N : Matroid α}
(h : N.StrictRestriction M)


@[measurability]
 lemma stronglyMeasurable_exponentialPDFReal (r : ℝ) :
     StronglyMeasurable (exponentialPDFReal r)


@[to_additive]
lemma sup_mul_right [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s * t) f = sup t fun y ↦ sup s (f <| · * y)

{α : Type u_2}
{β : Type u_3}
[DecidableEq α]
[Mul α]
[SemilatticeSup β]
[OrderBot β]
(s t : Finset α)
(f : α → β)

(s * t).sup f = t.sup fun y => s.sup fun x => f (x * y)


theorem integral_simpleFunc_larger_space (hm : m ≤ m0) (f : @SimpleFunc β m F)
    (hf_int : Integrable f μ) :
    ∫ x, f x ∂μ = ∑ x ∈ @SimpleFunc.range β F m f, ENNReal.toReal (μ (f ⁻¹' {x})) • x

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

∫ (x : β), ↑f x ∂μ = ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal • x


@[simp]
theorem tail_cons (a : α) (s) : tail (cons a s) = s

{α : Type u}
(a : α)
(s : Stream'.WSeq α)


@[measurability]
theorem fundamentalDomain_measurableSet [MeasurableSpace E] [OpensMeasurableSpace E] [Finite ι] :
    MeasurableSet (fundamentalDomain b)

{E : Type u_1}
{ι : Type u_2}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
(b : Basis ι ℝ E)
[MeasurableSpace E]
[OpensMeasurableSpace E]
[Finite ι]


theorem Fintype.card_units [GroupWithZero α] [Fintype α] [DecidableEq α] :
    Fintype.card αˣ = Fintype.card α - 1

{α : Type u_1}
[GroupWithZero α]
[Fintype α]
[DecidableEq α]


theorem fdiv_nonpos : ∀ {a b : Int}, 0 ≤ a → b ≤ 0 → a.fdiv b ≤ 0


/-- Given `Uᵢ ×[Z] Y`, this is the glued fibered product `X ×[Z] Y`. -/
@[simps U V f t t', simps (config := .lemmasOnly) J]
def gluing : Scheme.GlueData.{u}

[∀ (i : 𝒰.J), CategoryTheory.Limits.HasPullback (𝒰.map i ≫ f) g]

(AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).t i j = AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j


theorem eqOn_of_ae_eq {f g : X → Y} (h : f =ᵐ[μ.restrict s] g) (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) (hU : s ⊆ closure (interior s)) : EqOn f g s

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
{m : MeasurableSpace X}
[TopologicalSpace Y]
[T2Space Y]
{μ : MeasureTheory.Measure X}
[μ.IsOpenPosMeasure]
{s : Set X}
{f g : X → Y}
(h : f =ᵐ[μ.restrict s] g)
(hf : ContinuousOn f s)
(hg : ContinuousOn g s)
(hU : s ⊆ closure (interior s))


/-- Given a functor `F : C₁ ⥤ C₂ ⥤ D`, this is the bifunctor which sends
`K₁ : HomologicalComplex C₁ c₁` and `K₂ : HomologicalComplex C₂ c₂` to the bicomplex
which is degree `(i₁, i₂)` consists of `(F.obj (K₁.X i₁)).obj (K₂.X i₂)`. -/
@[simps! obj_obj_X_X obj_obj_X_d obj_obj_d_f obj_map_f_f map_app_f_f]
def mapBifunctorHomologicalComplex :
    HomologicalComplex C₁ c₁ ⥤ HomologicalComplex C₂ c₂ ⥤ HomologicalComplex₂ D c₁ c₂

[∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms]

((((F.mapBifunctorHomologicalComplex c₁ c₂).map f).app K₂).f i₁).f i₂ = (F.map (f.f i₁)).app (K₂.X i₂)


/-- **Kummer's Theorem**
Taking (`p - 1`) times the `p`-adic valuation of the binomial `n + k` over `k` equals the sum of the
digits of `k` plus the sum of the digits of `n` minus the sum of digits of `n + k`, all base `p`.
-/
theorem sub_one_mul_padicValNat_choose_eq_sub_sum_digits' {k n : ℕ} [hp : Fact p.Prime] :
    (p - 1) * padicValNat p (choose (n + k) k) =
    (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum

(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum


@[to_additive (attr := simp)]
theorem noncommProd_toFinset [DecidableEq α] (l : List α) (f : α → β) (comm) (hl : l.Nodup) :
    noncommProd l.toFinset f comm = (l.map f).prod

(comm : (↑l.toFinset).Pairwise fun a b => AddCommute (f a) (f b))

l.toFinset.noncommSum f comm = (List.map f l).sum


lemma setLIntegral_compProd [SFinite μ] [IsSFiniteKernel κ]
    {f : α × β → ℝ≥0∞} (hf : Measurable f)
    {s : Set α} (hs : MeasurableSet s) {t : Set β} (ht : MeasurableSet t) :
    ∫⁻ x in s ×ˢ t, f x ∂(μ ⊗ₘ κ) = ∫⁻ a in s, ∫⁻ b in t, f (a, b) ∂(κ a) ∂μ

{α : Type u_1}
{β : Type u_2}
{mα : MeasurableSpace α}
{mβ : MeasurableSpace β}
{μ : MeasureTheory.Measure α}
{κ : ProbabilityTheory.Kernel α β}
[MeasureTheory.SFinite μ]
[ProbabilityTheory.IsSFiniteKernel κ]
{f : α × β → ℝ≥0∞}
(hf : Measurable f)
{s : Set α}
(hs : MeasurableSet s)
{t : Set β}
(ht : MeasurableSet t)

∫⁻ (x : α × β) in s ×ˢ t, f x ∂μ ⊗ₘ κ = ∫⁻ (a : α) in s, ∫⁻ (b : β) in t, f (a, b) ∂κ a ∂μ


/-- `Ordinal.deriv` enumerates the fixed points of a normal function. -/
theorem deriv_eq_enumOrd (H : IsNormal f) : deriv f = enumOrd (Function.fixedPoints f)

{f : Ordinal.{u} → Ordinal.{u}}
(H : Ordinal.IsNormal f)

Ordinal.deriv f = Ordinal.enumOrd (Function.fixedPoints f)


theorem InfIrred.finset_inf_eq : InfIrred a → s.inf f = a → ∃ i ∈ s, f i = a

{ι : Type u_1}
{α : Type u_2}
[SemilatticeInf α]
{a : α}
[OrderTop α]
{s : Finset ι}
{f : ι → α}


theorem single_add_erase (i : ι) (f : Π₀ i, β i) : single i (f i) + f.erase i = f

{ι : Type u}
{β : ι → Type v}
[DecidableEq ι]
[(i : ι) → AddZeroClass (β i)]
(i : ι)
(f : Π₀ (i : ι), β i)

DFinsupp.single i (f i) + DFinsupp.erase i f = f


@[simp]
theorem continuum_mul_aleph0 : 𝔠 * ℵ₀ = 𝔠

Cardinal.continuum * Cardinal.aleph0 = Cardinal.continuum


@[simp, norm_cast]
theorem toNNReal_nat (n : ℕ) : (n : ℝ≥0∞).toNNReal = n


theorem roots_X_pow_char_pow_sub_C_pow {y : R} {m : ℕ} :
    ((X ^ p ^ n - C y) ^ m).roots = (m * p ^ n) • {(iterateFrobeniusEquiv R p n).symm y}

{R : Type u_1}
[CommRing R]
[IsDomain R]
{p n : ℕ}
[ExpChar R p]
[PerfectRing R p]
{y : R}
{m : ℕ}

((Polynomial.X ^ p ^ n - Polynomial.C y) ^ m).roots = (m * p ^ n) • {(iterateFrobeniusEquiv R p n).symm y}


theorem LinearMap.weakBilin_withSeminorms (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :
    WithSeminorms (LinearMap.toSeminormFamily B : F → Seminorm 𝕜 (WeakBilin B))

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[NormedField 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[AddCommGroup F]
[Module 𝕜 F]
(B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜)


@[trans]
theorem Filter.EventuallyEq.trans_isEquivalent {f g₁ g₂ : α → β} (h : f =ᶠ[l] g₁)
    (h₂ : g₁ ~[l] g₂) : f ~[l] g₂

{α : Type u_1}
{β : Type u_2}
[NormedAddCommGroup β]
{l : Filter α}
{f g₁ g₂ : α → β}
(h : f =ᶠ[l] g₁)
(h₂ : g₁ ~[l] g₂)


theorem Equiv.isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≈ 0

(x : SetTheory.PGame)
[IsEmpty x.LeftMoves]
[IsEmpty x.RightMoves]


theorem lcm_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.lcm f = s₂.lcm g

{α : Type u_2}
{β : Type u_3}
[CancelCommMonoidWithZero α]
[NormalizedGCDMonoid α]
{s₁ s₂ : Finset β}
{f g : β → α}
(hs : s₁ = s₂)
(hfg : ∀ a ∈ s₂, f a = g a)


/-- A different formulation of Hölder's inequality for two functions, with two exponents that sum to
1, instead of reciprocals of  -/
theorem lintegral_mul_norm_pow_le {α} [MeasurableSpace α] {μ : Measure α}
    {f g : α → ℝ≥0∞} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ)
    {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) (hpq : p + q = 1) :
    ∫⁻ a, f a ^ p * g a ^ q ∂μ ≤ (∫⁻ a, f a ∂μ) ^ p * (∫⁻ a, g a ∂μ) ^ q

{α : Type u_2}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
{f g : α → ENNReal}
(hf : AEMeasurable f μ)
(hg : AEMeasurable g μ)
{p q : ℝ}
(hp : 0 ≤ p)
(hq : 0 ≤ q)
(hpq : p + q = 1)

∫⁻ (a : α), f a ^ p * g a ^ q ∂μ ≤ (∫⁻ (a : α), f a ∂μ) ^ p * (∫⁻ (a : α), g a ∂μ) ^ q


theorem tendsto_Iio_atBot [SemilatticeInf α] {a : α} {f : β → Iio a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot

{α : Type u_3}
{β : Type u_4}
[SemilatticeInf α]
{a : α}
{f : β → ↑(Set.Iio a)}
{l : Filter β}

Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atBot


lemma a_add_eta_mul_b : S.a + η * S.b = (S.a + S.b) + λ * S.b

(S : FermatLastTheoremForThreeGen.Solution hζ)

S.a + ↑⋯.unit * S.b = S.a + S.b + (hζ.toInteger - 1) * S.b


theorem LF.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x)


theorem integral_exp_neg_Ioi (c : ℝ) : (∫ x : ℝ in Ioi c, exp (-x)) = exp (-c)

∫ (x : ℝ) in Set.Ioi c, rexp (-x) = rexp (-c)


lemma set_range_forget_map_inclusion {X : TopCat} (U : Opens X) :
    Set.range ((forget TopCat).map (inclusion U)) = (U : Set X)

{X : TopCat}
(U : TopologicalSpace.Opens ↑X)

Set.range ((CategoryTheory.forget TopCat).map U.inclusion) = ↑U


/-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C

(X : CategoryTheory.DifferentialObject S C)

((CategoryTheory.DifferentialObject.shiftFunctor C n).obj X).d =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map X.d)
    (CategoryTheory.shiftComm X.obj 1 n).hom


/-- If `{s i | p i}` is a basis of a filter `l` and each `s i` includes `s j` such that
`p j ∧ q j`, then `{s j | p j ∧ q j}` is a basis of `l`. -/
theorem HasBasis.restrict (h : l.HasBasis p s) {q : ι → Prop}
    (hq : ∀ i, p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i) : l.HasBasis (fun i => p i ∧ q i) s

(hq : ∀ (i : ι), p i → ∃ j, p j ∧ q j ∧ s j ⊆ s i)


theorem hasDerivAt_gronwallBound_shift (δ K ε x a : ℝ) :
    HasDerivAt (fun y => gronwallBound δ K ε (y - a)) (K * gronwallBound δ K ε (x - a) + ε) x


theorem cond_mul_eq_inter' (hms : MeasurableSet s) (hcs' : μ s ≠ ∞) (t : Set Ω) :
    μ[t|s] * μ s = μ (s ∩ t)

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

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


@[simp]
theorem snd_compl [HasCompl α] [HasCompl β] (a : α × β) : aᶜ.2 = a.2ᶜ

{α : Type u_2}
{β : Type u_3}
[HasCompl α]
[HasCompl β]
(a : α × β)


theorem IsNormal.lt_iff {f} (H : IsNormal f) {a b} : f a < f b ↔ a < b

{f : Ordinal.{u_4} → Ordinal.{u_5}}
(H : Ordinal.IsNormal f)
{a b : Ordinal.{u_4}}


theorem div_le_div_iff (b0 : 0 < b) (d0 : 0 < d) : a / b ≤ c / d ↔ a * d ≤ c * b

{α : Type u_2}
[LinearOrderedSemifield α]
{a b c d : α}
(b0 : 0 < b)
(d0 : 0 < d)


/-- Given a trifunctor `F : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄`, a map `p : I₁ × I₂ × I₃ → J`, and
graded objects `X₁ : GradedObject I₁ C₁`, `X₂ : GradedObject I₂ C₂` and `X₃ : GradedObject I₃ C₃`,
this is the `J`-graded object sending `j` to the coproduct of
`((F.obj (X₁ i₁)).obj (X₂ i₂)).obj (X₃ i₃)` for `p ⟨i₁, i₂, i₃⟩ = j`. -/
@[simps]
noncomputable def mapTrifunctorMapFunctorObj (X₁ : GradedObject I₁ C₁)
    [∀ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄

(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄)))

(X₁ : CategoryTheory.GradedObject I₁ C₁)

[∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p]

((CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁).obj X₂).obj X₃ =
  CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ X₂ X₃


theorem add_one_mul [RightDistribClass α] (a b : α) : (a + 1) * b = a * b + b

{α : Type u}
[Add α]
[MulOneClass α]
[RightDistribClass α]
(a b : α)


lemma BijOn.iterate {f : α → α} {s : Set α} (h : BijOn f s s) : ∀ n, BijOn f^[n] s s

{α : Type u_1}
{f : α → α}
{s : Set α}
(h : Set.BijOn f s s)
(n : ℕ)


theorem mapAccumr_bisim_tail {f₁ : α → σ₁ → σ₁ × β} {f₂ : α → σ₂ → σ₂ × β} {s₁ : σ₁} {s₂ : σ₂}
    (h : ∃ R : σ₁ → σ₂ → Prop, R s₁ s₂ ∧
      ∀ {s q} a, R s q → R (f₁ a s).1 (f₂ a q).1 ∧ (f₁ a s).2 = (f₂ a q).2) :
    (mapAccumr f₁ xs s₁).snd = (mapAccumr f₂ xs s₂).snd

{f₁ : α → σ₁ → σ₁ × β}

{f₂ : α → σ₂ → σ₂ × β}

(h : ∃ R, R s₁ s₂ ∧ ∀ {s : σ₁} {q : σ₂} (a : α), R s q → R (f₁ a s).1 (f₂ a q).1 ∧ (f₁ a s).2 = (f₂ a q).2)

(Mathlib.Vector.mapAccumr f₁ xs s₁).2 = (Mathlib.Vector.mapAccumr f₂ xs s₂).2


theorem mem_factorSet_some {p : Associates α} {hp : Irreducible p}
    {l : Multiset { a : Associates α // Irreducible a }} :
    p ∈ (l : FactorSet α) ↔ Subtype.mk p hp ∈ l

{α : Type u_1}
[CancelCommMonoidWithZero α]
{p : Associates α}
{hp : Irreducible p}
{l : Multiset { a // Irreducible a }}


/--
Given a natural transformation `G ⋙ ℱ ⟶ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ'` is a sheaf,
we may obtain a natural transformation between sheaves.
-/
@[simps]
noncomputable def presheafHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) : ℱ ⟶ ℱ'.val

{K : CategoryTheory.GrothendieckTopology D}

{ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)}

∀ (a : ℱ.obj (Opposite.op (Opposite.unop X))),
  (CategoryTheory.Functor.IsCoverDense.Types.presheafHom α).app X a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom α (Opposite.unop X) a


theorem coe_inj {f g : ι →ᵇᵃ[I₀] M} : (f : Box ι → M) = g ↔ f = g

{f g : BoxIntegral.BoxAdditiveMap ι M I₀}


@[to_additive (attr := simp)]
theorem map_of (x) : map f (of x) = of (f x)

{α : Type u}
{β : Type v}
(f : α → β)
(x : α)

(FreeAddMagma.map f) (FreeAddMagma.of x) = FreeAddMagma.of (f x)


theorem unitCoeff_spec {x : ℤ_[p]} (hx : x ≠ 0) :
    x = (unitCoeff hx : ℤ_[p]) * (p : ℤ_[p]) ^ Int.natAbs (valuation x)

{p : ℕ}
[hp : Fact (Nat.Prime p)]
{x : ℤ_[p]}
(hx : x ≠ 0)

x = ↑(PadicInt.unitCoeff hx) * ↑p ^ x.valuation.natAbs


/-- Quantitative result associated to the direct comparison test for series: If `∑' i, g i` is
summable, and for all `i`, `‖f i‖₊ ≤ g i`, then `‖∑' i, f i‖₊ ≤ ∑' i, g i`. Note that we
do not assume that `∑' i, f i` is summable, and it might not be the case if `α` is not a complete
space. -/
theorem tsum_of_nnnorm_bounded {f : ι → E} {g : ι → ℝ≥0} {a : ℝ≥0} (hg : HasSum g a)
    (h : ∀ i, ‖f i‖₊ ≤ g i) : ‖∑' i : ι, f i‖₊ ≤ a

{ι : Type u_1}
{E : Type u_3}
[SeminormedAddCommGroup E]
{f : ι → E}
{g : ι → ℝ≥0}
{a : ℝ≥0}
(hg : HasSum g a)
(h : ∀ (i : ι), ‖f i‖₊ ≤ g i)


/-- **Divergence theorem** for Bochner integral. If `f : ℝⁿ⁺¹ → Eⁿ⁺¹` is continuous on a rectangular
box `[a, b] : Set ℝⁿ⁺¹`, `a ≤ b`, is differentiable on its interior with derivative
`f' : ℝⁿ⁺¹ → ℝⁿ⁺¹ →L[ℝ] Eⁿ⁺¹` and the divergence `fun x ↦ ∑ i, f' x eᵢ i` is integrable on `[a, b]`,
where `eᵢ = Pi.single i 1` is the `i`-th basis vector, then its integral is equal to the sum of
integrals of `f` over the faces of `[a, b]`, taken with appropriate signs.

Moreover, the same is true if the function is not differentiable at countably many
points of the interior of `[a, b]`.

We represent both faces `x i = a i` and `x i = b i` as the box
`face i = [a ∘ Fin.succAbove i, b ∘ Fin.succAbove i]` in `ℝⁿ`, where
`Fin.succAbove : Fin n ↪o Fin (n + 1)` is the order embedding with range `{i}ᶜ`. The restrictions
of `f : ℝⁿ⁺¹ → Eⁿ⁺¹` to these faces are given by `f ∘ backFace i` and `f ∘ frontFace i`, where
`backFace i = Fin.insertNth i (a i)` and `frontFace i = Fin.insertNth i (b i)` are embeddings
`ℝⁿ → ℝⁿ⁺¹` that take `y : ℝⁿ` and insert `a i` (resp., `b i`) as `i`-th coordinate. -/
theorem integral_divergence_of_hasFDerivWithinAt_off_countable (hle : a ≤ b)
    (f : ℝⁿ⁺¹ → Eⁿ⁺¹)
    (f' : ℝⁿ⁺¹ → ℝⁿ⁺¹ →L[ℝ] Eⁿ⁺¹)
    (s : Set ℝⁿ⁺¹) (hs : s.Countable) (Hc : ContinuousOn f (Icc a b))
    (Hd : ∀ x ∈ (Set.pi univ fun i => Ioo (a i) (b i)) \ s, HasFDerivAt f (f' x) x)
    (Hi : IntegrableOn (fun x => ∑ i, f' x (e i) i) (Icc a b)) :
    (∫ x in Icc a b, ∑ i, f' x (e i) i) =
      ∑ i : Fin (n + 1),
        ((∫ x in face i, f (frontFace i x) i) - ∫ x in face i, f (backFace i x) i)

(f : (Fin (n + 1) → ℝ) → Fin (n + 1) → E)

(f' : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) →L[ℝ] Fin (n + 1) → E)

(Hd : ∀ x ∈ (Set.univ.pi fun i => Set.Ioo (a i) (b i)) \ s, HasFDerivAt f (f' x) x)

(Hi :
  MeasureTheory.IntegrableOn (fun x => ∑ i : Fin (n + 1), (f' x) (Pi.single i 1) i) (Set.Icc a b) MeasureTheory.volume)

∫ (x : Fin (n + 1) → ℝ) in Set.Icc a b, ∑ i : Fin (n + 1), (f' x) (Pi.single i 1) i =
  ∑ i : Fin (n + 1),
    ((∫ (x : Fin n → ℝ) in Set.Icc (a ∘ i.succAbove) (b ∘ i.succAbove), f (i.insertNth (b i) x) i) -
      ∫ (x : Fin n → ℝ) in Set.Icc (a ∘ i.succAbove) (b ∘ i.succAbove), f (i.insertNth (a i) x) i)


theorem hitting_mem_set [IsWellOrder ι (· < ·)] {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
    u (hitting u s n m ω) ω ∈ s

{u : ι → Ω → β}

u (MeasureTheory.hitting u s n m ω) ω ∈ s


theorem setOf_wSameSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.WSameSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Ici 0) s

{R : Type u_1}
{V : Type u_2}
{P : Type u_4}
[LinearOrderedField R]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
{s : AffineSubspace R P}
{x p : P}
(hx : x ∉ s)
(hp : p ∈ s)

{y | s.WSameSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (Set.Ici 0) ↑s


theorem lipschitzWith_circleMap (c : ℂ) (R : ℝ) : LipschitzWith (Real.nnabs R) (circleMap c R)


@[to_additive (attr := simp)]
theorem ofDual_div [Div α] (a b : αᵒᵈ) : ofDual (a / b) = ofDual a / ofDual b

OrderDual.ofDual (a - b) = OrderDual.ofDual a - OrderDual.ofDual b


/-- Definition of `IsBigO` in terms of `IsBigOWith`. We record it in a lemma as `IsBigO` is
irreducible. -/
theorem isBigO_iff_isBigOWith : f =O[l] g ↔ ∃ c : ℝ, IsBigOWith c l f g

{α : Type u_1}
{E : Type u_3}
{F : Type u_4}
[Norm E]
[Norm F]
{f : α → E}
{g : α → F}
{l : Filter α}

f =O[l] g ↔ ∃ c, Asymptotics.IsBigOWith c l f g


theorem abs_sin_eq_sqrt_one_sub_cos_sq (x : ℝ) : |sin x| = √(1 - cos x ^ 2)


theorem posOf_eq (s c) : posOf s c = find s (· == c)


/-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
antitone function `f : ℤ → α`. -/
theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f

(α : Type u)
[Preorder α]
[Nonempty α]
[NoMinOrder α]
[NoMaxOrder α]


/-- The image of a compact open under a continuous open map. -/
@[simps toCompacts]
def map (f : α → β) (hf : Continuous f) (hf' : IsOpenMap f) (s : CompactOpens α) : CompactOpens β

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
(f : α → β)
(hf : Continuous f)
(hf' : IsOpenMap f)
(s : TopologicalSpace.CompactOpens α)

(TopologicalSpace.CompactOpens.map f hf hf' s).toCompacts = TopologicalSpace.Compacts.map f hf s.toCompacts


theorem SeparationQuotient.t2Space_iff : T2Space (SeparationQuotient X) ↔ R1Space X


/-- If there is a primitive `n`-th root of unity in `K`, then `X ^ n - 1` splits. -/
theorem X_pow_sub_one_splits {ζ : K} {n : ℕ} (h : IsPrimitiveRoot ζ n) :
    Splits (RingHom.id K) (X ^ n - C (1 : K))

{K : Type u_1}
[Field K]
{ζ : K}
{n : ℕ}
(h : IsPrimitiveRoot ζ n)

Polynomial.Splits (RingHom.id K) (Polynomial.X ^ n - Polynomial.C 1)


theorem midpoint_vsub (p₁ p₂ p : P) :
    midpoint R p₁ p₂ -ᵥ p = (⅟ 2 : R) • (p₁ -ᵥ p) + (⅟ 2 : R) • (p₂ -ᵥ p)

{R : Type u_1}
{V : Type u_2}
{P : Type u_4}
[Ring R]
[Invertible 2]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
(p₁ p₂ p : P)

midpoint R p₁ p₂ -ᵥ p = ⅟2 • (p₁ -ᵥ p) + ⅟2 • (p₂ -ᵥ p)


/-- An affine combination, over the image of an embedding, equals an
affine combination with the same points and weights over the original
`Finset`. -/
theorem affineCombination_map (e : ι₂ ↪ ι) (w : ι → k) (p : ι → P) :
    (s₂.map e).affineCombination k p w = s₂.affineCombination k (p ∘ e) (w ∘ e)

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[S : AffineSpace V P]
{ι : Type u_4}
{ι₂ : Type u_5}
(s₂ : Finset ι₂)
(e : ι₂ ↪ ι)
(w : ι → k)
(p : ι → P)

(Finset.affineCombination k (Finset.map e s₂) p) w = (Finset.affineCombination k s₂ (p ∘ ⇑e)) (w ∘ ⇑e)


/-- **Phragmen-Lindelöf principle** in the first quadrant. Let `f g : ℂ → E` be functions such that

* `f` and `g` are differentiable in the open first quadrant and are continuous on its closure;
* `‖f z‖` and `‖g z‖` are bounded from above by `A * exp(B * (abs z) ^ c)` on the open first
  quadrant for some `A`, `B`, and `c < 2`;
* `f` is equal to `g` on the boundary of the first quadrant.

Then `f` is equal to `g` on the closed first quadrant. -/
theorem eqOn_quadrant_I (hdf : DiffContOnCl ℂ f (Ioi 0 ×ℂ Ioi 0))
    (hBf : ∃ c < (2 : ℝ), ∃ B,
      f =O[cobounded ℂ ⊓ 𝓟 (Ioi 0 ×ℂ Ioi 0)] fun z => expR (B * abs z ^ c))
    (hdg : DiffContOnCl ℂ g (Ioi 0 ×ℂ Ioi 0))
    (hBg : ∃ c < (2 : ℝ), ∃ B,
      g =O[cobounded ℂ ⊓ 𝓟 (Ioi 0 ×ℂ Ioi 0)] fun z => expR (B * abs z ^ c))
    (hre : ∀ x : ℝ, 0 ≤ x → f x = g x) (him : ∀ x : ℝ, 0 ≤ x → f (x * I) = g (x * I)) :
    EqOn f g {z | 0 ≤ z.re ∧ 0 ≤ z.im}

(hdf : DiffContOnCl ℂ f (Set.Ioi 0 ×ℂ Set.Ioi 0))

(hBf : ∃ c < 2, ∃ B, f =O[Bornology.cobounded ℂ ⊓ 𝓟 (Set.Ioi 0 ×ℂ Set.Ioi 0)] fun z => expR (B * Complex.abs z ^ c))

(hdg : DiffContOnCl ℂ g (Set.Ioi 0 ×ℂ Set.Ioi 0))

(hBg : ∃ c < 2, ∃ B, g =O[Bornology.cobounded ℂ ⊓ 𝓟 (Set.Ioi 0 ×ℂ Set.Ioi 0)] fun z => expR (B * Complex.abs z ^ c))

(him : ∀ (x : ℝ), 0 ≤ x → f (↑x * Complex.I) = g (↑x * Complex.I))


theorem hasDerivWithinAt_arcsin_Ici {x : ℝ} (h : x ≠ -1) :
    HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x

HasDerivWithinAt Real.arcsin (1 / √(1 - x ^ 2)) (Set.Ici x) x


lemma hasSum_jacobiTheta₂'_term (z : ℂ) {τ : ℂ} (hτ : 0 < im τ) :
    HasSum (fun n ↦ jacobiTheta₂'_term n z τ) (jacobiTheta₂' z τ)

HasSum (fun n => jacobiTheta₂'_term n z τ) (jacobiTheta₂' z τ)


theorem cgf_zero [IsProbabilityMeasure μ] : cgf X μ 0 = 0

{Ω : Type u_1}
{m : MeasurableSpace Ω}
{X : Ω → ℝ}
{μ : MeasureTheory.Measure Ω}
[MeasureTheory.IsProbabilityMeasure μ]


/-- Given a Localization map `f : M →* N` for a Submonoid `S ⊆ M`, if a `CommMonoid` map
`g : M →* P` induces a map `f.lift hg : N →* P` then for all `z : N, v w : P`, we have
`f.lift hg z * w = v ↔ g x * w = g y * v`, where `x : M, y ∈ S` are such that
`z * f y = f x`. -/
@[to_additive
    "Given a Localization map `f : M →+ N` for a Submonoid `S ⊆ M`, if an `AddCommMonoid` map
`g : M →+ P` induces a map `f.lift hg : N →+ P` then for all
`z : N, v w : P`, we have `f.lift hg z + w = v ↔ g x + w = g y + v`, where `x : M, y ∈ S` are such
that `z + f y = f x`."]
theorem lift_spec_mul (z w v) : f.lift hg z * w = v ↔ g (f.sec z).1 * w = g (f.sec z).2 * v

{M : Type u_1}
[CommMonoid M]
{S : Submonoid M}
{N : Type u_2}
[CommMonoid N]
{P : Type u_3}
[CommMonoid P]
(f : S.LocalizationMap N)
{g : M →* P}
(hg : ∀ (y : ↥S), IsUnit (g ↑y))
(z : N)
(w v : P)

(f.lift hg) z * w = v ↔ g (f.sec z).1 * w = g ↑(f.sec z).2 * v


theorem isSFiniteKernel_sum [Countable ι] {κs : ι → Kernel α β}
    (hκs : ∀ n, IsSFiniteKernel (κs n)) : IsSFiniteKernel (Kernel.sum κs)

(hκs : ∀ (n : ι), ProbabilityTheory.IsSFiniteKernel (κs n))


theorem isLUB_iSup : IsLUB (range f) (⨆ j, f j)

{α : Type u_1}
{ι : Sort u_5}
[CompleteLattice α]
{f : ι → α}


@[simp]
theorem continuousMultilinearCurryLeftEquiv_symm_apply (f : ContinuousMultilinearMap 𝕜 Ei G)
    (x : Ei 0) (v : ∀ i : Fin n, Ei i.succ) :
    (continuousMultilinearCurryLeftEquiv 𝕜 Ei G).symm f x v = f (cons x v)

[(i : Fin n.succ) → NormedAddCommGroup (Ei i)]

[(i : Fin n.succ) → NormedSpace 𝕜 (Ei i)]

(((continuousMultilinearCurryLeftEquiv 𝕜 Ei G).symm f) x) v = f (Fin.cons x v)


@[to_additive]
lemma sup_div_left [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s / t) f = sup s fun x ↦ sup t (f <| x / ·)

{α : Type u_2}
{β : Type u_3}
[DecidableEq α]
[Div α]
[SemilatticeSup β]
[OrderBot β]
(s t : Finset α)
(f : α → β)

(s / t).sup f = s.sup fun x => t.sup fun x_1 => f (x / x_1)


theorem succ_lt_succ_iff : succ a < succ b ↔ a < b


theorem ncard_eq_ncard_iff_ncard_diff_eq_ncard_diff (hs : s.Finite := by toFinite_tac)
    (ht : t.Finite := by toFinite_tac) : s.ncard = t.ncard ↔ (s \ t).ncard = (t \ s).ncard

{α : Type u_1}
{s t : Set α}
(hs : s.Finite := by toFinite_tac)
(ht : t.Finite := by toFinite_tac)


@[to_additive]
lemma comp_mul [CommMonoid P] (g : N →* P) (f₁ f₂ : M →* N) :
    g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂

{M : Type u_3}
{N : Type u_4}
{P : Type u_5}
[MulOneClass M]
[CommMonoid N]
[CommMonoid P]
(g : N →* P)
(f₁ f₂ : M →* N)


/-- If the angle between two vectors is `π`, the vectors are not equal. -/
theorem ne_of_oangle_eq_pi {x y : V} (h : o.oangle x y = π) : x ≠ y

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


theorem lineMap_mono_endpoints (ha : a ≤ a') (hb : b ≤ b') (h₀ : 0 ≤ r) (h₁ : r ≤ 1) :
    lineMap a b r ≤ lineMap a' b' r

{k : Type u_1}
{E : Type u_2}
[OrderedRing k]
[OrderedAddCommGroup E]
[Module k E]
[OrderedSMul k E]
{a a' b b' : E}
{r : k}
(ha : a ≤ a')
(hb : b ≤ b')
(h₀ : 0 ≤ r)
(h₁ : r ≤ 1)

(AffineMap.lineMap a b) r ≤ (AffineMap.lineMap a' b') r


/--
The contravariant functor turning monoid objects in the opposite category into comonoid objects.
-/
@[simps]
def Mon_OpOpToComon_ : (Mon_ (Cᵒᵖ))ᵒᵖ ⥤ Comon_ C

(C : Type u₁)
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
(A : (Mon_ Cᵒᵖ)ᵒᵖ)

(Comon_.Mon_OpOpToComon_ C).obj A = Comon_.Mon_OpOpToComon_obj' C (Opposite.unop A)


lemma twoTorsionPolynomial_disc_isUnit [Invertible (2 : R)] :
    IsUnit W.twoTorsionPolynomial.disc ↔ IsUnit W.Δ

{R : Type u}
[CommRing R]
(W : WeierstrassCurve R)
[Invertible 2]


theorem sSup_iUnion (t : ι → Set β) : sSup (⋃ i, t i) = ⨆ i, sSup (t i)

{β : Type u_2}
{ι : Sort u_4}
[CompleteLattice β]
(t : ι → Set β)


theorem SurjOn.bijOn_subset [Nonempty α] (h : SurjOn f s t) : BijOn f (invFunOn f s '' t) t

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{t : Set β}
{f : α → β}
[Nonempty α]
(h : Set.SurjOn f s t)

Set.BijOn f (Function.invFunOn f s '' t) t


@[simp]
theorem mk_finsupp_lift_of_fintype (α : Type u) (β : Type v) [Fintype α] [Zero β] :
    #(α →₀ β) = lift.{u} #β ^ Fintype.card α

Cardinal.mk (α →₀ β) = Cardinal.lift.{u, v} (Cardinal.mk β) ^ Fintype.card α


theorem compatiblePreserving_opens_map :
    CompatiblePreserving (Opens.grothendieckTopology X) (Opens.map f)

CategoryTheory.CompatiblePreserving (Opens.grothendieckTopology ↑X) (TopologicalSpace.Opens.map f)


@[to_additive (attr := simp, norm_cast)]
theorem coe_inv [Inv G] (f : α → G) : ↑f⁻¹ = (f⁻¹ : Germ l G)

{α : Type u_1}
{l : Filter α}
{G : Type u_6}
[Inv G]
(f : α → G)

↑f⁻¹ = (↑f)⁻¹


theorem finrank_eq_zero_of_not_exists_basis
    (h : ¬∃ s : Finset M, Nonempty (Basis (s : Set M) R M)) : finrank R M = 0

{R : Type u}
{M : Type v}
[Ring R]
[AddCommGroup M]
[Module R M]
[Module.Free R M]
(h : ¬∃ s, Nonempty (Basis (↑↑s) R M))


/-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `F₁' : D ⥤ E` lifts a functor `F₁ : C ⥤ D`, then a functor `F₂'` which
is isomorphic to `F₁'` also lifts a functor `F₂` that is isomorphic to `F₁`.  -/
@[simps]
def ofIsos {F₁ F₂ : C ⥤ E} {F₁' F₂' : D ⥤ E} (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') [Lifting L W F₁ F₁'] :
    Lifting L W F₂ F₂'

[CategoryTheory.Localization.Lifting L W F₁ F₁']

CategoryTheory.Localization.Lifting.iso' W =
  CategoryTheory.isoWhiskerLeft L e'.symm ≪≫ CategoryTheory.Localization.Lifting.iso L W F₁ F₁' ≪≫ e


@[to_additive (attr := simp)]
lemma stabilizer_mul_self (s : Set G) : (stabilizer G s : Set G) * s = s


@[simp] theorem maximum?_eq_none_iff {xs : List α} [Max α] : xs.maximum? = none ↔ xs = []


@[simp, norm_cast]
theorem coe_nndist (x y : α) : ↑(nndist x y) = dist x y

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


@[simp]
theorem coe_toIntLinearEquiv : ⇑e.toIntLinearEquiv = e

{M : Type u_8}
{M₂ : Type u_10}
[AddCommGroup M]
[AddCommGroup M₂]
(e : M ≃+ M₂)


@[to_additive (attr := simp)]
lemma UniformFun.toFun_one [One β] : toFun (1 : α →ᵤ β) = 1


@[simp] lemma toENat_le_ofNat {a : Cardinal} {n : ℕ} [n.AtLeastTwo] :
    toENat a ≤ no_index (OfNat.ofNat n) ↔ a ≤ OfNat.ofNat n

{a : Cardinal.{u_1}}
{n : ℕ}
[n.AtLeastTwo]

Cardinal.toENat a ≤ OfNat.ofNat n ↔ a ≤ OfNat.ofNat n


theorem Perm.append {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂) : l₁ ++ t₁ ~ l₂ ++ t₂

{α : Type u_1}
{l₁ l₂ t₁ t₂ : List α}
(p₁ : l₁ ~ l₂)
(p₂ : t₁ ~ t₂)


@[reassoc (attr := simp)]
theorem ι_desc {Z : C} (Δ : SimplexCategoryᵒᵖ) (F : ∀ A : IndexSet Δ, s.N A.1.unop.len ⟶ Z)
    (A : IndexSet Δ) : (s.cofan Δ).inj A ≫ s.desc Δ F = F A

(F : (A : SimplicialObject.Splitting.IndexSet Δ) → s.N (Opposite.unop A.fst).len ⟶ Z)


@[to_additive (attr := simp) dite_smul]
lemma pow_dite (p : Prop) [Decidable p] (a : α) (b : p → β) (c : ¬ p → β) :
    a ^ (if h : p then b h else c h) = if h : p then a ^ b h else a ^ c h

{α : Type u_1}
{β : Type u_2}
[SMul β α]
(p : Prop)
[Decidable p]
(a : α)
(b : p → β)
(c : ¬p → β)

(if h : p then b h else c h) • a = if h : p then b h • a else c h • a