theorem hasDerivWithinAt_neg : HasDerivWithinAt Neg.neg (-1) s x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
(x : 𝕜)
(s : Set 𝕜)


theorem MapsTo.congr (h₁ : MapsTo f₁ s t) (h : EqOn f₁ f₂ s) : MapsTo f₂ s t

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{t : Set β}
{f₁ f₂ : α → β}
(h₁ : Set.MapsTo f₁ s t)
(h : Set.EqOn f₁ f₂ s)


@[simp]
theorem ceil_sub_int (a : α) (z : ℤ) : ⌈a - z⌉ = ⌈a⌉ - z

{α : Type u_2}
[LinearOrderedRing α]
[FloorRing α]
(a : α)
(z : ℤ)


/-- A vector is in the direction of a nonempty affine subspace if and only if it is the subtraction
of two vectors in the subspace. -/
theorem mem_direction_iff_eq_vsub {s : AffineSubspace k P} (h : (s : Set P).Nonempty) (v : V) :
    v ∈ s.direction ↔ ∃ p1 ∈ s, ∃ p2 ∈ s, v = p1 -ᵥ p2

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{s : AffineSubspace k P}
(h : (↑s).Nonempty)
(v : V)


theorem norm_re_le_norm (z : K) : ‖re z‖ ≤ ‖z‖


/-- The multilinear version of `LinearMap.comp_codRestrict` -/
@[simp]
theorem compMultilinearMap_codRestrict (g : M₂ →ₗ[R] M₃) (f : MultilinearMap R M₁ M₂)
    (p : Submodule R M₃) (h) :
    (g.codRestrict p h).compMultilinearMap f =
      (g.compMultilinearMap f).codRestrict p fun v => h (f v)

{R : Type uR}
{ι : Type uι}
{M₁ : ι → Type v₁}
{M₂ : Type v₂}
{M₃ : Type v₃}
[Semiring R]
[(i : ι) → AddCommMonoid (M₁ i)]
[AddCommMonoid M₂]
[AddCommMonoid M₃]
[(i : ι) → Module R (M₁ i)]
[Module R M₂]
[Module R M₃]
(g : M₂ →ₗ[R] M₃)
(f : MultilinearMap R M₁ M₂)
(p : Submodule R M₃)
(h : ∀ (c : M₂), g c ∈ p)

(LinearMap.codRestrict p g h).compMultilinearMap f = (g.compMultilinearMap f).codRestrict p ⋯


lemma neg_natCast_eq_one (n : ℕ) : -(n : Fin (n + 1)) = 1


lemma equiv_iff_eq_of_Z_eq' {P Q : Fin 3 → R} (hz : P z = Q z) (mem : Q z ∈ nonZeroDivisors R) :
    P ≈ Q ↔ P = Q

{R : Type u}
[CommRing R]
{P Q : Fin 3 → R}
(hz : P z = Q z)
(mem : Q z ∈ nonZeroDivisors R)


theorem le_coe_addNat (m : Nat) (i : Fin n) : m ≤ addNat i m


@[to_additive]
lemma iIndepFun.indepFun_div_right (hf_indep : iIndepFun (fun _ ↦ m) f κ μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    IndepFun (f i) (f j / f k) κ μ

{f : ι → Ω → β}

(hf_indep : ProbabilityTheory.Kernel.iIndepFun (fun x => m) f κ μ)

ProbabilityTheory.Kernel.IndepFun (f i) (f j / f k) κ μ


@[simp]
theorem liminf_const {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} [NeBot f]
    (b : β) : liminf (fun _ => b) f = b

{β : Type u_2}
{α : Type u_6}
[ConditionallyCompleteLattice β]
{f : Filter α}
[f.NeBot]
(b : β)


@[simp] lemma bot_mul_bot : (⊥ : EReal) * ⊥ = ⊤


theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤

{P : Type u_1}
[LE P]
[IsDirected P fun x x_1 => x ≤ x_1]
[Nonempty P]
{I : Order.Ideal P}


@[simp]
theorem add_cons (a : α) (s t : Multiset α) : s + a ::ₘ t = a ::ₘ (s + t)

{α : Type u_1}
(a : α)
(s t : Multiset α)


protected theorem coe_zero : ((0 : S) : A) = 0

{R : Type u}
{A : Type v}
[CommSemiring R]
[Semiring A]
[Algebra R A]
(S : Subalgebra R A)


@[simp] theorem ker_rangeRestrict : ker f.rangeRestrict = ker f

{R : Type u_1}
{R₂ : Type u_2}
{M : Type u_6}
{M₂ : Type u_7}
[Semiring R]
[Semiring R₂]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R₂ M₂]
{τ₁₂ : R →+* R₂}
[RingHomSurjective τ₁₂]
(f : M →ₛₗ[τ₁₂] M₂)

LinearMap.ker f.rangeRestrict = LinearMap.ker f


/-- Right unitor as a natural isomorphism. -/
@[simps!]
def rightUnitorNatIso (a b : B) : (postcomposing a _ _).obj (𝟙 b) ≅ 𝟭 (a ⟶ b)

{B : Type u}
[CategoryTheory.Bicategory B]
(a b : B)
(X : a ⟶ b)

(CategoryTheory.Bicategory.rightUnitorNatIso a b).inv.app X = (CategoryTheory.Bicategory.rightUnitor X).inv


@[simp]
theorem rightAngleRotation_rightAngleRotation (x : E) : J (J x) = -x

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

o.rightAngleRotation (o.rightAngleRotation x) = -x


@[simp]
theorem equivMapDomain_refl (l : α →₀ M) : equivMapDomain (Equiv.refl _) l = l

{α : Type u_1}
{M : Type u_5}
[Zero M]
(l : α →₀ M)

Finsupp.equivMapDomain (Equiv.refl α) l = l


/-- Given a splitting Cartan subalgebra `H` of a finite-dimensional Lie algebra with non-singular
Killing form, the corresponding roots span the dual space of `H`. -/
@[simp]
lemma span_weight_eq_top :
    span K (range (Weight.toLinear K H L)) = ⊤

(K : Type u_2)
(L : Type u_3)
[LieRing L]
[Field K]
[LieAlgebra K L]
[FiniteDimensional K L]
(H : LieSubalgebra K L)
[H.IsCartanSubalgebra]
[LieModule.IsTriangularizable K (↥H) L]
[LieAlgebra.IsKilling K L]

Submodule.span K (Set.range (LieModule.Weight.toLinear K (↥H) L)) = ⊤


@[simp]
lemma stalkMap_inv_hom_apply (e : X ≅ Y) (x : X) (y) :
    e.hom.stalkMap x (e.inv.stalkMap (e.hom.val.base x) y) =
      X.presheaf.stalkSpecializes (specializes_of_eq <| by simp) y

(y : ↑(X.presheaf.stalk (e.inv.val.base (e.hom.val.base x))))

(AlgebraicGeometry.Scheme.Hom.stalkMap e.hom x) ((AlgebraicGeometry.Scheme.Hom.stalkMap e.inv (e.hom.val.base x)) y) =
  (X.presheaf.stalkSpecializes ⋯) y


lemma comp_mem (W : MorphismProperty C) [W.IsStableUnderComposition]
    {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (hf : W f) (hg : W g) : W (f ≫ g)

{C : Type u}
[CategoryTheory.Category.{v, u} C]
(W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderComposition]
{X Y Z : C}
(f : X ⟶ Y)
(g : Y ⟶ Z)
(hf : W f)
(hg : W g)

W (CategoryTheory.CategoryStruct.comp f g)


theorem val_smul (n : ℕ) (r : R) (f : AdicCompletion I M) : (r • f).val n = r • f.val n

{R : Type u_1}
[CommRing R]
{I : Ideal R}
{M : Type u_2}
[AddCommGroup M]
[Module R M]
(n : ℕ)
(r : R)
(f : AdicCompletion I M)


theorem inverse_domain : (inverse f).domain = LinearMap.range f.toFun

{R : Type u_1}
[Ring R]
{E : Type u_2}
[AddCommGroup E]
[Module R E]
{F : Type u_3}
[AddCommGroup F]
[Module R F]
{f : E →ₗ.[R] F}

f.inverse.domain = LinearMap.range f.toFun


lemma posSMulMono_iff_posSMulStrictMono : PosSMulMono α β ↔ PosSMulStrictMono α β

{α : Type u_1}
{β : Type u_2}
[Semiring α]
[AddCommGroup β]
[Module α β]
[NoZeroSMulDivisors α β]
[PartialOrder α]
[PartialOrder β]


@[to_additive]
theorem set_subsingleton (h : UniqueMul A B a0 b0) :
    Set.Subsingleton { ab : G × G | ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0 }

{G : Type u_1}
[Mul G]
{A B : Finset G}
{a0 b0 : G}
(h : UniqueMul A B a0 b0)

{ab | ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0}.Subsingleton


@[simp]
theorem mem_localizationLocalizationSubmodule {x : R} :
    x ∈ localizationLocalizationSubmodule M N ↔
      ∃ (y : N) (z : M), algebraMap R S x = y * algebraMap R S z

{R : Type u_1}
[CommSemiring R]
{M : Submonoid R}
{S : Type u_2}
[CommSemiring S]
[Algebra R S]
{N : Submonoid S}
{x : R}

x ∈ IsLocalization.localizationLocalizationSubmodule M N ↔ ∃ y z, (algebraMap R S) x = ↑y * (algebraMap R S) ↑z


theorem setLIntegral_compProd_univ_right (κ : Kernel α β) [IsSFiniteKernel κ]
    (η : Kernel (α × β) γ) [IsSFiniteKernel η] (a : α) {f : β × γ → ℝ≥0∞} (hf : Measurable f)
    {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ z in s ×ˢ Set.univ, f z ∂(κ ⊗ₖ η) a = ∫⁻ x in s, ∫⁻ y, f (x, y) ∂η (a, x) ∂κ a

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

{f : β × γ → ℝ≥0∞}

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


theorem symm_bijective : Function.Bijective (RingEquiv.symm : (R ≃+* S) → S ≃+* R)

{R : Type u_4}
{S : Type u_5}
[Mul R]
[Mul S]
[Add R]
[Add S]


@[to_additive]
lemma IsOfFinOrder.mem_zpowers_iff_mem_range_orderOf [DecidableEq G] (hx : IsOfFinOrder x) :
    y ∈ zpowers x ↔ y ∈ (Finset.range (orderOf x)).image (x ^ ·)

{G : Type u_1}
[Group G]
{x y : G}
[DecidableEq G]
(hx : IsOfFinOrder x)

y ∈ Subgroup.zpowers x ↔ y ∈ Finset.image (fun x_1 => x ^ x_1) (Finset.range (orderOf x))


@[to_additive]
protected theorem finset_prod {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
    {s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) :
    ProgMeasurable f fun i a => ∏ c ∈ s, U c i a

{U : γ → ι → Ω → β}

(h : ∀ c ∈ s, MeasureTheory.ProgMeasurable f (U c))

MeasureTheory.ProgMeasurable f fun i a => ∑ c ∈ s, U c i a


@[norm_cast]
lemma ofNat_isUnit {n : ℕ} : IsUnit (n : ℤ) ↔ IsUnit n


/-- Any large enough family of vectors in `R^n` has a pair of elements
whose remainders are close together, pointwise. -/
theorem exists_approx_aux (n : ℕ) (h : abv.IsAdmissible) :
    ∀ {ε : ℝ} (_hε : 0 < ε) {b : R} (_hb : b ≠ 0) (A : Fin (h.card ε ^ n).succ → Fin n → R),
      ∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ k, (abv (A i₁ k % b - A i₀ k % b) : ℝ) < abv b • ε

∃ i₀ i₁, i₀ ≠ i₁ ∧ ∀ (k : Fin n), ↑(abv (A i₁ k % b - A i₀ k % b)) < abv b • ε


@[simp]
theorem toENNRealVectorMeasure_zero : (0 : Measure α).toENNRealVectorMeasure = 0

MeasureTheory.Measure.toENNRealVectorMeasure 0 = 0


@[to_additive]
theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type*} [CommMonoid M]
    {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1) :
    (mulSingle k u : I → M) * mulSingle l v = mulSingle m u * mulSingle n v ↔
      k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u * v = 1 ∧ k = l ∧ m = n

{I : Type u}
[DecidableEq I]
{M : Type u_3}
[AddCommMonoid M]
{k l m n : I}
{u v : M}
(hu : u ≠ 0)
(hv : v ≠ 0)

Pi.single k u + Pi.single l v = Pi.single m u + Pi.single n v ↔
  k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n


theorem denseRange_coe : DenseRange ((↑) : α → Completion α)


theorem sub_smul (r s : R) (y : M) : (r - s) • y = r • y - s • y

{R : Type u_2}
{M : Type u_5}
[Ring R]
[AddCommGroup M]
[Module R M]
(r s : R)
(y : M)


theorem integrable_smul_measure {f : α → β} {c : ℝ≥0∞} (h₁ : c ≠ 0) (h₂ : c ≠ ∞) :
    Integrable f (c • μ) ↔ Integrable f μ

{α : Type u_1}
{β : Type u_2}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup β]
{f : α → β}
{c : ℝ≥0∞}
(h₁ : c ≠ 0)
(h₂ : c ≠ ⊤)

MeasureTheory.Integrable f (c • μ) ↔ MeasureTheory.Integrable f μ


theorem injective (f : M ↪[L] N) : Function.Injective f

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


protected lemma leibniz_lie (x : L) (D₁ D₂ : LieDerivation R L L) :
    ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆

(R : Type u_1)
(L : Type u_2)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(x : L)
(D₁ D₂ : LieDerivation R L L)


@[simp] lemma floorRoot_eq_zero : floorRoot n a = 0 ↔ n = 0 ∨ a = 0


theorem charpoly_sub_diagonal_degree_lt :
    (M.charpoly - ∏ i : n, (X - C (M i i))).degree < ↑(Fintype.card n - 1)

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

(M.charpoly - ∏ i : n, (Polynomial.X - Polynomial.C (M i i))).degree < ↑(Fintype.card n - 1)


theorem Icc_subset_Icc_left (h : a₁ ≤ a₂) : Icc a₂ b ⊆ Icc a₁ b

{α : Type u_2}
[Preorder α]
[LocallyFiniteOrder α]
{a₁ a₂ b : α}
(h : a₁ ≤ a₂)


@[to_additive (attr := simp)]
lemma mulEquivOfOrderOfEq_symm :
    (mulEquivOfOrderOfEq hg hg' h).symm = mulEquivOfOrderOfEq hg' hg h.symm

(hg : ∀ (x : G), x ∈ Subgroup.zpowers g)

(hg' : ∀ (x : G'), x ∈ Subgroup.zpowers g')

(mulEquivOfOrderOfEq hg hg' h).symm = mulEquivOfOrderOfEq hg' hg ⋯


lemma isTorsionBySet_quotient_ideal_smul :
    IsTorsionBySet R (M⧸I • (⊤ : Submodule R M)) I

{R : Type u_1}
(M : Type u_2)
[CommRing R]
[AddCommGroup M]
[Module R M]
(I : Ideal R)


@[to_additive]
theorem MonoidHom.functions_ext [Finite I] (G : Type*) [CommMonoid G] (g h : (∀ i, Z i) →* G)
    (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h

(H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x))


theorem invOf_mul_self [Mul α] [One α] (a : α) [Invertible a] : ⅟ a * a = 1

{α : Type u}
[Mul α]
[One α]
(a : α)
[Invertible a]


theorem isPrenex_toPrenexImp {φ ψ : L.BoundedFormula α n} (hφ : IsPrenex φ) (hψ : IsPrenex ψ) :
    IsPrenex (φ.toPrenexImp ψ)

{L : FirstOrder.Language}
{α : Type u'}
{n : ℕ}
{φ ψ : L.BoundedFormula α n}
(hφ : φ.IsPrenex)
(hψ : ψ.IsPrenex)


theorem gal_prod_isSolvable {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable (Gal p)) :
    IsSolvable s.prod.Gal

{F : Type u_1}
[Field F]
{s : Multiset F[X]}
(hs : ∀ p ∈ s, IsSolvable p.Gal)


theorem isOpen_iff (U : Set D.glued.carrier) : IsOpen U ↔ ∀ i, IsOpen ((D.ι i).1.base ⁻¹' U)

(D : AlgebraicGeometry.Scheme.GlueData)
(U : Set ↑↑D.glued.toPresheafedSpace)

IsOpen U ↔ ∀ (i : D.J), IsOpen (⇑(D.ι i).val.base ⁻¹' U)


lemma IsPullback.iff_of_iso {sq₁ sq₂ : Square C} (e : sq₁ ≅ sq₂) :
    sq₁.IsPullback ↔ sq₂.IsPullback

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{sq₁ sq₂ : CategoryTheory.Square C}
(e : sq₁ ≅ sq₂)


lemma isWeaklyRegular_singleton_iff (r : R) :
    IsWeaklyRegular M [r] ↔ IsSMulRegular M r

{R : Type u_1}
(M : Type u_3)
[CommRing R]
[AddCommGroup M]
[Module R M]
(r : R)

RingTheory.Sequence.IsWeaklyRegular M [r] ↔ IsSMulRegular M r


@[simp]
theorem equivOfMinpoly_gen (pb : PowerBasis A S) (pb' : PowerBasis A S')
    (h : minpoly A pb.gen = minpoly A pb'.gen) : pb.equivOfMinpoly pb' h pb.gen = pb'.gen

(pb.equivOfMinpoly pb' h) pb.gen = pb'.gen


lemma isReduced_iff : P.IsReduced ↔ ∀ i j : ι, i ≠ j →
    ¬ LinearIndependent R ![P.root i, P.root j] → P.root i = - P.root j

{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
{N : Type u_4}
[CommRing R]
[AddCommGroup M]
[Module R M]
[AddCommGroup N]
[Module R N]
(P : RootPairing ι R M N)

P.IsReduced ↔ ∀ (i j : ι), i ≠ j → ¬LinearIndependent R ![P.root i, P.root j] → P.root i = -P.root j


theorem getElem?_range' (s step) :
    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)

m < n → (List.range' s n step)[m]? = some (s + step * m)


theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure

(μ : MeasureTheory.VectorMeasure α ℝ≥0∞)


theorem RelEmbedding.image_maximals_eq (f : r ↪r s) (x : Set α) :
    f '' maximals r x = maximals s (f '' x)

{α : Type u_1}
{β : Type u_2}
{r : α → α → Prop}
{s : β → β → Prop}
(f : r ↪r s)
(x : Set α)

⇑f '' maximals r x = maximals s (⇑f '' x)


theorem smul_apply (b : R) (v : ⨁ i, M i) (i : ι) : (b • v) i = b • v i

{R : Type u}
[Semiring R]
{ι : Type v}
{M : ι → Type w}
[(i : ι) → AddCommMonoid (M i)]
[(i : ι) → Module R (M i)]
(b : R)
(v : DirectSum ι fun i => M i)
(i : ι)


@[simp]
theorem coe_Iio (a : α) : ↑(Iio a) = Set.Iio a


theorem not_prime_mul {a b : ℕ} (a1 : a ≠ 1) (b1 : b ≠ 1) : ¬Prime (a * b)


theorem comap_lift'_eq2 {m : β → α} {g : Set β → Set γ} (hg : Monotone g) :
    (comap m f).lift' g = f.lift' (g ∘ preimage m)

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

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


@[simp] theorem findSome?_replicate_of_pos (h : 0 < n) : findSome? f (replicate n a) = f a

∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {a : α}, 0 < n → List.findSome? f (List.replicate n a) = f a


theorem of_a_eq_zero (ha : P.a = 0) : P.toPoly = C P.b * X ^ 2 + C P.c * X + C P.d

{R : Type u_1}
{P : Cubic R}
[Semiring R]
(ha : P.a = 0)

P.toPoly = Polynomial.C P.b * Polynomial.X ^ 2 + Polynomial.C P.c * Polynomial.X + Polynomial.C P.d


@[gcongr]
theorem max_le_max : a ≤ c → b ≤ d → max a b ≤ max c d

{α : Type u}
[LinearOrder α]
{a b c d : α}


/-- The equivalence of categories between `(A ⥤ B) × (A ⥤ C)` and `A ⥤ (B × C)` -/
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C

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

(CategoryTheory.functorProdFunctorEquiv A B C).counitIso = CategoryTheory.functorProdFunctorEquivCounitIso A B C


theorem eqOn (h : RightInvOn f' f t) : EqOn (f ∘ f') id t

{α : Type u_1}
{β : Type u_2}
{t : Set β}
{f : α → β}
{f' : β → α}
(h : Set.RightInvOn f' f t)


lemma primeFactors_mul (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).primeFactors = a.primeFactors ∪ b.primeFactors


theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ (range m)ᶜ ∈ f

{α : Type u}
{β : Type v}
{f : Filter β}
{m : α → β}

Filter.comap m f = ⊥ ↔ (Set.range m)ᶜ ∈ f


@[to_additive (attr := simp)]
theorem mker_inl : mker (inl M N) = ⊥

{M : Type u_1}
{N : Type u_2}
[MulOneClass M]
[MulOneClass N]


@[simp] theorem toZeroAtInftyCLM_apply (f : 𝓢(E, F)) (x : E) : toZeroAtInftyCLM 𝕜 E F f x = f x

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

((SchwartzMap.toZeroAtInftyCLM 𝕜 E F) f) x = f x


theorem Ico_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Ico a c ∈ 𝓝[>] b

{α : Type u}
[TopologicalSpace α]
[LinearOrder α]
[ClosedIciTopology α]
{a b c : α}
(H : b ∈ Set.Ico a c)


theorem sumCompl_symm_apply_of_not_mem {α : Type u} {s : Set α} [DecidablePred (· ∈ s)] {x : α}
    (hx : x ∉ s) : (Equiv.Set.sumCompl s).symm x = Sum.inr ⟨x, hx⟩

{α : Type u}
{s : Set α}
[DecidablePred fun x => x ∈ s]
{x : α}
(hx : x ∉ s)


theorem integral_comp_inv_mul_right (g : ℝ → F) (a : ℝ) :
    (∫ x : ℝ, g (x * a⁻¹)) = |a| • ∫ y : ℝ, g y

{F : Type u_2}
[NormedAddCommGroup F]
[NormedSpace ℝ F]
(g : ℝ → F)
(a : ℝ)

∫ (x : ℝ), g (x * a⁻¹) = |a| • ∫ (y : ℝ), g y


/-- Diagonal matrices are generated by the `Matrix.diagonal` of their `Matrix.diag`. -/
theorem IsDiag.diagonal_diag [Zero α] [DecidableEq n] {A : Matrix n n α} (h : A.IsDiag) :
    diagonal (diag A) = A

{α : Type u_1}
{n : Type u_4}
[Zero α]
[DecidableEq n]
{A : Matrix n n α}
(h : A.IsDiag)


theorem perm_append_comm : ∀ {l₁ l₂ : List α}, l₁ ++ l₂ ~ l₂ ++ l₁


@[simp]
theorem radius_neg (p : FormalMultilinearSeries 𝕜 E F) : (-p).radius = p.radius

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F)


/--
Two linear maps `S` and `T` are equal, if and only if the identity `⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ` holds
for all `x`.
-/
theorem ext_inner_map (S T : V →ₗ[ℂ] V) : (∀ x : V, ⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ) ↔ S = T

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

(∀ (x : V), ⟪S x, x⟫_ℂ = ⟪T x, x⟫_ℂ) ↔ S = T


/-- Transport a `HasLimitsOfShape` instance across an equivalence. -/
theorem hasLimitsOfShape_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfShape J C] :
    HasLimitsOfShape J D


theorem of_arrow_iso_right {A B X Y X' Y' : C} (i : A ⟶ B) {p : X ⟶ Y} {p' : X' ⟶ Y'}
    (e : Arrow.mk p ≅ Arrow.mk p') [hip : HasLiftingProperty i p] : HasLiftingProperty i p'

(e : CategoryTheory.Arrow.mk p ≅ CategoryTheory.Arrow.mk p')

[hip : CategoryTheory.HasLiftingProperty i p]


/-- The unit for the tensor `X ⊗ Y` in `Dial C`. -/
@[simps] def tensorUnit : Dial C

CategoryTheory.Dial.tensorUnit.src = ⊤_ C


@[ext] theorem ext {e₁ e₂ : α ≃ᵐ β} (h : (e₁ : α → β) = e₂) : e₁ = e₂

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[MeasurableSpace β]
{e₁ e₂ : α ≃ᵐ β}
(h : ⇑e₁ = ⇑e₂)


@[to_additive]
theorem prod_extend_by_one [DecidableEq α] (s : Finset α) (f : α → β) :
    ∏ i ∈ s, (if i ∈ s then f i else 1) = ∏ i ∈ s, f i

{α : Type u_3}
{β : Type u_4}
[CommMonoid β]
[DecidableEq α]
(s : Finset α)
(f : α → β)

(∏ i ∈ s, if i ∈ s then f i else 1) = ∏ i ∈ s, f i


@[simp] lemma forgetToTop_of (α : Type*) [TopologicalSpace α] [AlexandrovDiscrete α] :
  (forget₂ AlexDisc TopCat).obj (of α) = TopCat.of α

(α : Type u_1)
[TopologicalSpace α]
[AlexandrovDiscrete α]

(CategoryTheory.forget₂ AlexDisc TopCat).obj (AlexDisc.of α) = TopCat.of α


@[simps]
instance right' (X Y : C) [MonoidalCoherence X Y] :
    MonoidalCoherence X (Y ⊗ 𝟙_ C)

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


/-- The closures of supports of smooth bump functions centered at `c` form a basis of `𝓝 c`.
In other words, each of these closures is a neighborhood of `c` and each neighborhood of `c`
includes `tsupport f` for some `f : SmoothBumpFunction I c`. -/
theorem nhds_basis_tsupport :
    (𝓝 c).HasBasis (fun _ : SmoothBumpFunction I c => True) fun f => tsupport f

{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[FiniteDimensional ℝ E]
{H : Type uH}
[TopologicalSpace H]
(I : ModelWithCorners ℝ E H)
{M : Type uM}
[TopologicalSpace M]
[ChartedSpace H M]
(c : M)
[T2Space M]

(𝓝 c).HasBasis (fun x => True) fun f => tsupport ↑f


theorem image2_inter_subset_right : image2 f s (t ∩ t') ⊆ image2 f s t ∩ image2 f s t'

{α : Type u_1}
{β : Type u_3}
{γ : Type u_5}
{f : α → β → γ}
{s : Set α}
{t t' : Set β}

Set.image2 f s (t ∩ t') ⊆ Set.image2 f s t ∩ Set.image2 f s t'


/-- If `a`, `b`, `c` are consecutive and `a < x < c` then `x = b`. -/
theorem CovBy.eq_of_between {x : α} (hab : a ⋖ b) (hbc : b ⋖ c) (hax : a < x) (hxc : x < c) :
    x = b

{α : Type u_1}
[LinearOrder α]
{a b c x : α}
(hab : a ⋖ b)
(hbc : b ⋖ c)
(hax : a < x)
(hxc : x < c)


theorem coeFn_abs (f : Lp E p μ) : ⇑|f| =ᵐ[μ] fun x => |f x|

{α : Type u_1}
{E : Type u_2}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{p : ℝ≥0∞}
[NormedLatticeAddCommGroup E]
(f : ↥(MeasureTheory.Lp E p μ))


/-- Given a function such that `f` and `x ^ (k + l) * f` are bounded for a suitable `l`, then
`x ^ k * f` is integrable. The bounds are not relevant for the integrability conclusion, but they
are relevant for bounding the integral in `integral_pow_mul_le_of_le_of_pow_mul_le`. We formulate
the two lemmas with the same set of assumptions for ease of applications. -/
lemma integrable_of_le_of_pow_mul_le
    {μ : Measure D} [μ.HasTemperateGrowth] {f : D → E} {C₁ C₂ : ℝ} {k : ℕ}
    (hf : ∀ x, ‖f x‖ ≤ C₁) (h'f : ∀ x, ‖x‖ ^ (k + μ.integrablePower) * ‖f x‖ ≤ C₂)
    (h''f : AEStronglyMeasurable f μ) :
    Integrable (fun x ↦ ‖x‖ ^ k * ‖f x‖) μ

(h'f : ∀ (x : D), ‖x‖ ^ (k + μ.integrablePower) * ‖f x‖ ≤ C₂)

(h''f : MeasureTheory.AEStronglyMeasurable f μ)

MeasureTheory.Integrable (fun x => ‖x‖ ^ k * ‖f x‖) μ


theorem isOpenMap_coe : IsOpenMap ((↑) : X → OnePoint X)


@[simp]
theorem if_false_left [h : Decidable p] :
    ite p False q ↔ ¬p ∧ q


/-- The `0` power series is the unique power series with infinite order. -/
@[simp]
theorem order_eq_top {φ : R⟦X⟧} : φ.order = ⊤ ↔ φ = 0

{R : Type u_1}
[Semiring R]
{φ : PowerSeries R}


theorem det_pos [DecidableEq n] {M : Matrix n n 𝕜} (hM : M.PosDef) : 0 < det M

{n : Type u_2}
{𝕜 : Type u_4}
[Fintype n]
[RCLike 𝕜]
[DecidableEq n]
{M : Matrix n n 𝕜}
(hM : M.PosDef)


/-- If two Coxeter systems on the same group `W` have the same Coxeter matrix `M : Matrix B B ℕ`
and the same simple reflection map `B → W`, then they are identical. -/
theorem simple_determines_coxeterSystem :
    Injective (simple : CoxeterSystem M W → B → W)

{B : Type u_1}
{W : Type u_3}
[Group W]
{M : CoxeterMatrix B}


@[to_additive]
theorem one_mem_one [One α] : (1 : α) ∈ (1 : Part α)


/-- The range of the adjoint action homomorphism from a Lie algebra `L` to the Lie algebra of its
derivations is an ideal of the latter. -/
lemma ad_isIdealMorphism : (ad R L).IsIdealMorphism

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


theorem aecover_Ioi_of_Ici : AECover (μ.restrict (Ioi A)) l fun i ↦ Ici (a i)

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

MeasureTheory.AECover (μ.restrict (Set.Ioi A)) l fun i => Set.Ici (a i)


@[simp]
theorem prod'_μ (X Y : C) : (F.prod' G).μ X Y = (F.μ X Y, G.μ X Y)

(F : CategoryTheory.LaxMonoidalFunctor C D)

(G : CategoryTheory.LaxMonoidalFunctor C E)


lemma cancel_left {g : β →*₀ γ} {f₁ f₂ : α →*₀ β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[MulZeroOneClass α]
[MulZeroOneClass β]
[MulZeroOneClass γ]
{g : β →*₀ γ}
{f₁ f₂ : α →*₀ β}
(hg : Function.Injective ⇑g)


theorem singleton_injective : Injective fun a : α => [a]


/-- A domain that is not (left) Ore is of infinite rank.
See [cohn_1995] Proposition 1.3.6 -/
lemma aleph0_le_rank_of_isEmpty_oreSet (hS : IsEmpty (OreLocalization.OreSet R⁰)) :
    ℵ₀ ≤ Module.rank R R


theorem mem_iff {r : R} {a : A} : r ∈ σ a ↔ ¬IsUnit (↑ₐ r - a)

{R : Type u}
{A : Type v}
[CommSemiring R]
[Ring A]
[Algebra R A]
{r : R}
{a : A}

r ∈ spectrum R a ↔ ¬IsUnit ((algebraMap R A) r - a)


theorem factorThruImage_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : factorThruImage φ = e

{i : CategoryTheory.Limits.image φ ⟶ Δ''}

CategoryTheory.Limits.factorThruImage φ = e


@[simp]
theorem toDualTopEquiv_symm_bot [LE α] : WithBot.toDualTopEquiv.symm (⊥ : (WithTop α)ᵒᵈ) = ⊥


theorem mem_toAddSubmonoid {s : Subsemiring R} {x : R} : x ∈ s.toAddSubmonoid ↔ x ∈ s

{R : Type u}
[NonAssocSemiring R]
{s : Subsemiring R}
{x : R}


@[simp] lemma not_cast_lt_zero : ¬(q : K) < 0

{K : Type u_5}
[LinearOrderedSemifield K]
{q : ℚ≥0}


theorem range_coe : (f.range : Set β) = range f

{α : Type u_1}
{β : Type u_2}
[CompleteLattice α]
[CompleteLattice β]
(f : CompleteLatticeHom α β)


theorem take_reverse {α} {xs : List α} (n : Nat) (h : n ≤ xs.length) :
    xs.reverse.take n = (xs.drop (xs.length - n)).reverse

{α : Type u_1}
{xs : List α}
(n : Nat)
(h : n ≤ xs.length)

List.take n xs.reverse = (List.drop (xs.length - n) xs).reverse


@[measurability, fun_prop]
theorem Measurable.ereal_toReal {f : α → EReal} (hf : Measurable f) :
    Measurable fun x => (f x).toReal

{α : Type u_1}
[MeasurableSpace α]
{f : α → EReal}
(hf : Measurable f)


protected theorem lipschitz : LipschitzWith ‖(e : E →SL[σ₁₂] F)‖₊ e

{𝕜 : Type u_1}
{𝕜₂ : Type u_2}
{E : Type u_4}
{F : Type u_6}
[SeminormedAddCommGroup E]
[SeminormedAddCommGroup F]
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜₂]
[NormedSpace 𝕜 E]
[NormedSpace 𝕜₂ F]
{σ₁₂ : 𝕜 →+* 𝕜₂}
{σ₂₁ : 𝕜₂ →+* 𝕜}
[RingHomInvPair σ₁₂ σ₂₁]
[RingHomInvPair σ₂₁ σ₁₂]
[RingHomIsometric σ₁₂]
(e : E ≃SL[σ₁₂] F)


theorem sInf_add' {n : ℕ} {p : ℕ → Prop} (h : 0 < sInf { m | p m }) :
    sInf { m | p m } + n = sInf { m | p (m - n) }

{n : ℕ}
{p : ℕ → Prop}
(h : 0 < sInf {m | p m})

sInf {m | p m} + n = sInf {m | p (m - n)}


/-- A set of linearly independent vectors in a module `M` over a semiring `K` is also linearly
independent over a subring `R` of `K`.
The implementation uses minimal assumptions about the relationship between `R`, `K` and `M`.
The version where `K` is an `R`-algebra is `LinearIndependent.restrict_scalars_algebras`.
 -/
theorem LinearIndependent.restrict_scalars [Semiring K] [SMulWithZero R K] [Module K M]
    [IsScalarTower R K M] (hinj : Function.Injective fun r : R => r • (1 : K))
    (li : LinearIndependent K v) : LinearIndependent R v

(hinj : Function.Injective fun r => r • 1)


@[simp] lemma inf_apply (f g : C(α, β)) (a : α) : (f ⊓ g) a = f a ⊓ g a

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
[SemilatticeInf β]
[ContinuousInf β]
(f g : C(α, β))
(a : α)


/-- If two mul homomorphisms are equal on a set, then they are equal on its subsemigroup closure. -/
@[to_additive "If two add homomorphisms are equal on a set,
  then they are equal on its additive subsemigroup closure."]
theorem eqOn_closure {f g : M →ₙ* N} {s : Set M} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure s)

{M : Type u_1}
{N : Type u_2}
[Add M]
[Add N]
{f g : AddHom M N}
{s : Set M}
(h : Set.EqOn (⇑f) (⇑g) s)

Set.EqOn ⇑f ⇑g ↑(AddSubsemigroup.closure s)


theorem piecewise_ae_eq_restrict_compl [DecidablePred (· ∈ s)] (hs : MeasurableSet s) :
    piecewise s f g =ᵐ[μ.restrict sᶜ] g

{α : Type u_2}
{β : Type u_3}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
{s : Set α}
{f g : α → β}
[DecidablePred fun x => x ∈ s]
(hs : MeasurableSet s)


@[simp]
lemma addOppositeEquiv_symm_support (x : (HahnSeries Γ R)ᵃᵒᵖ) :
    (addOppositeEquiv.symm x).support = x.unop.support

{Γ : Type u_1}
{R : Type u_2}
[PartialOrder Γ]
[AddMonoid R]
(x : (HahnSeries Γ R)ᵃᵒᵖ)

(HahnSeries.addOppositeEquiv.symm x).support = (AddOpposite.unop x).support


@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem pow_mem {M A} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M}
    (hx : x ∈ S) : ∀ n : ℕ, x ^ n ∈ S

{M : Type u_4}
{A : Type u_5}
[Monoid M]
[SetLike A M]
[SubmonoidClass A M]
{S : A}
{x : M}
(hx : x ∈ S)
(n : ℕ)


theorem comp_prod_comp_same (f₁ f₂ : β →o γ) (g : α →o β) :
    (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g

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


lemma constantCommuteComposeApp_comp_counit (F : Sheaf J A) :
    ((constantCommuteCompose J U).app _).hom ≫
      (constantSheafAdj J B ht).counit.app ((sheafCompose J U).obj F) =
        (sheafCompose J U).map ((constantSheafAdj J A ht).counit.app F)

(J : CategoryTheory.GrothendieckTopology C)

(ht : CategoryTheory.Limits.IsTerminal t)

((CategoryTheory.Sheaf.constantCommuteCompose J U).app (F.val.obj (Opposite.op t))).hom ≫
    (CategoryTheory.constantSheafAdj J B ht).counit.app ((CategoryTheory.sheafCompose J U).obj F) =
  (CategoryTheory.sheafCompose J U).map ((CategoryTheory.constantSheafAdj J A ht).counit.app F)


theorem mem_pNilradical {R : Type*} [CommSemiring R] {p : ℕ} {x : R} :
    x ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = 0

{R : Type u_1}
[CommSemiring R]
{p : ℕ}
{x : R}

x ∈ pNilradical R p ↔ ∃ n, x ^ p ^ n = 0


theorem nhds_injective [T0Space X] : Injective (𝓝 : X → Filter X)

{X : Type u_1}
[TopologicalSpace X]
[T0Space X]


theorem map_strictMono (f : α → β) : StrictMono (map f)


theorem trivializationAt_proj_fst {x : TotalSpace F E} :
    ((trivializationAt F E x.proj) x).1 = x.proj

[TopologicalSpace (Bundle.TotalSpace F E)]

(↑(trivializationAt F E x.proj) x).1 = x.proj


@[simp]
theorem cobounded_eq : Bornology.cobounded ℤ = atBot ⊔ atTop

Bornology.cobounded ℤ = Filter.atBot ⊔ Filter.atTop


@[simp]
theorem mk_add_mk (x y : ℕ × K) :
    mk K p x + mk K p y =
      mk K p (x.1 + y.1, (frobenius K p)^[y.1] x.2 + (frobenius K p)^[x.1] y.2)

(K : Type u)
[CommRing K]
(p : ℕ)
[Fact (Nat.Prime p)]
[CharP K p]
(x y : ℕ × K)

PerfectClosure.mk K p x + PerfectClosure.mk K p y =
  PerfectClosure.mk K p (x.1 + y.1, (⇑(frobenius K p))^[y.1] x.2 + (⇑(frobenius K p))^[x.1] y.2)


theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a

{α : Type u_1}
[Preorder α]
{a : α}
[PredOrder α]
[NoMinOrder α]
(h : Order.IsPredLimit a)
(b : α)


/-- A morphism constructed with `nullHomotopic` is homotopic to zero. -/
@[simps]
def ofNullHomotopic (h₀ : S₁.X₁ ⟶ S₂.X₁) (h₀_f : h₀ ≫ S₂.f = 0)
    (h₁ : S₁.X₂ ⟶ S₂.X₁) (h₂ : S₁.X₃ ⟶ S₂.X₂) (h₃ : S₁.X₃ ⟶ S₂.X₃) (g_h₃ : S₁.g ≫ h₃ = 0) :
  Homotopy (nullHomotopic _ _ h₀ h₀_f h₁ h₂ h₃ g_h₃) 0

(h₀_f : CategoryTheory.CategoryStruct.comp h₀ S₂.f = 0)

(g_h₃ : CategoryTheory.CategoryStruct.comp S₁.g h₃ = 0)

(CategoryTheory.ShortComplex.Homotopy.ofNullHomotopic S₁ S₂ h₀ h₀_f h₁ h₂ h₃ g_h₃).h₃ = h₃


@[simp]
lemma relativeDifferentials'_obj (X : Dᵒᵖ) :
    (relativeDifferentials' φ').obj X =
      CommRingCat.KaehlerDifferential (φ'.app X)

{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{S' R : Dᵒᵖ ⥤ CommRingCat}
(φ' : S' ⟶ R)
(X : Dᵒᵖ)

(PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').obj X =
  CommRingCat.KaehlerDifferential (φ'.app X)


theorem iUnion_inter_of_monotone {ι α} [Preorder ι] [IsDirected ι (· ≤ ·)] {s t : ι → Set α}
    (hs : Monotone s) (ht : Monotone t) : ⋃ i, s i ∩ t i = (⋃ i, s i) ∩ ⋃ i, t i

{ι : Type u_11}
{α : Type u_12}
[Preorder ι]
[IsDirected ι fun x x_1 => x ≤ x_1]
{s t : ι → Set α}
(hs : Monotone s)
(ht : Monotone t)


/-- The defining property of `OverArrows.val`. -/
lemma app_val {F : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {X : C} {s : yoneda.obj X ⟶ A}
    (p : OverArrows η s) : η.app (op X) p.val = yonedaEquiv s

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

(p : CategoryTheory.OverPresheafAux.OverArrows η s)

η.app (Opposite.op X) p.val = CategoryTheory.yonedaEquiv s


theorem pf_add_c [Add α] (p : a = b) (c : α) : a + c = b + c

{α : Type u_1}
{a b : α}
[Add α]
(p : a = b)
(c : α)


@[to_additive]
theorem comp₂_left (hf : HasCompactMulSupport f)
    (hf₂ : HasCompactMulSupport f₂) (hm : m 1 1 = 1) :
    HasCompactMulSupport fun x => m (f x) (f₂ x)

{α : Type u_2}
{β : Type u_4}
{γ : Type u_5}
{δ : Type u_6}
[TopologicalSpace α]
[Zero β]
[Zero γ]
[Zero δ]
{f : α → β}
{f₂ : α → γ}
{m : β → γ → δ}
(hf : HasCompactSupport f)
(hf₂ : HasCompactSupport f₂)
(hm : m 0 0 = 0)

HasCompactSupport fun x => m (f x) (f₂ x)


theorem Cotrident.IsColimit.hom_ext [Nonempty J] {s : Cotrident f} (hs : IsColimit s) {W : C}
    {k l : s.pt ⟶ W} (h : s.π ≫ k = s.π ≫ l) : k = l

(hs : CategoryTheory.Limits.IsColimit s)

(h : CategoryTheory.CategoryStruct.comp s.π k = CategoryTheory.CategoryStruct.comp s.π l)


@[to_additive]
theorem isometry_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a : M) :
    Isometry (a * ·)

{M : Type u}
[Mul M]
[PseudoEMetricSpace M]
[IsometricSMul M M]
(a : M)


theorem not_infinite_add {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : ¬Infinite (x + y)

{x y : ℝ*}
(hx : ¬x.Infinite)
(hy : ¬y.Infinite)


theorem lift_spec_mul_add {g : R →+* P} (hg : ∀ y : M, IsUnit (g y)) (z w w' v) :
    ((toLocalizationWithZeroMap M S).lift g.toMonoidWithZeroHom hg) z * w + w' = v ↔
      g ((toLocalizationMap M S).sec z).1 * w + g ((toLocalizationMap M S).sec z).2 * w' =
        g ((toLocalizationMap M S).sec z).2 * v

{R : Type u_1}
[CommSemiring R]
{M : Submonoid R}
{S : Type u_2}
[CommSemiring S]
[Algebra R S]
{P : Type u_3}
[CommSemiring P]
[IsLocalization M S]
{g : R →+* P}
(hg : ∀ (y : ↥M), IsUnit (g ↑y))
(z : S)
(w w' v : P)

((IsLocalization.toLocalizationWithZeroMap M S).lift g.toMonoidWithZeroHom hg) z * w + w' = v ↔
  g ((IsLocalization.toLocalizationMap M S).sec z).1 * w + g ↑((IsLocalization.toLocalizationMap M S).sec z).2 * w' =
    g ↑((IsLocalization.toLocalizationMap M S).sec z).2 * v


theorem nhds_basis_uniformity {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
    {x : α} : (𝓝 x).HasBasis p fun i => { y | (y, x) ∈ s i }

{α : Type ua}
{ι : Sort u_1}
[UniformSpace α]
{p : ι → Prop}
{s : ι → Set (α × α)}
(h : (𝓤 α).HasBasis p s)
{x : α}

(𝓝 x).HasBasis p fun i => {y | (y, x) ∈ s i}


theorem integer_eq :
    (S.integer K).toSubring =
      ⨅ (v) (_ : v ∉ S), (v : HeightOneSpectrum R).valuation.valuationSubring.toSubring

(S : Set (IsDedekindDomain.HeightOneSpectrum R))

(S.integer K).toSubring = ⨅ v, ⨅ (_ : v ∉ S), v.valuation.valuationSubring.toSubring


/-- An element can be compressed to any other element by removing/adding the differences. -/
@[simp]
theorem compress_sdiff_sdiff (a b : α) : compress (a \ b) (b \ a) b = a

{α : Type u_1}
[GeneralizedBooleanAlgebra α]
[DecidableRel Disjoint]
[DecidableRel fun x x_1 => x ≤ x_1]
(a b : α)


/-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_neg_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_le_one_div_of_neg (ha : a < 0) (hb : b < 0) : 1 / a ≤ 1 / b ↔ b ≤ a

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


@[simp]
theorem lTensorHomToHomLTensor_apply (p : P) (f : M →ₗ[R] Q) (m : M) :
    lTensorHomToHomLTensor R M P Q (p ⊗ₜ f) m = p ⊗ₜ f m

{R : Type u_1}
[CommSemiring R]
{M : Type u_4}
{P : Type u_6}
{Q : Type u_7}
[AddCommMonoid M]
[AddCommMonoid P]
[AddCommMonoid Q]
[Module R M]
[Module R P]
[Module R Q]
(p : P)
(f : M →ₗ[R] Q)
(m : M)

((TensorProduct.lTensorHomToHomLTensor R M P Q) (p ⊗ₜ[R] f)) m = p ⊗ₜ[R] f m


{R : Type r}
[CommRing R]
(W : WeierstrassCurve R)


/-- Reinterpret `G ≃* H` as `Additive G ≃+ Additive H`. -/
@[simps]
def MulEquiv.toAdditive [MulOneClass G] [MulOneClass H] :
    G ≃* H ≃ (Additive G ≃+ Additive H)

{G : Type u_1}
{H : Type u_2}
[MulOneClass G]
[MulOneClass H]
(f : G ≃* H)
(a : Additive H)

(MulEquiv.toAdditive f).symm a = (MonoidHom.toAdditive f.symm.toMonoidHom) a


theorem single_mul_apply_aux [Add G] (f : k[G]) (r : k) (x y z : G)
    (H : ∀ a, x + a = y ↔ a = z) : (single x r * f) y = r * f z

{k : Type u₁}
{G : Type u₂}
[Semiring k]
[Add G]
(f : AddMonoidAlgebra k G)
(r : k)
(x y z : G)
(H : ∀ (a : G), x + a = y ↔ a = z)

(AddMonoidAlgebra.single x r * f) y = r * f z


theorem eq_nil_of_length_zero {u v : U} (p : Path u v) (hzero : p.length = 0) :
    p.cast (eq_of_length_zero p hzero) rfl = Path.nil

{U : Type u_1}
[Quiver U]
{u v : U}
(p : Quiver.Path u v)
(hzero : p.length = 0)

Quiver.Path.cast ⋯ ⋯ p = Quiver.Path.nil


@[simp]
lemma starCenterIsoCentroid_symm_apply_coe (T : CentroidHom α) :
    ↑(CentroidHom.starCenterIsoCentroid.symm T) = T 1

{α : Type u_1}
[NonAssocSemiring α]
[StarRing α]
(T : CentroidHom α)


theorem map_le_iff_le_comap {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} {U : StarSubalgebra R B} :
    map f S ≤ U ↔ S ≤ comap f U

{R : Type u_2}
{A : Type u_3}
{B : Type u_4}
[CommSemiring R]
[StarRing R]
[Semiring A]
[StarRing A]
[Algebra R A]
[StarModule R A]
[Semiring B]
[StarRing B]
[Algebra R B]
[StarModule R B]
{S : StarSubalgebra R A}
{f : A →⋆ₐ[R] B}
{U : StarSubalgebra R B}

StarSubalgebra.map f S ≤ U ↔ S ≤ StarSubalgebra.comap f U


theorem ContDiffOn.clm_comp {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F} {s : Set X}
    (hg : ContDiffOn 𝕜 n g s) (hf : ContDiffOn 𝕜 n f s) :
    ContDiffOn 𝕜 n (fun x => (g x).comp (f x)) s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type uG}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{X : Type u_2}
[NormedAddCommGroup X]
[NormedSpace 𝕜 X]
{n : ℕ∞}
{g : X → F →L[𝕜] G}
{f : X → E →L[𝕜] F}
{s : Set X}
(hg : ContDiffOn 𝕜 n g s)
(hf : ContDiffOn 𝕜 n f s)


theorem map_singleton (f : α → β) (a : α) : map f [a] = [f a]

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


theorem coe_le_coe_add_dist {f g : α →ᵇ ℝ} : f x ≤ g x + dist f g

{α : Type u}
[TopologicalSpace α]
{x : α}
{f g : BoundedContinuousFunction α ℝ}


@[rclike_simps]
theorem zero_re' : re (0 : K) = (0 : ℝ)


theorem bot_lt_center [Nontrivial G] [Finite G] : ⊥ < Subgroup.center G

{p : ℕ}
{G : Type u_1}
[Group G]
(hG : IsPGroup p G)
[hp : Fact (Nat.Prime p)]
[Nontrivial G]
[Finite G]


theorem of_f {i j} (hij) (x) : of G f j (f i j hij x) = of G f i x

{ι : Type v}
[Preorder ι]
{G : ι → Type w}
[(i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j}
{i j : ι}
(hij : i ≤ j)
(x : G i)

(Ring.DirectLimit.of G f j) (f i j hij x) = (Ring.DirectLimit.of G f i) x


lemma mapsTo_biSup_of_mapsTo (s : Set ι) {f : Module.End R M} (hf : ∀ i, MapsTo f (N i) (N i)) :
    MapsTo f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)

(hf : ∀ (i : ι), Set.MapsTo ⇑f ↑(N i) ↑(N i))

Set.MapsTo ⇑f ↑(⨆ i ∈ s, N i) ↑(⨆ i ∈ s, N i)


lemma IsRatCondKernelCDF.tendsto_atBot_zero (hf : IsRatCondKernelCDF f κ ν) (a : α) :
    ∀ᵐ b ∂(ν a), Tendsto (f (a, b)) atBot (𝓝 0)

{κ : ProbabilityTheory.Kernel α (β × ℝ)}

{f : α × β → ℚ → ℝ}

(hf : ProbabilityTheory.IsRatCondKernelCDF f κ ν)

∀ᵐ (b : β) ∂ν a, Filter.Tendsto (f (a, b)) Filter.atBot (𝓝 0)


/-- For a presheaf `P`, consider the forgetful functor from the category of representable
    presheaves over `P` to the category of presheaves. There is a tautological cocone over this
    functor whose leg for a natural transformation `V ⟶ P` with `V` representable is just that
    natural transformation. -/
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda)

(P : CategoryTheory.Functor Cᵒᵖ (Type v₁))

(CategoryTheory.Presheaf.tautologicalCocone P).pt = P


@[simp]
lemma toColumns₁_fromColumns (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) :
    toColumns₁ (fromColumns A₁ A₂) = A₁

{R : Type u_1}
{m : Type u_2}
{n₁ : Type u_6}
{n₂ : Type u_7}
(A₁ : Matrix m n₁ R)
(A₂ : Matrix m n₂ R)


@[simp]
theorem map_eq_zero_iff [Nontrivial R] : I.map h = 0 ↔ I = 0

{R : Type u_1}
[CommRing R]
{K : Type u_3}
{K' : Type u_4}
[Field K]
[Field K']
[Algebra R K]
[IsFractionRing R K]
[Algebra R K']
[IsFractionRing R K']
{I : FractionalIdeal R⁰ K}
(h : K →ₐ[R] K')
[Nontrivial R]


lemma isLeftKanExtension_iff_isIso {F' : D ⥤ H} {F'' : D ⥤ H} (φ : F' ⟶ F'')
    {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') (α' : F ⟶ L ⋙ F'')
    (comm : α ≫ whiskerLeft L φ = α') [F'.IsLeftKanExtension α] :
    F''.IsLeftKanExtension α' ↔ IsIso φ

(comm : CategoryTheory.CategoryStruct.comp α (CategoryTheory.whiskerLeft L φ) = α')

F''.IsLeftKanExtension α' ↔ CategoryTheory.IsIso φ


/-- A monotone function is continuous to the left at a point if and only if its left limit
coincides with the value of the function. -/
theorem continuousWithinAt_Iio_iff_leftLim_eq :
    ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x

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

ContinuousWithinAt f (Set.Iio x) x ↔ Function.leftLim f x = f x


lemma epi_iff_inl_eq_inr (hc : IsColimit c) : Epi f ↔ c.inl = c.inr

{c : CategoryTheory.Limits.PushoutCocone f f}

(hc : CategoryTheory.Limits.IsColimit c)


@[simp]
theorem spanExt_app_one : (spanExt iX iY iZ wf wg).app WalkingSpan.zero = iX

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{X Y Z X' Y' Z' : C}
(iX : X ≅ X')
(iY : Y ≅ Y')
(iZ : Z ≅ Z')
{f : X ⟶ Y}
{g : X ⟶ Z}
{f' : X' ⟶ Y'}
{g' : X' ⟶ Z'}
(wf : iX.hom ≫ f' = f ≫ iY.hom)
(wg : iX.hom ≫ g' = g ≫ iZ.hom)

(CategoryTheory.Limits.spanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingSpan.zero = iX


@[simp]
theorem unop_inj_iff (x y : αᵒᵖ) : unop x = unop y ↔ x = y

Opposite.unop x = Opposite.unop y ↔ x = y


/-- Two subgroups are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubgroup`s are equal if they have the same elements."]
theorem ext {H K : Subgroup G} (h : ∀ x, x ∈ H ↔ x ∈ K) : H = K

{G : Type u_1}
[AddGroup G]
{H K : AddSubgroup G}
(h : ∀ (x : G), x ∈ H ↔ x ∈ K)


@[simp]
theorem map_zero : v 0 = (⊤ : Γ₀)

{R : Type u_3}
{Γ₀ : Type u_4}
[Ring R]
[LinearOrderedAddCommMonoidWithTop Γ₀]
(v : AddValuation R Γ₀)


/-- The third projection functor `ShortComplex C ⥤ C`. -/
@[simps]
def π₃ : ShortComplex C ⥤ C

∀ {X Y : CategoryTheory.ShortComplex C} (f : X ⟶ Y), CategoryTheory.ShortComplex.π₃.map f = f.τ₃


@[simp]
theorem coeff_fslope : p.fslope.coeff n = p.coeff (n + 1)

{𝕜 : Type u}
{E : Type v}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{p : FormalMultilinearSeries 𝕜 𝕜 E}
{n : ℕ}


theorem mod_eq_sub_mod {a b : Nat} (h : a ≥ b) : a % b = (a - b) % b


theorem comp_tail {α : Type*} {β : Type*} (g : α → β) (q : Fin n.succ → α) :
    g ∘ tail q = tail (g ∘ q)

{n : ℕ}
{α : Type u_1}
{β : Type u_2}
(g : α → β)
(q : Fin n.succ → α)


@[to_additive]
lemma mul_mem_units (S : Submonoid M) {x y : Mˣ} (h₁ : x ∈ S.units) (h₂ : y ∈ S.units) :
    x * y ∈ S.units

{M : Type u_1}
[AddMonoid M]
(S : AddSubmonoid M)
{x y : AddUnits M}
(h₁ : x ∈ S.addUnits)
(h₂ : y ∈ S.addUnits)


theorem isLeast_min' : IsLeast (↑s) (s.min' H)

{α : Type u_2}
[LinearOrder α]
(s : Finset α)
(H : s.Nonempty)


theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f

(F' : CategoryTheory.Limits.MonoFactorisation f)

ModuleCat.image.lift F' ≫ F'.m = ModuleCat.image.ι f


@[to_additive (attr := simp)]
theorem self_eq_mul_right : a = a * b ↔ b = 1

{M : Type u}
[AddLeftCancelMonoid M]
{a b : M}


@[norm_cast]
theorem coe_posPart (f : Lp ℝ p μ) : (posPart f : α →ₘ[μ] ℝ) = (f : α →ₘ[μ] ℝ).posPart

{α : Type u_1}
{m0 : MeasurableSpace α}
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
(f : ↥(MeasureTheory.Lp ℝ p μ))

↑(MeasureTheory.Lp.posPart f) = (↑f).posPart


@[reassoc]
theorem coprod.map_comp_id {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryCoproduct Z W]
    [HasBinaryCoproduct Y W] [HasBinaryCoproduct X W] :
    coprod.map (f ≫ g) (𝟙 W) = coprod.map f (𝟙 W) ≫ coprod.map g (𝟙 W)

CategoryTheory.Limits.coprod.map (f ≫ g) (𝟙 W) =
  CategoryTheory.Limits.coprod.map f (𝟙 W) ≫ CategoryTheory.Limits.coprod.map g (𝟙 W)


theorem isSheaf_coherent_iff_regular_and_extensive [Preregular C] [FinitaryPreExtensive C] :
    IsSheaf (coherentTopology C) F ↔
    IsSheaf (extensiveTopology C) F ∧ IsSheaf (regularTopology C) F

{C : Type u_1}
[CategoryTheory.Category.{u_3, u_1} C]
{A : Type u₃}
[CategoryTheory.Category.{v₃, u₃} A]
(F : CategoryTheory.Functor Cᵒᵖ A)
[CategoryTheory.Preregular C]
[CategoryTheory.FinitaryPreExtensive C]

CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.extensiveTopology C) F ∧
    CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F


@[to_additive sum_le_card_nsmul]
lemma prod_le_pow_card (s : Multiset α) (n : α) (h : ∀ x ∈ s, x ≤ n) : s.prod ≤ n ^ card s

{α : Type u_2}
[OrderedAddCommMonoid α]
(s : Multiset α)
(n : α)
(h : ∀ x ∈ s, x ≤ n)


theorem HasPoints.existsUnique_point [HasPoints P L] (l₁ l₂ : L) (hl : l₁ ≠ l₂) :
    ∃! p, p ∈ l₁ ∧ p ∈ l₂

(P : Type u_1)
(L : Type u_2)
[Membership P L]
[Configuration.HasPoints P L]
(l₁ l₂ : L)
(hl : l₁ ≠ l₂)


@[to_additive]
theorem mulIndicator_one_preimage (s : Set M) :
    t.mulIndicator 1 ⁻¹' s ∈ ({Set.univ, ∅} : Set (Set α))

{α : Type u_1}
{M : Type u_4}
[Zero M]
{t : Set α}
(s : Set M)


@[simp]
theorem LinearMap.coe_isometryOfInner (f : E →ₗ[𝕜] E') (h) : ⇑(f.isometryOfInner h) = f

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


@[simp]
theorem closure_submonoid_closure (s : Set R) : closure ↑(Submonoid.closure s) = closure s

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

Subsemiring.closure ↑(Submonoid.closure s) = Subsemiring.closure s


@[simp]
theorem self_le_sinh_iff : x ≤ sinh x ↔ 0 ≤ x


theorem parallelepiped_eq_sum_segment (v : ι → E) : parallelepiped v = ∑ i, segment ℝ 0 (v i)

{ι : Type u_1}
{E : Type u_3}
[Fintype ι]
[AddCommGroup E]
[Module ℝ E]
(v : ι → E)

parallelepiped v = ∑ i : ι, segment ℝ 0 (v i)


@[simp]
theorem map_map (f : R →+* S) (g : S →+* T) (x : ResidueField R) [IsLocalRingHom f]
    [IsLocalRingHom g] : map g (map f x) = map (g.comp f) x

{R : Type u_1}
{S : Type u_2}
{T : Type u_3}
[CommRing R]
[LocalRing R]
[CommRing S]
[LocalRing S]
[CommRing T]
[LocalRing T]
(f : R →+* S)
(g : S →+* T)
(x : LocalRing.ResidueField R)
[IsLocalRingHom f]
[IsLocalRingHom g]

(LocalRing.ResidueField.map g) ((LocalRing.ResidueField.map f) x) = (LocalRing.ResidueField.map (g.comp f)) x


/-- The kernel of `g.unop` is the opposite of `cokernel g`. -/
@[simps!]
def kernelUnopOp : Opposite.op (kernel g.unop) ≅ cokernel g

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
[CategoryTheory.Abelian C]
{A B : Cᵒᵖ}
(g : A ⟶ B)

(CategoryTheory.kernelUnopOp g).hom =
  (CategoryTheory.Limits.kernel.lift g.unop (CategoryTheory.Limits.cokernel.π g).unop ⋯).op


lemma biUnion_image_sup_left : s.biUnion (fun a ↦ t.image (a ⊔ ·)) = s ⊻ t

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

(s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t


lemma isCondKernelCDF_stieltjesOfMeasurableRat {f : α × β → ℚ → ℝ} (hf : IsRatCondKernelCDF f κ ν)
    [IsFiniteKernel κ] :
    IsCondKernelCDF (stieltjesOfMeasurableRat f hf.measurable) κ ν

{κ : ProbabilityTheory.Kernel α (β × ℝ)}

{f : α × β → ℚ → ℝ}

(hf : ProbabilityTheory.IsRatCondKernelCDF f κ ν)

ProbabilityTheory.IsCondKernelCDF (ProbabilityTheory.stieltjesOfMeasurableRat f ⋯) κ ν


/-- A lawful `Control.Monad` gives a category theory `Monad` on the category of types.
-/
@[simps!]
def ofTypeMonad : Monad (Type u)

(m : Type u → Type u)
[Monad m]
[LawfulMonad m]
{α : Type u}

∀ (a : α), (CategoryTheory.ofTypeMonad m).η.app α a = pure a


/-- A `PredOrder` is pred-archimedean if one can go from any two comparable elements by iterating
`pred` -/
class IsPredArchimedean (α : Type*) [Preorder α] [PredOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `b` from `a` by iterating `pred` -/
  exists_pred_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, pred^[n] b = a

{α : Type u_3}
[Preorder α]
[PredOrder α]
[self : IsPredArchimedean α]
{a b : α}
(h : a ≤ b)


theorem tsum_intervalIntegral_eq_of_summable_norm [Countable ι] {f : ι → C(ℝ, E)}
    (hf_sum : Summable fun i : ι => ‖(f i).restrict (⟨uIcc a b, isCompact_uIcc⟩ : Compacts ℝ)‖) :
    ∑' i : ι, ∫ x in a..b, f i x = ∫ x in a..b, ∑' i : ι, f i x

(hf_sum : Summable fun i => ‖ContinuousMap.restrict (↑{ carrier := Set.uIcc a b, isCompact' := ⋯ }) (f i)‖)


theorem card_eq_two_iff' (x : α) : Nat.card α = 2 ↔ ∃! y, y ≠ x


@[simp, norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α)


theorem subtype_specializes_iff {p : X → Prop} (x y : Subtype p) : x ⤳ y ↔ (x : X) ⤳ y

{X : Type u_1}
[TopologicalSpace X]
{p : X → Prop}
(x y : Subtype p)

x ⤳ y ↔ ↑x ⤳ ↑y


theorem splits_mul {f g : K[X]} (hf : Splits i f) (hg : Splits i g) : Splits i (f * g)

{K : Type v}
{L : Type w}
[CommRing K]
[Field L]
(i : K →+* L)
{f g : K[X]}
(hf : Polynomial.Splits i f)
(hg : Polynomial.Splits i g)


@[simp]
theorem toLinearMap_ofLinearMap (f : A →ₗ[R] B) (map_one) (map_mul) :
    toLinearMap (ofLinearMap f map_one map_mul) = f

(map_mul : ∀ (x y : A), f (x * y) = f x * f y)

(AlgHom.ofLinearMap f map_one map_mul).toLinearMap = f


theorem Ico_mem_nhdsSet_Ioc (h : a ≤ b) (h' : c < d) : Ico a d ∈ 𝓝ˢ (Ioc b c)

{α : Type u_1}
[LinearOrder α]
[TopologicalSpace α]
[OrderClosedTopology α]
{a b c d : α}
(h : a ≤ b)
(h' : c < d)


theorem iso_symm_comp : (iso S f).symm.toLinearMap.comp f = LocalizedModule.mkLinearMap S M

{R : Type u_1}
[CommSemiring R]
(S : Submonoid R)
{M : Type u_2}
{M' : Type u_3}
[AddCommMonoid M]
[AddCommMonoid M']
[Module R M]
[Module R M']
(f : M →ₗ[R] M')
[IsLocalizedModule S f]

↑(IsLocalizedModule.iso S f).symm ∘ₗ f = LocalizedModule.mkLinearMap S M


/-- A non-unital normed commutative ring is a non-unital commutative ring endowed with a
norm which satisfies the inequality `‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class NonUnitalNormedCommRing (α : Type*) extends NonUnitalNormedRing α where
  /-- Multiplication is commutative. -/
  mul_comm : ∀ x y : α, x * y = y * x

{α : Type u_5}
[self : NonUnitalNormedCommRing α]
(x y : α)


theorem InfinitePos.neg {x : ℝ*} : InfinitePos x → InfiniteNeg (-x)


/-- `Part` extensionality -/
theorem ext' : ∀ {o p : Part α}, (o.Dom ↔ p.Dom) → (∀ h₁ h₂, o.get h₁ = p.get h₂) → o = p

(o.Dom ↔ p.Dom) → (∀ (h₁ : o.Dom) (h₂ : p.Dom), o.get h₁ = p.get h₂) → o = p


theorem zpow_neg {A : M} (h : IsUnit A.det) : ∀ n : ℤ, A ^ (-n) = (A ^ n)⁻¹

{n' : Type u_1}
[DecidableEq n']
[Fintype n']
{R : Type u_2}
[CommRing R]
{A : Matrix n' n' R}
(h : IsUnit A.det)
(n : ℤ)


@[simp] theorem length_zip (l₁ : List α) (l₂ : List β) :
    length (zip l₁ l₂) = min (length l₁) (length l₂)

{α : Type u_1}
{β : Type u_2}
(l₁ : List α)
(l₂ : List β)

(l₁.zip l₂).length = min l₁.length l₂.length


theorem posDef_prod_iff [PartialOrder P] [CovariantClass P P (· + ·) (· ≤ ·)]
    {Q₁ : QuadraticMap R M₁ P} {Q₂ : QuadraticMap R M₂ P} :
    (Q₁.prod Q₂).PosDef ↔ Q₁.PosDef ∧ Q₂.PosDef

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


@[simp]
theorem bot_eq_empty : (⊥ : Finset α) = ∅


@[simp]
theorem ι_range_map_reverse :
    (ι Q).range.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
      = LinearMap.range (ι Q)

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

Submodule.map CliffordAlgebra.reverse (LinearMap.range (CliffordAlgebra.ι Q)) = LinearMap.range (CliffordAlgebra.ι Q)


@[to_additive]
theorem op_smul_finset_mul_eq_mul_smul_finset (a : α) (s : Finset α) (t : Finset α) :
    op a • s * t = s * a • t

{α : Type u_2}
[Semigroup α]
[DecidableEq α]
(a : α)
(s t : Finset α)


@[simp]
theorem add_top (a : WithTop α) : a + ⊤ = ⊤


@[to_additive]
protected theorem Injective [Mul α] [PartialOrder α] {a : α} (ha : MulLECancellable a) :
    Injective (a * ·)

{α : Type u_1}
[Add α]
[PartialOrder α]
{a : α}
(ha : AddLECancellable a)


@[simp] protected theorem le_true : ∀ (x : Bool), x ≤ true


theorem div_lt_one (hb : 0 < b) : a / b < 1 ↔ a < b

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


@[simp] lemma fromDirectLimit_of_tmul {i : ι} (g : G i) (m : M) :
    fromDirectLimit f M (of _ _ _ _ i (g ⊗ₜ m)) = (of _ _ _ f i g) ⊗ₜ m

{R : Type u_1}
[CommRing R]
{ι : Type u_2}
[DecidableEq ι]
[Preorder ι]
{G : ι → Type u_3}
[(i : ι) → AddCommGroup (G i)]
[(i : ι) → Module R (G i)]
(f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
{M : Type u_4}
[AddCommGroup M]
[Module R M]
{i : ι}
(g : G i)
(m : M)

(TensorProduct.fromDirectLimit f M)
    ((Module.DirectLimit.of R ι (fun x => G x ⊗[R] M) (fun i j h => LinearMap.rTensor M (f i j h)) i) (g ⊗ₜ[R] m)) =
  (Module.DirectLimit.of R ι G f i) g ⊗ₜ[R] m


@[simp] theorem toHopfAlgEquiv_refl : toHopfAlgEquiv (.refl X) = .refl _ _

{R : Type u}
[CommRing R]
{X : HopfAlgebraCat R}

(CategoryTheory.Iso.refl X).toHopfAlgEquiv = BialgEquiv.refl R ↑X.toBundled


@[to_additive]
theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r

{E : Type u_6}
[SeminormedAddGroup E]
{a : E}
{r : ℝ≥0∞}


protected theorem union_null (hs : NullMeasurableSet s μ) (ht : μ t = 0) :
    NullMeasurableSet (s ∪ t) μ

(hs : MeasureTheory.NullMeasurableSet s μ)

MeasureTheory.NullMeasurableSet (s ∪ t) μ


lemma hurwitzEvenFEPair_neg (a : UnitAddCircle) : hurwitzEvenFEPair (-a) = hurwitzEvenFEPair a

HurwitzZeta.hurwitzEvenFEPair (-a) = HurwitzZeta.hurwitzEvenFEPair a


lemma LinearIndependent.eq_of_pair {x y : M} (h : LinearIndependent R ![x, y])
    {s t s' t' : R} (h' : s • x + t • y = s' • x + t' • y) : s = s' ∧ t = t'

{R : Type u_2}
{M : Type u_4}
[Ring R]
[AddCommGroup M]
[Module R M]
{x y : M}
(h : LinearIndependent R ![x, y])
{s t s' t' : R}
(h' : s • x + t • y = s' • x + t' • y)


/-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : (R × R') × S × S' ≃+* (R × S) × R' × S'

(R : Type u_3)
(R' : Type u_4)
(S : Type u_5)
(S' : Type u_6)
[NonAssocSemiring R]
[NonAssocSemiring S]
[NonAssocSemiring R']
[NonAssocSemiring S']
(rrss : (R × R') × S × S')

(RingEquiv.prodProdProdComm R R' S S') rrss = ((rrss.1.1, rrss.2.1), rrss.1.2, rrss.2.2)


theorem equiv_toFun_eq_eval : (equiv_range C).toFun = Set.rangeFactorization (eval C)

{I : Type u}
[LinearOrder I]
(C : Set (I → Bool))

(Profinite.NobelingProof.GoodProducts.equiv_range C).toFun =
  Set.rangeFactorization (Profinite.NobelingProof.GoodProducts.eval C)


@[to_additive]
theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1

{G : Type u_1}
{H : Type u_2}
[Group H]
(f : G → H)
{x : G}


@[simp]
theorem castSucc_castPred (i : Fin (n + 1)) (h : i ≠ last n) :
    castSucc (i.castPred h) = i

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


@[simp]
theorem coeffs_apply [DecidableEq ι] (h : DualBases e ε) (m : M) (i : ι) : h.coeffs m i = ε i m

{R : Type u_1}
{M : Type u_2}
{ι : Type u_3}
[CommRing R]
[AddCommGroup M]
[Module R M]
{e : ι → M}
{ε : ι → Module.Dual R M}
[DecidableEq ι]
(h : Module.DualBases e ε)
(m : M)
(i : ι)


@[simp]
lemma image_preimage (e : α ≃ᵐ β) (s : Set β) : e '' (e ⁻¹' s) = s

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[MeasurableSpace β]
(e : α ≃ᵐ β)
(s : Set β)


@[to_additive]
theorem HasCompactMulSupport.uniformContinuous_of_continuous {f : α → β} [One β]
    (h1 : HasCompactMulSupport f) (h2 : Continuous f) : UniformContinuous f

{α : Type u_1}
{β : Type u_2}
[UniformSpace α]
[UniformSpace β]
{f : α → β}
[One β]
(h1 : HasCompactMulSupport f)
(h2 : Continuous f)


@[simp]
theorem comp_apply (f : β →*₀o γ) (g : α →*₀o β) (a : α) : (f.comp g) a = f (g a)

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[Preorder α]
[Preorder β]
[Preorder γ]
[MulZeroOneClass α]
[MulZeroOneClass β]
[MulZeroOneClass γ]
(f : β →*₀o γ)
(g : α →*₀o β)
(a : α)


@[to_additive]
theorem map_inr (s : Submonoid N) : s.map (inr M N) = prod ⊥ s

{M : Type u_1}
{N : Type u_2}
[MulOneClass M]
[MulOneClass N]
(s : Submonoid N)

Submonoid.map (MonoidHom.inr M N) s = ⊥.prod s


/-- The cone of `F` corresponding to an element in `(F ⋙ coyoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F

(s : ↑(F ⋙ CategoryTheory.coyoneda.obj X).sections)

(CategoryTheory.Limits.coneOfSectionCompCoyoneda F X s).pt = Opposite.unop X


theorem uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
    [[a₁, b₁]] ⊆ [[a₂, b₂]]

{α : Type u_2}
[Lattice α]
[LocallyFiniteOrder α]
{a₁ a₂ b₁ b₂ : α}
(h₁ : a₁ ∈ [[a₂, b₂]])
(h₂ : b₁ ∈ [[a₂, b₂]])


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

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


theorem changeOriginSeries_summable_aux₁ {r r' : ℝ≥0} (hr : (r + r' : ℝ≥0∞) < p.radius) :
    Summable fun s : Σk l : ℕ, { s : Finset (Fin (k + l)) // s.card = l } =>
      ‖p (s.1 + s.2.1)‖₊ * r ^ s.2.1 * r' ^ s.1

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F)
{r r' : ℝ≥0}
(hr : ↑r + ↑r' < p.radius)

Summable fun s => ‖p (s.fst + s.snd.fst)‖₊ * r ^ s.snd.fst * r' ^ s.fst


lemma mk_surjective : Function.Surjective (mk (𝒜 := 𝒜) (x := x))

{ι : Type u_1}
{R : Type u_2}
{A : Type u_3}
[CommRing R]
[CommRing A]
[Algebra R A]
{𝒜 : ι → Submodule R A}
{x : Submonoid A}


theorem principal_add_of_le_one {o : Ordinal} (ho : o ≤ 1) : Principal (· + ·) o

Ordinal.Principal (fun x x_1 => x + x_1) o


/-- The type of Compact Hausdorff topological spaces satisfying an additional property `P`. -/
structure CompHausLike where
  /-- The underlying topological space of an object of `CompHausLike P`. -/
  toTop : TopCat
  /-- The underlying topological space is compact. -/
  [is_compact : CompactSpace toTop]
  /-- The underlying topological space is T2. -/
  [is_hausdorff : T2Space toTop]
  /-- The underlying topological space satisfies P. -/
  prop : P toTop

{P : TopCat → Prop}
(self : CompHausLike P)


theorem hom_ext {R : Type u₁} [CommSemiring R] [CharP R p] [PerfectRing R p] {S : Type u₂}
    [CommSemiring S] [CharP S p] {f g : R →+* Ring.Perfection S p}
    (hfg : ∀ x, coeff S p 0 (f x) = coeff S p 0 (g x)) : f = g

(hfg : ∀ (x : R), (Perfection.coeff S p 0) (f x) = (Perfection.coeff S p 0) (g x))


theorem fold_op_distrib {f g : α → β} {b₁ b₂ : β} :
    (s.fold op (b₁ * b₂) fun x => f x * g x) = s.fold op b₁ f * s.fold op b₂ g

{α : Type u_1}
{β : Type u_2}
{op : β → β → β}
[hc : Std.Commutative op]
[ha : Std.Associative op]
{s : Finset α}
{f g : α → β}
{b₁ b₂ : β}

Finset.fold op (op b₁ b₂) (fun x => op (f x) (g x)) s = op (Finset.fold op b₁ f s) (Finset.fold op b₂ g s)


@[functor_norm]
theorem fish_assoc {α β γ φ} (f : α → m β) (g : β → m γ) (h : γ → m φ) :
    (f >=> g) >=> h = f >=> g >=> h

{m : Type u → Type v}
[Monad m]
[LawfulMonad m]
{α : Type u_1}
{β γ φ : Type u}
(f : α → m β)
(g : β → m γ)
(h : γ → m φ)


@[simp]
theorem le_pred_iff : a ≤ pred b ↔ a < b

{α : Type u_1}
[Preorder α]
[PredOrder α]
{a b : α}
[NoMinOrder α]


theorem measurableSet_eq_fun_of_countable {m : MeasurableSpace α} {E} [MeasurableSpace E]
    [MeasurableSingletonClass E] [Countable E] {f g : α → E} (hf : Measurable f)
    (hg : Measurable g) : MeasurableSet { x | f x = g x }

{α : Type u_3}
{m : MeasurableSpace α}
{E : Type u_4}
[MeasurableSpace E]
[MeasurableSingletonClass E]
[Countable E]
{f g : α → E}
(hf : Measurable f)
(hg : Measurable g)


theorem forall_congr' (h : ∀ a, p a ↔ q a) : (∀ a, p a) ↔ ∀ a, q a

{α : Sort u_1}
{p q : α → Prop}
(h : ∀ (a : α), p a ↔ q a)


theorem disjoint_right : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ t → a ∉ s


@[higher_order]
theorem tsnd_eq_snd_id {α β β'} (f : β → β') (x : t α β) :
    tsnd (F := Id) (pure ∘ f) x = pure (snd f x)

{t : Type u → Type u → Type u}
[Bitraversable t]
[LawfulBitraversable t]
{α β β' : Type u}
(f : β → β')
(x : t α β)

Bitraversable.tsnd (pure ∘ f) x = pure (Bifunctor.snd f x)


@[to_additive]
theorem singleton_mul_inter : {a} * (s ∩ t) = {a} * s ∩ ({a} * t)

{α : Type u_2}
[Add α]
[IsLeftCancelAdd α]
[DecidableEq α]
(s t : Finset α)
(a : α)


theorem comp_assoc {V₄ : Type*} [SeminormedAddCommGroup V₄] (h : NormedAddGroupHom V₃ V₄)
    (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    (h.comp g).comp f = h.comp (g.comp f)

{V₁ : Type u_2}
{V₂ : Type u_3}
{V₃ : Type u_4}
[SeminormedAddCommGroup V₁]
[SeminormedAddCommGroup V₂]
[SeminormedAddCommGroup V₃]
{V₄ : Type u_5}
[SeminormedAddCommGroup V₄]
(h : NormedAddGroupHom V₃ V₄)
(g : NormedAddGroupHom V₂ V₃)
(f : NormedAddGroupHom V₁ V₂)


/-- We can write both `n.factorization p` and `n.factors.count p` to represent the power
of `p` in the factorization of `n`: we declare the former to be the simp-normal form. -/
@[simp]
theorem primeFactorsList_count_eq {n p : ℕ} : n.primeFactorsList.count p = n.factorization p

List.count p n.primeFactorsList = n.factorization p


/-- Initial segments are nested in some way. In particular, if they're the same size they're equal.
-/
lemma IsInitSeg.total (h₁ : IsInitSeg 𝒜₁ r) (h₂ : IsInitSeg 𝒜₂ r) : 𝒜₁ ⊆ 𝒜₂ ∨ 𝒜₂ ⊆ 𝒜₁

{α : Type u_1}
[LinearOrder α]
{𝒜₁ 𝒜₂ : Finset (Finset α)}
{r : ℕ}
(h₁ : Finset.Colex.IsInitSeg 𝒜₁ r)
(h₂ : Finset.Colex.IsInitSeg 𝒜₂ r)

𝒜₁ ⊆ 𝒜₂ ∨ 𝒜₂ ⊆ 𝒜₁


/-- If a space of linear maps from `E` to `F` is complete, and `E` is nontrivial, then `F` is
complete. -/
lemma completeSpace_of_completeSpace_continuousLinearMap [CompleteSpace (E →L[𝕜] F)] :
    CompleteSpace F

(𝕜 : Type u_3)
(E : Type u_4)
(F : Type u_5)
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[SeparatingDual 𝕜 E]
[Nontrivial E]
[CompleteSpace (E →L[𝕜] F)]


@[to_additive]
theorem edist_unop (x y : αᵐᵒᵖ) : edist (unop x) (unop y) = edist x y

{α : Type u}
[PseudoEMetricSpace α]
(x y : αᵃᵒᵖ)

edist (AddOpposite.unop x) (AddOpposite.unop y) = edist x y


/-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. -/
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F

(tX : CategoryTheory.Limits.IsInitial X)

(CategoryTheory.Limits.coneOfDiagramInitial tX F).pt = F.obj X


lemma cfcHom_eq_restrict (f : C(S, R)) (halg : UniformEmbedding (algebraMap R S))
    {a : A} (hpa : p a) (hqa : q a) (h : SpectrumRestricts a f) [CompactSpace (spectrum S a)] :
    cfcHom hpa = h.starAlgHom (cfcHom hqa)

(halg : UniformEmbedding ⇑(algebraMap R S))

cfcHom hpa = SpectrumRestricts.starAlgHom (cfcHom hqa) h


theorem card_eq_two_iff : Nat.card α = 2 ↔ ∃ x y : α, x ≠ y ∧ {x, y} = @Set.univ α

Nat.card α = 2 ↔ ∃ x y, x ≠ y ∧ {x, y} = Set.univ


theorem equiv_comp_equiv_eq_id :
    (equiv i j p).trans (equiv j i p) = RingEquiv.refl L

{K : Type u_1}
{L : Type u_2}
{M : Type u_3}
[CommRing K]
[CommRing L]
[CommRing M]
(i : K →+* L)
(j : K →+* M)
(p : ℕ)
[ExpChar K p]
[ExpChar L p]
[ExpChar M p]
[PerfectRing L p]
[IsPerfectClosure i p]
[PerfectRing M p]
[IsPerfectClosure j p]

(IsPerfectClosure.equiv i j p).trans (IsPerfectClosure.equiv j i p) = RingEquiv.refl L


a < UInt32.size → ↑(UInt32.ofNat a).val = a


lemma card_truncatedInf_union_add_card_truncatedInf_sups (𝒜 ℬ : Finset (Finset α)) (s : Finset α) :
    (truncatedInf (𝒜 ∪ ℬ) s).card + (truncatedInf (𝒜 ⊻ ℬ) s).card =
      (truncatedInf 𝒜 s).card + (truncatedInf ℬ s).card

{α : Type u_1}
[DecidableEq α]
[Fintype α]
(𝒜 ℬ : Finset (Finset α))
(s : Finset α)

((𝒜 ∪ ℬ).truncatedInf s).card + ((𝒜 ⊻ ℬ).truncatedInf s).card = (𝒜.truncatedInf s).card + (ℬ.truncatedInf s).card


/--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F

(F : CategoryTheory.Functor J (CategoryTheory.Comma L R))

[CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L]

{c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))}

(t₁ : CategoryTheory.Limits.IsColimit c₁)

(c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)))

((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).right = c₂.ι.app j


lemma pairwiseDisjoint_diffFinset (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
    PairwiseDisjoint (hC.diffFinset hs ht : Set (Set α)) id

{α : Type u_1}
{C : Set (Set α)}
{s t : Set α}
(hC : MeasureTheory.IsSetSemiring C)
(hs : s ∈ C)
(ht : t ∈ C)

(↑(hC.diffFinset hs ht)).PairwiseDisjoint id


theorem isRightInversion_inv_iff {w t : W} :
    cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t

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


theorem summable_conj {f : α → ℂ} : (Summable fun x => conj (f x)) ↔ Summable f

(Summable fun x => (starRingEnd ℂ) (f x)) ↔ Summable f


theorem eq_intCast' (f : ℤ →+* α) : f = Int.castRingHom α

{α : Type u_3}
[NonAssocRing α]
(f : ℤ →+* α)


/-- The cardinality of the `center` of a `p`-group is `p ^ k` where `k` is positive. -/
theorem card_center_eq_prime_pow (hn : 0 < n) :
    ∃ k > 0, Nat.card (center G) = p ^ k

{p : ℕ}
{G : Type u_1}
[Group G]
[Fact (Nat.Prime p)]
{n : ℕ}
(hGpn : Nat.card G = p ^ n)
(hn : 0 < n)

∃ k > 0, Nat.card ↥(Subgroup.center G) = p ^ k


@[to_additive]
theorem mem_ker (f : G →* M) {x : G} : x ∈ f.ker ↔ f x = 1

{G : Type u_1}
[Group G]
{M : Type u_7}
[MulOneClass M]
(f : G →* M)
{x : G}


/-- If `0 < n`, then `a 1` has order `2 * n`.
-/
@[simp]
theorem orderOf_a_one : orderOf (a 1 : QuaternionGroup n) = 2 * n


/-- The diagram of the multifork attached to a presheaf
`F : Cᵒᵖ ⥤ A`, `S : C` and `E : PreOneHypercover S`. -/
@[simps]
def multicospanIndex (F : Cᵒᵖ ⥤ A) : MulticospanIndex A

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{A : Type u_1}
[CategoryTheory.Category.{u_2, u_1} A]
{S : C}
(E : CategoryTheory.PreOneHypercover S)
(F : CategoryTheory.Functor Cᵒᵖ A)
(j : E.I₁')

(E.multicospanIndex F).fst j = F.map (E.p₁ j.snd).op


@[simp]
theorem map_surjective [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ} :
    Surjective (map f g) ↔ Surjective f ∧ Surjective g

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}
[Nonempty γ]
[Nonempty δ]
{f : α → γ}
{g : β → δ}

Function.Surjective (Prod.map f g) ↔ Function.Surjective f ∧ Function.Surjective g


theorem HasCompactSupport.iteratedFDeriv (hf : HasCompactSupport f) (n : ℕ) :
    HasCompactSupport (iteratedFDeriv 𝕜 n f)

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
(hf : HasCompactSupport f)
(n : ℕ)


@[to_additive (attr := simp)]
theorem srange_fst [Nonempty N] : (fst M N).srange = ⊤

{M : Type u_1}
{N : Type u_2}
[Mul M]
[Mul N]
[Nonempty N]


theorem MonotoneOn.integral_le_sum (hf : MonotoneOn f (Icc x₀ (x₀ + a))) :
    (∫ x in x₀..x₀ + a, f x) ≤ ∑ i ∈ Finset.range a, f (x₀ + (i + 1 : ℕ))

(hf : MonotoneOn f (Set.Icc x₀ (x₀ + ↑a)))

∫ (x : ℝ) in x₀..x₀ + ↑a, f x ≤ ∑ i ∈ Finset.range a, f (x₀ + ↑(i + 1))


@[simp]
theorem circulant_zero (α n) [Zero α] [Sub n] : circulant 0 = (0 : Matrix n n α)

(α : Type u_6)
(n : Type u_7)
[Zero α]
[Sub n]


theorem sqrt_eq_cases : √x = y ↔ y * y = x ∧ 0 ≤ y ∨ x < 0 ∧ y = 0


/-- Construct a pseudofunctor from an oplax functor whose `mapId` and `mapComp` are isomorphisms. -/
@[simps!]
noncomputable def mkOfOplax' (F : OplaxFunctor B C) [∀ a, IsIso (F.mapId a)]
    [∀ {a b c} (f : a ⟶ b) (g : b ⟶ c), IsIso (F.mapComp f g)] : Pseudofunctor B C

[∀ (a : B), CategoryTheory.IsIso (F.mapId a)]

[∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g)]

((CategoryTheory.Pseudofunctor.mkOfOplax' F).mapId a).inv = CategoryTheory.inv (F.mapId a)


/-- The **spectral mapping theorem** for the non-unital continuous functional calculus. -/
lemma cfcₙ_map_quasispectrum : σₙ R (cfcₙ f a) = f '' σₙ R a

(hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac)


@[to_additive]
theorem locallyCompactSpace_of_equicontinuousAt (U : Set X) (V : Set Y)
    (hU : IsCompact U) (hV : V ∈ nhds (1 : Y))
    (h : EquicontinuousAt (fun f : {f : X →* Y | Set.MapsTo f U V} ↦ (f : X → Y)) 1) :
    LocallyCompactSpace (ContinuousMonoidHom X Y)

{X : Type u_7}
{Y : Type u_8}
[TopologicalSpace X]
[Group X]
[TopologicalGroup X]
[UniformSpace Y]
[CommGroup Y]
[UniformGroup Y]
[T0Space Y]
[CompactSpace Y]
(U : Set X)
(V : Set Y)
(hU : IsCompact U)
(hV : V ∈ nhds 1)
(h : EquicontinuousAt (fun f => ⇑↑f) 1)


@[to_additive (attr := simp)]
theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1

{α : Type u}
[LinearOrderedAddCommGroup α]
{a : α}


/-- See [Theorem 6.6][calugareanu]. -/
theorem complementedLattice_of_sSup_atoms_eq_top (h : sSup { a : α | IsAtom a } = ⊤) :
    ComplementedLattice α

{α : Type u_2}
[CompleteLattice α]
[IsModularLattice α]
[IsCompactlyGenerated α]
(h : sSup {a | IsAtom a} = ⊤)


/-- Commutativity of an additive subgroup -/
structure _root_.AddSubgroup.IsCommutative (H : AddSubgroup A) : Prop where
  /-- `+` is commutative on `H` -/
  is_comm : Std.Commutative (α := H) (· + ·)

{A : Type u_4}
[AddGroup A]
{H : AddSubgroup A}
(self : H.IsCommutative)


theorem add_assoc_rev (a b c : R) : a + (b + c) = a + b + c

{R : Type u_1}
[CommSemiring R]
(a b c : R)


theorem ne_zero_of_coe_le_degree (hdeg : ↑n ≤ p.degree) : p ≠ 0

{R : Type u}
{n : ℕ}
[Semiring R]
{p : R[X]}
(hdeg : ↑n ≤ p.degree)


@[to_additive]
lemma prod_dite_of_false {p : α → Prop} {_ : DecidablePred p} (h : ∀ i ∈ s, ¬ p i)
    (f : ∀ i, p i → β) (g : ∀ i, ¬ p i → β) :
    ∏ i ∈ s, (if hi : p i then f i hi else g i hi) = ∏ i : s, g i.1 (h _ i.2)

{α : Type u_3}
{β : Type u_4}
{s : Finset α}
[CommMonoid β]
{p : α → Prop}

∀ {x : DecidablePred p} (h : ∀ i ∈ s, ¬p i) (f : (i : α) → p i → β) (g : (i : α) → ¬p i → β),
  (∏ i ∈ s, if hi : p i then f i hi else g i hi) = ∏ i : { x // x ∈ s }, g ↑i ⋯


@[to_additive (attr := simp)]
theorem mul_empty : s * ∅ = ∅


theorem isGreatest_Ioc (h : a < b) : IsGreatest (Ioc a b) b

{α : Type u}
[Preorder α]
{a b : α}
(h : a < b)


lemma map_baseChange [Algebra F K] [IsScalarTower R F K] [Algebra F L] [IsScalarTower R F L]
    (f : K →ₐ[F] L) (P : W⟮F⟯) : map W f (baseChange W F K P) = baseChange W F L P

(P : WeierstrassCurve.Affine.Point (WeierstrassCurve.baseChange W F))

(WeierstrassCurve.Affine.Point.map W f) ((WeierstrassCurve.Affine.Point.baseChange W F K) P) =
  (WeierstrassCurve.Affine.Point.baseChange W F L) P


lemma congr_φH {γ₁ γ₂ : RightHomologyMapData φ h₁ h₂} (eq : γ₁ = γ₂) : γ₁.φH = γ₂.φH

{γ₁ γ₂ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂}

γ₁.φH = γ₂.φH


/-- Intersection of an indexed family of sets `s : ι → Set α` is equal to the intersection of the
intersections of finite subfamilies. This version assumes `ι : Type*`. See also
`iInter_eq_iInter_finset'` for a version that works for `ι : Sort*`. -/
theorem iInter_eq_iInter_finset (s : ι → Set α) : ⋂ i, s i = ⋂ t : Finset ι, ⋂ i ∈ t, s i

{α : Type u_2}
{ι : Type u_5}
(s : ι → Set α)


theorem openSegment_subset_iff :
    openSegment 𝕜 x y ⊆ s ↔ ∀ a b : 𝕜, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s

(𝕜 : Type u_1)
{E : Type u_2}
[OrderedSemiring 𝕜]
[AddCommMonoid E]
[SMul 𝕜 E]
{s : Set E}
{x y : E}

openSegment 𝕜 x y ⊆ s ↔ ∀ (a b : 𝕜), 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s


@[to_additive]
theorem csSup_inv (hs₀ : s.Nonempty) (hs₁ : BddBelow s) : sSup s⁻¹ = (sInf s)⁻¹

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

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


@[to_additive (attr := simp)]
theorem lift_id (x) : f.lift f.map_units x = x

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


/-- If a continuous function lies strictly above `a` on a compact set,
  it has a lower bound strictly above `a`. -/
theorem IsCompact.exists_forall_le' [ClosedIicTopology α] [NoMaxOrder α] {f : β → α}
    {s : Set β} (hs : IsCompact s) (hf : ContinuousOn f s) {a : α} (hf' : ∀ b ∈ s, a < f b) :
    ∃ a', a < a' ∧ ∀ b ∈ s, a' ≤ f b

{α : Type u_2}
{β : Type u_3}
[LinearOrder α]
[TopologicalSpace α]
[TopologicalSpace β]
[ClosedIicTopology α]
[NoMaxOrder α]
{f : β → α}
{s : Set β}
(hs : IsCompact s)
(hf : ContinuousOn f s)
{a : α}
(hf' : ∀ b ∈ s, a < f b)


lemma ContinuousAt.finset_sup (hs : ∀ i ∈ s, ContinuousAt (f i) x) :
    ContinuousAt (s.sup f) x

{L : Type u_1}
{X : Type u_2}
[TopologicalSpace L]
[TopologicalSpace X]
{ι : Type u_3}
[SemilatticeSup L]
[OrderBot L]
[ContinuousSup L]
{s : Finset ι}
{f : ι → X → L}
{x : X}
(hs : ∀ i ∈ s, ContinuousAt (f i) x)


@[simp]
theorem mk_dvd_mk {a b : α} : Associates.mk a ∣ Associates.mk b ↔ a ∣ b


theorem rotate_eq_iff {l l' : List α} {n : ℕ} :
    l.rotate n = l' ↔ l = l'.rotate (l'.length - n % l'.length)


@[simp]
theorem biprod_isoCoprod_hom {X Y : C} [HasBinaryBiproduct X Y] :
    (biprod.isoCoprod X Y).hom = biprod.desc coprod.inl coprod.inr

(CategoryTheory.Limits.biprod.isoCoprod X Y).hom =
  CategoryTheory.Limits.biprod.desc CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr


/-- Any shift of a Cauchy sequence is also a Cauchy sequence. -/
theorem cauchySeq_shift {u : ℕ → α} (k : ℕ) : CauchySeq (fun n ↦ u (n + k)) ↔ CauchySeq u

{α : Type u}
[uniformSpace : UniformSpace α]
{u : ℕ → α}
(k : ℕ)

(CauchySeq fun n => u (n + k)) ↔ CauchySeq u


@[simp]
theorem mapRange_apply {f : M → N} {hf : f 0 = 0} {g : α →₀ M} {a : α} :
    mapRange f hf g a = f (g a)

{α : Type u_1}
{M : Type u_5}
{N : Type u_7}
[Zero M]
[Zero N]
{f : M → N}
{hf : f 0 = 0}
{g : α →₀ M}
{a : α}


theorem ofNat_natAbs_of_nonpos {a : Int} (H : a ≤ 0) : (natAbs a : Int) = -a


theorem fin_app {n} : Primrec₂ (@id (Fin n → σ))


/-- The **first isomorphism** theorem for algebras, computable version. -/
@[simps!]
def quotientKerAlgEquivOfRightInverse {f : A →ₐ[R₁] B} {g : B → A}
    (hf : Function.RightInverse g f) : (A ⧸ RingHom.ker f) ≃ₐ[R₁] B

{R₁ : Type u_1}
{A : Type u_3}
{B : Type u_4}
[CommSemiring R₁]
[CommRing A]
[Algebra R₁ A]
[Semiring B]
[Algebra R₁ B]
{f : A →ₐ[R₁] B}
{g : B → A}
(hf : Function.RightInverse g ⇑f)

∀ (a : B), (Ideal.quotientKerAlgEquivOfRightInverse hf).symm a = (Ideal.Quotient.mk (RingHom.ker ↑f)) (g a)


/-- `F : ComposableArrows C n` is exact if it is a complex and that all short
complexes consisting of two consecutive arrows are exact. -/
structure Exact extends S.IsComplex : Prop where
  exact (i : ℕ) (hi : i + 2 ≤ n := by omega) : (S.sc toIsComplex i).Exact

{S : CategoryTheory.ComposableArrows C n}


@[to_additive]
theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
    center G = ⨅ g ∈ S, centralizer (zpowers g)

{G : Type u_1}
[AddGroup G]
(S : Set G)
(hS : AddSubgroup.closure S = ⊤)

AddSubgroup.center G = ⨅ g ∈ S, AddSubgroup.centralizer ↑(AddSubgroup.zmultiples g)


/-- Composing an independent indexed family with an injective function on the index results in
another indepedendent indexed family. -/
theorem Independent.comp {ι ι' : Sort*} {t : ι → α} {f : ι' → ι} (ht : Independent t)
    (hf : Injective f) : Independent (t ∘ f)

{α : Type u_1}
[CompleteLattice α]
{ι : Sort u_5}
{ι' : Sort u_6}
{t : ι → α}
{f : ι' → ι}
(ht : CompleteLattice.Independent t)
(hf : Function.Injective f)


@[to_additive]
theorem preimage_of_equiv {ν : Measure β} (h : IsFundamentalDomain G s μ) {f : β → α}
    (hf : QuasiMeasurePreserving f ν μ) {e : G → H} (he : Bijective e)
    (hef : ∀ g, Semiconj f (e g • ·) (g • ·)) : IsFundamentalDomain H (f ⁻¹' s) ν

(h : MeasureTheory.IsAddFundamentalDomain G s μ)

(hf : MeasureTheory.Measure.QuasiMeasurePreserving f ν μ)

(hef : ∀ (g : G), Function.Semiconj f (fun x => e g +ᵥ x) fun x => g +ᵥ x)

MeasureTheory.IsAddFundamentalDomain H (f ⁻¹' s) ν


theorem of_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsPreimmersion g]
    [IsPreimmersion (f ≫ g)] : IsPreimmersion f

[AlgebraicGeometry.IsPreimmersion (f ≫ g)]


/-- **Equality case of the Rearrangement Inequality**: Pointwise scalar multiplication of `f` and
`g`, which monovary together, is unchanged by a permutation if and only if `f` and `g ∘ σ` monovary
together. Stated by permuting the entries of `g`. -/
theorem MonovaryOn.sum_smul_comp_perm_eq_sum_smul_iff (hfg : MonovaryOn f g s)
    (hσ : {x | σ x ≠ x} ⊆ s) :
    ∑ i ∈ s, f i • g (σ i) = ∑ i ∈ s, f i • g i ↔ MonovaryOn f (g ∘ σ) s

{ι : Type u_1}
{α : Type u_2}
{β : Type u_3}
[LinearOrderedRing α]
[LinearOrderedAddCommGroup β]
[Module α β]
[OrderedSMul α β]
{s : Finset ι}
{σ : Equiv.Perm ι}
{f : ι → α}
{g : ι → β}
(hfg : MonovaryOn f g ↑s)
(hσ : {x | σ x ≠ x} ⊆ ↑s)

∑ i ∈ s, f i • g (σ i) = ∑ i ∈ s, f i • g i ↔ MonovaryOn f (g ∘ ⇑σ) ↑s


@[simp]
theorem add_hom {X Y : Action V G} (f g : X ⟶ Y) : (f + g).hom = f.hom + g.hom

{V : Type (u + 1)}
[CategoryTheory.LargeCategory V]
{G : MonCat}
[CategoryTheory.Preadditive V]
{X Y : Action V G}
(f g : X ⟶ Y)


theorem mdifferentiable_const : MDifferentiable I I' fun _ : M => c

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
[SmoothManifoldWithCorners I M]
{E' : Type u_5}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_6}
[TopologicalSpace H']
(I' : ModelWithCorners 𝕜 E' H')
{M' : Type u_7}
[TopologicalSpace M']
[ChartedSpace H' M']
[SmoothManifoldWithCorners I' M']
{c : M'}


theorem map_ne_zero_iff {x : M} : e x ≠ 0 ↔ x ≠ 0

{R : Type u_1}
{S : Type u_7}
{M : Type u_8}
{M₂ : Type u_10}
[Semiring R]
[Semiring S]
[AddCommMonoid M]
[AddCommMonoid M₂]
{module_M : Module R M}
{module_S_M₂ : Module S M₂}
{σ : R →+* S}
{σ' : S →+* R}
{re₁ : RingHomInvPair σ σ'}
{re₂ : RingHomInvPair σ' σ}
(e : M ≃ₛₗ[σ] M₂)
{x : M}


theorem mulVec_surjective_of_invertible (A : Matrix m m R) [Invertible A] :
    Function.Surjective A.mulVec

{m : Type u}
[DecidableEq m]
{R : Type u_2}
[CommRing R]
[Fintype m]
(A : Matrix m m R)
[Invertible A]


@[to_additive]
theorem HasProd.mul (hf : HasProd f a) (hg : HasProd g b) :
    HasProd (fun b ↦ f b * g b) (a * b)

{α : Type u_1}
{β : Type u_2}
[CommMonoid α]
[TopologicalSpace α]
{f g : β → α}
{a b : α}
[ContinuousMul α]
(hf : HasProd f a)
(hg : HasProd g b)


/-- The equivalence between coarsenings of a valuation ring and its prime ideals. -/
@[simps]
def primeSpectrumEquiv : PrimeSpectrum A ≃ {S // A ≤ S}

{K : Type u}
[Field K]
(A : ValuationSubring K)
(P : PrimeSpectrum ↥A)

↑(A.primeSpectrumEquiv P) = A.ofPrime P.asIdeal


/-- `counitAlgHom R A` is the counit of the `R`-bialgebra `A`, as an `R`-algebra map. -/
@[simps!]
def counitAlgHom : A →ₐ[R] R

(R : Type u)
(A : Type v)
[CommSemiring R]
[Semiring A]
[Bialgebra R A]
(a : A)

(Bialgebra.counitAlgHom R A) a = Coalgebra.counit a


theorem range_total : LinearMap.range (Finsupp.total α M R v) = span R (range v)

{α : Type u_1}
{M : Type u_2}
(R : Type u_5)
[Semiring R]
[AddCommMonoid M]
[Module R M]
{v : α → M}

LinearMap.range (Finsupp.total α M R v) = Submodule.span R (Set.range v)


/-- The **fundamental identity** of ramification index `e` and inertia degree `f`:
for `P` ranging over the primes lying over `p`, `∑ P, e P * f P = [Frac(S) : Frac(R)]`;
here `S` is a finite `R`-module (and thus `Frac(S) : Frac(R)` is a finite extension) and `p`
is maximal.
-/
theorem sum_ramification_inertia (K L : Type*) [Field K] [Field L] [IsDedekindDomain R]
    [Algebra R K] [IsFractionRing R K] [Algebra S L] [IsFractionRing S L] [Algebra K L]
    [Algebra R L] [IsScalarTower R S L] [IsScalarTower R K L] [IsNoetherian R S]
    [IsIntegralClosure S R L] [p.IsMaximal] (hp0 : p ≠ ⊥) :
    (∑ P ∈ (factors (map (algebraMap R S) p)).toFinset,
        ramificationIdx (algebraMap R S) p P * inertiaDeg (algebraMap R S) p P) =
      finrank K L

{R : Type u}
[CommRing R]
{S : Type v}
[CommRing S]
(p : Ideal R)
[IsDedekindDomain S]
[Algebra R S]
(K : Type u_1)
(L : Type u_2)
[Field K]
[Field L]
[IsDedekindDomain R]
[Algebra R K]
[IsFractionRing R K]
[Algebra S L]
[IsFractionRing S L]
[Algebra K L]
[Algebra R L]
[IsScalarTower R S L]
[IsScalarTower R K L]
[IsNoetherian R S]
[IsIntegralClosure S R L]
[p.IsMaximal]
(hp0 : p ≠ ⊥)

∑ P ∈ (UniqueFactorizationMonoid.factors (Ideal.map (algebraMap R S) p)).toFinset,
    Ideal.ramificationIdx (algebraMap R S) p P * Ideal.inertiaDeg (algebraMap R S) p P =
  FiniteDimensional.finrank K L


/-- A `c : Bicone F` is:
* an object `c.pt` and
* morphisms `π j : pt ⟶ F j` and `ι j : F j ⟶ pt` for each `j`,
* such that `ι j ≫ π j'` is the identity when `j = j'` and zero otherwise.
-/
-- @[nolint has_nonempty_instance] Porting note (#5171): removed
structure Bicone (F : J → C) where
  pt : C
  π : ∀ j, pt ⟶ F j
  ι : ∀ j, F j ⟶ pt
  ι_π : ∀ j j', ι j ≫ π j' =
    if h : j = j' then eqToHom (congrArg F h) else 0 := by aesop

self.ι j ≫ self.π j' = if h : j = j' then CategoryTheory.eqToHom ⋯ else 0


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

OrderDual.toDual a⁻¹ = (OrderDual.toDual a)⁻¹


@[simp]
theorem isBigOWith_zero_right_iff : (IsBigOWith c l f'' fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0

{α : Type u_1}
{F' : Type u_7}
{E'' : Type u_9}
[SeminormedAddCommGroup F']
[NormedAddCommGroup E'']
{c : ℝ}
{f'' : α → E''}
{l : Filter α}

(Asymptotics.IsBigOWith c l f'' fun _x => 0) ↔ f'' =ᶠ[l] 0


/-- `Matrix.blockDiag'` as an `AddMonoidHom`. -/
@[simps]
def blockDiag'AddMonoidHom [AddZeroClass α] :
    Matrix (Σi, m' i) (Σi, n' i) α →+ ∀ i, Matrix (m' i) (n' i) α

(M : Matrix ((i : o) × m' i) ((i : o) × n' i) α)

(Matrix.blockDiag'AddMonoidHom m' n' α) M k = M.blockDiag' k


/-- A monic polynomial `p` that has as many roots as its degree
can be written `p = ∏(X - a)`, for `a` in `p.roots`. -/
theorem prod_multiset_X_sub_C_of_monic_of_roots_card_eq (hp : p.Monic)
    (hroots : Multiset.card p.roots = p.natDegree) : (p.roots.map fun a => X - C a).prod = p

(Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod = p


@[simp] lemma graph_def (f : α → β) (x y) : f.graph x y ↔ (f x = y)

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


theorem comp_right_differentiableWithinAt_iff {f : F → G} {s : Set F} {x : E} :
    DifferentiableWithinAt 𝕜 (f ∘ iso) (iso ⁻¹' s) x ↔ DifferentiableWithinAt 𝕜 f s (iso x)

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

DifferentiableWithinAt 𝕜 (f ∘ ⇑iso) (⇑iso ⁻¹' s) x ↔ DifferentiableWithinAt 𝕜 f s (iso x)


lemma toTriangle_is3Clique (hx : x ∈ t) : (graph t).IsNClique 3 (toTriangle x)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{t : Finset (α × β × γ)}
{x : α × β × γ}
[DecidableEq α]
[DecidableEq β]
[DecidableEq γ]
(hx : x ∈ t)

(SimpleGraph.TripartiteFromTriangles.graph t).IsNClique 3 (SimpleGraph.TripartiteFromTriangles.toTriangle x)


/-- A typeclass encoding the fact that a given Lie module has linear weights, vanishing on the
derived ideal. -/
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0

{R : Type u_1}
{L : Type u_2}
{M : Type u_3}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
[LieAlgebra.IsNilpotent R L]
[self : LieModule.LinearWeights R L M]
(χ : L → R)

LieModule.weightSpace M χ ≠ ⊥ → ∀ (t : R) (x : L), χ (t • x) = t • χ x


theorem closure_preimage (hsurj : Surjective f) (s : Set F) : closure (f ⁻¹' s) = f ⁻¹' closure s

{𝕜 : Type u_1}
{𝕜' : Type u_2}
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜']
{σ : 𝕜 →+* 𝕜'}
{σ' : 𝕜' →+* 𝕜}
[RingHomInvPair σ σ']
[RingHomIsometric σ]
[RingHomIsometric σ']
{E : Type u_3}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_4}
[NormedAddCommGroup F]
[NormedSpace 𝕜' F]
(f : E →SL[σ] F)
[CompleteSpace F]
[CompleteSpace E]
(hsurj : Function.Surjective ⇑f)
(s : Set F)


theorem stronglyMeasurable_limitProcess : StronglyMeasurable[⨆ n, ℱ n] (limitProcess f ℱ μ)

{Ω : Type u_1}
{ι : Type u_3}
{m : MeasurableSpace Ω}
[Preorder ι]
{E : Type u_4}
[Zero E]
[TopologicalSpace E]
{ℱ : MeasureTheory.Filtration ι m}
{f : ι → Ω → E}
{μ : MeasureTheory.Measure Ω}

MeasureTheory.StronglyMeasurable (MeasureTheory.Filtration.limitProcess f ℱ μ)


@[simp] lemma supClosed_supClosure : SupClosed (supClosure s)

{α : Type u_2}
[SemilatticeSup α]
{s : Set α}


theorem eq_succ_of_ne_zero {n : Nat} {i : Fin (n + 1)} (hi : i ≠ 0) : ∃ j : Fin n, i = j.succ


theorem liftPropAt_iff {P : (H → H') → Set H → H → Prop} {f : M → M'} {x : M} :
    LiftPropAt P f x ↔
      ContinuousAt f x ∧ P (chartAt H' (f x) ∘ f ∘ (chartAt H x).symm) univ (chartAt H x x)

{H : Type u_1}
{M : Type u_2}
{H' : Type u_3}
{M' : Type u_4}
[TopologicalSpace H]
[TopologicalSpace M]
[ChartedSpace H M]
[TopologicalSpace H']
[TopologicalSpace M']
[ChartedSpace H' M']
{P : (H → H') → Set H → H → Prop}
{f : M → M'}
{x : M}

ChartedSpace.LiftPropAt P f x ↔
  ContinuousAt f x ∧ P (↑(chartAt H' (f x)) ∘ f ∘ ↑(chartAt H x).symm) Set.univ (↑(chartAt H x) x)


(l : Type u_1)
(R : Type u_2)
[DecidableEq l]
[CommRing R]
[Fintype l]


@[ext]
theorem ext {f g : SpectralMap α β} (h : ∀ a, f a = g a) : f = g

{α : Type u_2}
{β : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
{f g : SpectralMap α β}
(h : ∀ (a : α), f a = g a)


@[continuity]
theorem continuous_coe : Continuous ((↑) : ℝ → Angle)


@[to_additive]
theorem isOpen_mono [ContinuousMul G] {H₁ H₂ : Subgroup G} (h : H₁ ≤ H₂)
    (h₁ : IsOpen (H₁ : Set G)) : IsOpen (H₂ : Set G)

{G : Type u_1}
[AddGroup G]
[TopologicalSpace G]
[ContinuousAdd G]
{H₁ H₂ : AddSubgroup G}
(h : H₁ ≤ H₂)
(h₁ : IsOpen ↑H₁)


/-- Any open set is the union of the basis sets contained in it. -/
theorem IsTopologicalBasis.open_eq_sUnion' {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : u = ⋃₀ { s ∈ B | s ⊆ u }

(hB : TopologicalSpace.IsTopologicalBasis B)


theorem norm_eq_norm_app_of_nonzero {f : PadicSeq p} (hf : ¬f ≈ 0) :
    ∃ k, f.norm = padicNorm p k ∧ k ≠ 0

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


theorem _root_.Commute.exp_left [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) : Commute (exp 𝕂 x) y

(𝕂 : Type u_1)
{𝔸 : Type u_2}
[Field 𝕂]
[Ring 𝔸]
[Algebra 𝕂 𝔸]
[TopologicalSpace 𝔸]
[TopologicalRing 𝔸]
[T2Space 𝔸]
{x y : 𝔸}
(h : Commute x y)


@[simp]
theorem contractRight_algebraMap (r : R) : algebraMap R (CliffordAlgebra Q) r⌊d = 0

{R : Type u1}
[CommRing R]
{M : Type u2}
[AddCommGroup M]
[Module R M]
(Q : QuadraticForm R M)
(d : Module.Dual R M)
(r : R)

(CliffordAlgebra.contractRight ((algebraMap R (CliffordAlgebra Q)) r)) d = 0


/-- First case of the inductive step: assuming that
`∀ (s : Finset ι), s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card`
and that the statement of **Hall's Marriage Theorem** is true for all
`ι'` of cardinality ≤ `n`, then it is true for `ι` of cardinality `n + 1`.
-/
theorem hall_hard_inductive_step_A {n : ℕ} (hn : Fintype.card ι = n + 1)
    (ht : ∀ s : Finset ι, s.card ≤ (s.biUnion t).card)
    (ih :
      ∀ {ι' : Type u} [Fintype ι'] (t' : ι' → Finset α),
        Fintype.card ι' ≤ n →
          (∀ s' : Finset ι', s'.card ≤ (s'.biUnion t').card) →
            ∃ f : ι' → α, Function.Injective f ∧ ∀ x, f x ∈ t' x)
    (ha : ∀ s : Finset ι, s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card) :
    ∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x

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

(ih :
  ∀ {ι' : Type u} [inst : Fintype ι'] (t' : ι' → Finset α),
    Fintype.card ι' ≤ n →
      (∀ (s' : Finset ι'), s'.card ≤ (s'.biUnion t').card) → ∃ f, Function.Injective f ∧ ∀ (x : ι'), f x ∈ t' x)

(ha : ∀ (s : Finset ι), s.Nonempty → s ≠ Finset.univ → s.card < (s.biUnion t).card)

∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x


/-- A flat is a maximal set having a given basis  -/
@[mk_iff]
structure Flat (M : Matroid α) (F : Set α) : Prop where
  subset_of_basis_of_basis : ∀ ⦃I X⦄, M.Basis I F → M.Basis I X → X ⊆ F
  subset_ground : F ⊆ M.E

{α : Type u_2}
{M : Matroid α}
{F : Set α}
(self : M.Flat F)
⦃I X : Set α⦄


@[simp]
theorem update_lt_self_iff : update x i a < x ↔ a < x i

{ι : Type u_1}
{π : ι → Type u_4}
[DecidableEq ι]
[(i : ι) → Preorder (π i)]
{x : (i : ι) → π i}
{i : ι}
{a : π i}


@[simp] theorem ihom_coev_app_hom (A B : Rep k G) :
    Action.Hom.hom ((ihom.coev A).app B) = (TensorProduct.mk k _ _).flip

{k G : Type u}
[CommRing k]
[Group G]
(A B : Rep k G)

((CategoryTheory.ihom.coev A).app B).hom = (TensorProduct.mk k (CoeSort.coe A) ↑((𝟭 (Rep k G)).obj B).V).flip


theorem lift_nhds_right {x : α} {g : Set α → Filter β} (hg : Monotone g) :
    (𝓝 x).lift g = (𝓤 α).lift fun s : Set (α × α) => g { y | (y, x) ∈ s }

{α : Type ua}
{β : Type ub}
[UniformSpace α]
{x : α}
{g : Set α → Filter β}
(hg : Monotone g)

(𝓝 x).lift g = (𝓤 α).lift fun s => g {y | (y, x) ∈ s}


theorem sumLift₂_eq_empty :
    sumLift₂ f g a b = ∅ ↔
      (∀ a₁ b₁, a = inl a₁ → b = inl b₁ → f a₁ b₁ = ∅) ∧
        ∀ a₂ b₂, a = inr a₂ → b = inr b₂ → g a₂ b₂ = ∅

{α₁ : Type u_1}
{α₂ : Type u_2}
{β₁ : Type u_3}
{β₂ : Type u_4}
{γ₁ : Type u_5}
{γ₂ : Type u_6}
{f : α₁ → β₁ → Finset γ₁}
{g : α₂ → β₂ → Finset γ₂}
{a : α₁ ⊕ α₂}
{b : β₁ ⊕ β₂}

Finset.sumLift₂ f g a b = ∅ ↔
  (∀ (a₁ : α₁) (b₁ : β₁), a = Sum.inl a₁ → b = Sum.inl b₁ → f a₁ b₁ = ∅) ∧
    ∀ (a₂ : α₂) (b₂ : β₂), a = Sum.inr a₂ → b = Sum.inr b₂ → g a₂ b₂ = ∅


/-- Tensoring an exact pair on the right gives an exact pair -/
theorem rTensor_exact : Exact (rTensor Q f) (rTensor Q g)

{R : Type u_1}
{M : Type u_2}
{N : Type u_3}
{P : Type u_4}
[CommRing R]
[AddCommGroup M]
[AddCommGroup N]
[AddCommGroup P]
[Module R M]
[Module R N]
[Module R P]
{f : M →ₗ[R] N}
{g : N →ₗ[R] P}
(Q : Type u_5)
[AddCommGroup Q]
[Module R Q]
(hfg : Function.Exact ⇑f ⇑g)
(hg : Function.Surjective ⇑g)

Function.Exact ⇑(LinearMap.rTensor Q f) ⇑(LinearMap.rTensor Q g)


lemma le_egauge_smul_right (c : 𝕜) (s : Set E) (x : E) :
    ‖c‖₊ * egauge 𝕜 s x ≤ egauge 𝕜 s (c • x)

{𝕜 : Type u_1}
[NormedDivisionRing 𝕜]
{E : Type u_3}
[AddCommGroup E]
[Module 𝕜 E]
(c : 𝕜)
(s : Set E)
(x : E)

↑‖c‖₊ * egauge 𝕜 s x ≤ egauge 𝕜 s (c • x)


@[to_additive]
theorem setIntegral_eq_tsum (h : IsFundamentalDomain G s μ) {f : α → E} {t : Set α}
    (hf : IntegrableOn f t μ) : ∫ x in t, f x ∂μ = ∑' g : G, ∫ x in t ∩ g • s, f x ∂μ

[MeasureTheory.VAddInvariantMeasure G α μ]

(h : MeasureTheory.IsAddFundamentalDomain G s μ)

∫ (x : α) in t, f x ∂μ = ∑' (g : G), ∫ (x : α) in t ∩ (g +ᵥ s), f x ∂μ


theorem Seminorm.gaugeSeminorm_ball (p : Seminorm ℝ E) :
    gaugeSeminorm (p.balanced_ball_zero 1) (p.convex_ball 0 1) (p.absorbent_ball_zero zero_lt_one) =
      p

{E : Type u_2}
[AddCommGroup E]
[Module ℝ E]
(p : Seminorm ℝ E)


theorem support_binomial' (k m : ℕ) (x y : R) :
    Polynomial.support (C x * X ^ k + C y * X ^ m) ⊆ {k, m}

{R : Type u}
[Semiring R]
(k m : ℕ)
(x y : R)

(Polynomial.C x * Polynomial.X ^ k + Polynomial.C y * Polynomial.X ^ m).support ⊆ {k, m}


@[simp] lemma map_id : L.map (LatticeHom.id α) = L

{α : Type u_2}
[Lattice α]
{L : Sublattice α}


theorem mass_nonzero_iff (μ : FiniteMeasure Ω) : μ.mass ≠ 0 ↔ μ ≠ 0

{Ω : Type u_1}
[MeasurableSpace Ω]
(μ : MeasureTheory.FiniteMeasure Ω)


@[simp]
theorem constantBaseRingEquiv_tprod (x : ι → R) :
    constantBaseRingEquiv ι R (tprod R x) = ∏ i, x i

{ι : Type u_1}
{R : Type u_3}
[CommSemiring R]
[Fintype ι]
(x : ι → R)

(PiTensorProduct.constantBaseRingEquiv ι R) ((PiTensorProduct.tprod R) x) = ∏ i : ι, x i


theorem arccos_eq_arctan {x : ℝ} (h : 0 < x) : arccos x = arctan (√(1 - x ^ 2) / x)

Real.arccos x = Real.arctan (√(1 - x ^ 2) / x)


@[to_additive]
theorem prod_Ico_add [OrderedCancelAddCommMonoid α] [ExistsAddOfLE α] [LocallyFiniteOrder α]
    (f : α → M) (a b c : α) : (∏ x ∈ Ico a b, f (c + x)) = ∏ x ∈ Ico (a + c) (b + c), f x

{α : Type u_1}
{M : Type u_2}
[CommMonoid M]
[OrderedCancelAddCommMonoid α]
[ExistsAddOfLE α]
[LocallyFiniteOrder α]
(f : α → M)
(a b c : α)

∏ x ∈ Finset.Ico a b, f (c + x) = ∏ x ∈ Finset.Ico (a + c) (b + c), f x


lemma iIndepSets.meas_iInter [Fintype ι] (h : iIndepSets π μ) (hs : ∀ i, s i ∈ π i) :
    μ (⋂ i, s i) = ∏ i, μ (s i)

{Ω : Type u_1}
{ι : Type u_2}
{π : ι → Set (Set Ω)}

∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι],
  ProbabilityTheory.iIndepSets π μ → (∀ (i : ι), s i ∈ π i) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)


@[simp]
theorem coe_toHomeomorph : ⇑e.toHomeomorph = e

{R : Type u_1}
{R₂ : Type u_2}
{E : Type u_5}
{E₂ : Type u_6}
[Semiring R]
[Semiring R₂]
{σ₁₂ : R →+* R₂}
{σ₂₁ : R₂ →+* R}
[RingHomInvPair σ₁₂ σ₂₁]
[RingHomInvPair σ₂₁ σ₁₂]
[SeminormedAddCommGroup E]
[SeminormedAddCommGroup E₂]
[Module R E]
[Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂)


theorem iSup_div (f : ι → ℝ≥0) (a : ℝ≥0) : (⨆ i, f i) / a = ⨆ i, f i / a


theorem isLocallyInjective_iff_isOpen_diagonal {f : X → Y} :
    IsLocallyInjective f ↔ IsOpen f.pullbackDiagonal

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
{f : X → Y}

IsLocallyInjective f ↔ IsOpen (Function.pullbackDiagonal f)


@[simp]
theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign


{R : Type u_1}
[CommMonoidWithZero R]
{n : ℕ}
(χ : DirichletCharacter R n)
(hn : n = 1)


/-- The interior of a balanced set is balanced if it contains the origin. -/
protected theorem Balanced.interior (hA : Balanced 𝕜 A) (h : (0 : E) ∈ interior A) :
    Balanced 𝕜 (interior A)

{𝕜 : Type u_1}
{E : Type u_3}
[NormedField 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
{A : Set E}
[TopologicalSpace E]
[ContinuousSMul 𝕜 E]
(hA : Balanced 𝕜 A)
(h : 0 ∈ interior A)


theorem span_preimage_le (f : F) (s : Set M₂) :
    span R (f ⁻¹' s) ≤ (span R₂ s).comap f

{R : Type u_1}
{R₂ : Type u_2}
{M : Type u_4}
{M₂ : Type u_5}
[Semiring R]
[AddCommMonoid M]
[Module R M]
[Semiring R₂]
{σ₁₂ : R →+* R₂}
[AddCommMonoid M₂]
[Module R₂ M₂]
{F : Type u_8}
[FunLike F M M₂]
[SemilinearMapClass F σ₁₂ M M₂]
(f : F)
(s : Set M₂)

Submodule.span R (⇑f ⁻¹' s) ≤ Submodule.comap f (Submodule.span R₂ s)


@[simp]
lemma φ_four :
    W.φ 4 = C X * C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 4 * C W.Ψ₃ + C W.Ψ₃ ^ 4

{R : Type r}
[CommRing R]
(W : WeierstrassCurve R)

W.φ 4 =
  Polynomial.C Polynomial.X * Polynomial.C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 -
      Polynomial.C W.preΨ₄ * W.ψ₂ ^ 4 * Polynomial.C W.Ψ₃ +
    Polynomial.C W.Ψ₃ ^ 4


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

{α : Type u}
[SubtractionMonoid α]
{a : α}
(h : IsAddUnit a)


theorem eq_ones_iff {c : Composition n} : c = ones n ↔ ∀ i ∈ c.blocks, i = 1

c = Composition.ones n ↔ ∀ i ∈ c.blocks, i = 1


/-- The inverse of a group homomorphism is a group homomorphism if the target is commutative. -/
@[to_additive
      "The negation of an additive group homomorphism is an additive group homomorphism
      if the target is commutative."]
theorem inv {α β} [Group α] [CommGroup β] {f : α → β} (hf : IsGroupHom f) :
    IsGroupHom fun a => (f a)⁻¹

{α : Type u_1}
{β : Type u_2}
[Group α]
[CommGroup β]
{f : α → β}
(hf : IsGroupHom f)


/-- `HasImages` asserts that every morphism has an image. -/
class HasImages : Prop where
  has_image : ∀ {X Y : C} (f : X ⟶ Y), HasImage f

[self : CategoryTheory.Limits.HasImages C]


theorem nnnorm_def (x : tsze R M) : ‖x‖₊ = ‖fst x‖₊ + ‖snd x‖₊

{R : Type u_3}
{M : Type u_4}
[SeminormedRing R]
[SeminormedAddCommGroup M]
(x : tsze R M)


@[simp, norm_cast]
theorem coe_pow (I : FractionalIdeal S P) (n : ℕ) : ↑(I ^ n) = (I : Submodule R P) ^ n

{R : Type u_1}
[CommRing R]
{S : Submonoid R}
{P : Type u_2}
[CommRing P]
[Algebra R P]
(I : FractionalIdeal S P)
(n : ℕ)


@[simp]
theorem not_lt_one (n : ℕ+) : ¬n < 1


/-- Forgetting the `B` action, a `Submodule` over `A ⊗[R] B` is just a `Submodule` over `A`. -/
@[simps]
def toSubmodule (p : Submodule (A ⊗[R] B) M) : Submodule A M

{R : Type u_1}
{A : Type u_2}
{B : Type u_3}
{M : Type u_4}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
[Semiring A]
[Semiring B]
[Module A M]
[Module B M]
[Algebra R A]
[Algebra R B]
[IsScalarTower R A M]
[IsScalarTower R B M]
[SMulCommClass A B M]
(p : Submodule (A ⊗[R] B) M)


@[simp]
theorem pathEquivList_cons (p : Path (star α) (star α)) (a : star α ⟶ star α) :
    pathEquivList (Path.cons p a) = a :: pathToList p

(p : Quiver.Path (Quiver.SingleObj.star α) (Quiver.SingleObj.star α))

(a : Quiver.SingleObj.star α ⟶ Quiver.SingleObj.star α)

Quiver.SingleObj.pathEquivList (p.cons a) = a :: Quiver.SingleObj.pathToList p


@[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ofReal' n = n


@[simp]
theorem edgeFinset_bot : (⊥ : SimpleGraph V).edgeFinset = ∅


lemma congr_append : ∀ (a b : String), a ++ b = String.mk (a.data ++ b.data)


theorem smoothAt_snd {p : M × N} : SmoothAt (I.prod J) J Prod.snd p

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{F : Type u_11}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type u_12}
[TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G}
{N : Type u_13}
[TopologicalSpace N]
[ChartedSpace G N]
{p : M × N}


theorem eLpNorm_condexpL2_le (hm : m ≤ m0) (f : α →₂[μ] E) :
    eLpNorm (F := E) (condexpL2 E 𝕜 hm f) 2 μ ≤ eLpNorm f 2 μ

{α : Type u_1}
{E : Type u_2}
{𝕜 : Type u_7}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
[CompleteSpace E]
{m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
(hm : m ≤ m0)
(f : ↥(MeasureTheory.Lp E 2 μ))

MeasureTheory.eLpNorm (↑↑↑((MeasureTheory.condexpL2 E 𝕜 hm) f)) 2 μ ≤ MeasureTheory.eLpNorm (↑↑f) 2 μ


/-- An element is a root of its minimal polynomial. -/
@[simp]
theorem aeval : aeval x (minpoly A x) = 0

(A : Type u_1)
{B : Type u_2}
[CommRing A]
[Ring B]
[Algebra A B]
(x : B)


theorem cthickening_max_zero (δ : ℝ) (E : Set α) : cthickening (max 0 δ) E = cthickening δ E

{α : Type u}
[PseudoEMetricSpace α]
(δ : ℝ)
(E : Set α)

Metric.cthickening (max 0 δ) E = Metric.cthickening δ E


/-- Given a distinguished triangle `T` such that `T.mor₃ = 0` and the datum of morphisms
`inr : T.obj₃ ⟶ T.obj₂` and `fst : T.obj₂ ⟶ T.obj₁` satisfying suitable relations, this
is the binary biproduct data expressing that `T.obj₂` identifies to the binary
biproduct of `T.obj₁` and `T.obj₃`.
See also `exists_iso_binaryBiproduct_of_distTriang`. -/
@[simps]
def binaryBiproductData (T : Triangle C) (hT : T ∈ distTriang C) (hT₀ : T.mor₃ = 0)
    (inr : T.obj₃ ⟶ T.obj₂) (inr_snd : inr ≫ T.mor₂ = 𝟙 _) (fst : T.obj₂ ⟶ T.obj₁)
    (total : fst ≫ T.mor₁ + T.mor₂ ≫ inr = 𝟙 T.obj₂) :
    BinaryBiproductData T.obj₁ T.obj₃

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

(T : CategoryTheory.Pretriangulated.Triangle C)

(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)

(CategoryTheory.Pretriangulated.binaryBiproductData T hT hT₀ inr inr_snd fst total).bicone.inl = T.mor₁


@[simp]
theorem zmodEquivZPowers_apply_coe_int (i : ℤ) :
    h.zmodEquivZPowers i = Additive.ofMul (⟨ζ ^ i, i, rfl⟩ : Subgroup.zpowers ζ)

{R : Type u_4}
{k : ℕ}
[CommRing R]
{ζ : Rˣ}
(h : IsPrimitiveRoot ζ k)
(i : ℤ)

h.zmodEquivZPowers ↑i = Additive.ofMul ⟨ζ ^ i, ⋯⟩