/--
A class describing the property of reflecting finite effective epimorphic families.
-/
class ReflectsFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects finite effective epimorphic families if finite families that are
  mapped to effective epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π

(CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) → CategoryTheory.EffectiveEpiFamily X π


theorem continuousAt_const_cpow' {a b : ℂ} (h : b ≠ 0) : ContinuousAt (fun x : ℂ => a ^ x) b


theorem PseudoMetricSpace.replaceUniformity_eq {α} [U : UniformSpace α] (m : PseudoMetricSpace α)
    (H : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace]) : m.replaceUniformity H = m

{α : Type u_3}
[U : UniformSpace α]
(m : PseudoMetricSpace α)
(H : 𝓤 α = 𝓤 α)


theorem isPreconnected_setOf_wSameSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.WSameSide x y }

{V : Type u_2}
{P : Type u_4}
[SeminormedAddCommGroup V]
[NormedSpace ℝ V]
[PseudoMetricSpace P]
[NormedAddTorsor V P]
(s : AffineSubspace ℝ P)
(x : P)


theorem symm_trans (h₁ : X ≃ₕ Y) (h₂ : Y ≃ₕ Z) : (h₁.trans h₂).symm = h₂.symm.trans h₁.symm

{X : Type u}
{Y : Type v}
{Z : Type w}
[TopologicalSpace X]
[TopologicalSpace Y]
[TopologicalSpace Z]
(h₁ : X ≃ₕ Y)
(h₂ : Y ≃ₕ Z)


/-- A natural transformation `R₁ ⟶ R₂` induces a functor `Comma L R₁ ⥤ Comma L R₂`. -/
@[simps]
def mapRight (r : R₁ ⟶ R₂) : Comma L R₁ ⥤ Comma L R₂

{A : Type u₁}
[CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₂}
[CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃}
[CategoryTheory.Category.{v₃, u₃} T]
(L : CategoryTheory.Functor A T)
{R₁ R₂ : CategoryTheory.Functor B T}
(r : R₁ ⟶ R₂)
(X : CategoryTheory.Comma L R₁)

((CategoryTheory.Comma.mapRight L r).obj X).right = X.right


/-- The splitting of the short complex `S.op` deduced from a splitting of `S`. -/
@[simps]
def op (h : Splitting S) : Splitting S.op

{C : Type u_1}
[CategoryTheory.Category.{u_3, u_1} C]
[CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}
(h : S.Splitting)


@[to_additive]
theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
    s / closedBall x δ = x⁻¹ • cthickening δ s

{E : Type u_1}
[SeminormedCommGroup E]
{δ : ℝ}
{s : Set E}
(hs : IsCompact s)
(hδ : 0 ≤ δ)
(x : E)

s / Metric.closedBall x δ = x⁻¹ • Metric.cthickening δ s


@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis (fun V : Set G => V ∈ (𝓝 1 : Filter G)) fun V =>
      { f : α → G | ∀ x, f x ∈ V }

{α : Type u_1}
{G : Type u_2}
[AddGroup G]
[UniformSpace G]
[UniformAddGroup G]

(𝓝 0).HasBasis (fun V => V ∈ 𝓝 0) fun V => {f | ∀ (x : α), f x ∈ V}


/-- The degree of `cyclotomic' n R` is `totient n` if there is a primitive root of unity in `R`. -/
theorem degree_cyclotomic' {ζ : R} {n : ℕ} (h : IsPrimitiveRoot ζ n) :
    (cyclotomic' n R).degree = Nat.totient n

{R : Type u_1}
[CommRing R]
[IsDomain R]
{ζ : R}
{n : ℕ}
(h : IsPrimitiveRoot ζ n)

(Polynomial.cyclotomic' n R).degree = ↑n.totient


{α : Type u_1}
[Preorder α]
[OrderBot α]
[LocallyFiniteOrder α]


/-- The symmetry of homotopy between morphisms of short complexes. -/
@[simps]
def symm (h : Homotopy φ₁ φ₂) : Homotopy φ₂ φ₁

{φ₁ φ₂ : S₁ ⟶ S₂}

(h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)


theorem pairwiseDisjoint_pi {ι' α : ι → Type*} {s : ∀ i, Set (ι' i)} {f : ∀ i, ι' i → Set (α i)}
    (hs : ∀ i, (s i).PairwiseDisjoint (f i)) :
    ((univ : Set ι).pi s).PairwiseDisjoint fun I => (univ : Set ι).pi fun i => f _ (I i)

(hs : ∀ (i : ι), (s i).PairwiseDisjoint (f i))

(Set.univ.pi s).PairwiseDisjoint fun I => Set.univ.pi fun i => f i (I i)


theorem canonicalEquiv_trans_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
    [IsLocalization S P''] :
    (canonicalEquiv S P P').trans (canonicalEquiv S P' P'') = canonicalEquiv S P P''

{R : Type u_1}
[CommRing R]
(S : Submonoid R)
(P : Type u_2)
[CommRing P]
[Algebra R P]
[loc : IsLocalization S P]
(P' : Type u_3)
[CommRing P']
[Algebra R P']
[loc' : IsLocalization S P']
(P'' : Type u_5)
[CommRing P'']
[Algebra R P'']
[IsLocalization S P'']

(FractionalIdeal.canonicalEquiv S P P').trans (FractionalIdeal.canonicalEquiv S P' P'') =
  FractionalIdeal.canonicalEquiv S P P''


theorem Codisjoint.himp_eq_left (h : Codisjoint a b) : a ⇨ b = b

{α : Type u_2}
[GeneralizedHeytingAlgebra α]
{a b : α}
(h : Codisjoint a b)


@[simp]
theorem ker_coe_equiv (f : R ≃+* S) : ker (f : R →+* S) = ⊥

{R : Type u}
{S : Type v}
[Ring R]
[Semiring S]
(f : R ≃+* S)


theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.fst = c.inl.op

(c : CategoryTheory.Limits.PushoutCocone f g)


@[to_additive ne_zero_of_mem_unit_sphere]
theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1

{E : Type u_6}
[SeminormedAddGroup E]
(x : ↑(Metric.sphere 0 1))


/-- If `χ` is of odd order, then `χ(-1) = 1` -/
lemma val_neg_one_eq_one_of_odd_order {χ : MulChar R R'} {n : ℕ} (hn : Odd n) (hχ : χ ^ n = 1) :
    χ (-1) = 1

{R : Type u_1}
{R' : Type u_2}
[CommRing R]
[CommMonoidWithZero R']
{χ : MulChar R R'}
{n : ℕ}
(hn : Odd n)
(hχ : χ ^ n = 1)


@[simp]
lemma incl_map {A B : PointedGaloisObject F} (f : A ⟶ B) : (incl F).map f = f.val

(F : CategoryTheory.Functor C FintypeCat)

{A B : CategoryTheory.PreGaloisCategory.PointedGaloisObject F}

(CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl F).map f = f.val


theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
    (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion }

{ι : Type u_1}
[Fintype ι]
(l : BoxIntegral.IntegrationParams)
(I : BoxIntegral.Box ι)
(π₀ : BoxIntegral.Prepartition I)

(l.toFilteriUnion I π₀).HasBasis (fun r => ∀ (c : ℝ≥0), l.RCond (r c)) fun r =>
  {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion}


theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal |r|


theorem inf_sup_self (a b : α) : a ⊓ (a ⊔ b) = a

{α : Type u_1}
[BooleanRing α]
(a b : α)


/-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M

{M : Type u_1}
[Field M]
[IsAlgClosed M]
{R : Type u_2}
[CommRing R]
{S : Type u_3}
[CommRing S]
[IsDomain S]
[Algebra R S]
[Algebra R M]
[NoZeroSMulDivisors R S]
[NoZeroSMulDivisors R M]
[Algebra.IsAlgebraic R S]

IsAlgClosed.lift =
  let_fun this := ⋯;
  let_fun this_1 := ⋯;
  let f := IsAlgClosed.lift_aux (FractionRing R) (FractionRing S) M;
  (AlgHom.restrictScalars R f).comp (AlgHom.restrictScalars R (Algebra.ofId S (FractionRing S)))


@[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n

{M : Type u_4}
[Monoid M]
{n : ℕ}
(hn : n ≠ 0)
(a : M)


theorem nhdsWithin_eq_nhdsWithin {a : α} {s t u : Set α} (h₀ : a ∈ s) (h₁ : IsOpen s)
    (h₂ : t ∩ s = u ∩ s) : 𝓝[t] a = 𝓝[u] a

{α : Type u_1}
[TopologicalSpace α]
{a : α}
{s t u : Set α}
(h₀ : a ∈ s)
(h₁ : IsOpen s)
(h₂ : t ∩ s = u ∩ s)


theorem isPiSystem_iUnion_of_directed_le {α ι} (p : ι → Set (Set α))
    (hp_pi : ∀ n, IsPiSystem (p n)) (hp_directed : Directed (· ≤ ·) p) :
    IsPiSystem (⋃ n, p n)

(hp_directed : Directed (fun x x_1 => x ≤ x_1) p)


theorem ball_sub_closedBall (hε : 0 < ε) (hδ : 0 ≤ δ) (a b : E) :
    ball a ε - closedBall b δ = ball (a - b) (ε + δ)

{E : Type u_2}
[SeminormedAddCommGroup E]
[NormedSpace ℝ E]
{δ ε : ℝ}
(hε : 0 < ε)
(hδ : 0 ≤ δ)
(a b : E)

Metric.ball a ε - Metric.closedBall b δ = Metric.ball (a - b) (ε + δ)


@[simp]
theorem range_arctan : range arctan = Ioo (-(π / 2)) (π / 2)

Set.range Real.arctan = Set.Ioo (-(Real.pi / 2)) (Real.pi / 2)


theorem derivative_C_mul_X (a : R) : derivative (C a * X) = C a

Polynomial.derivative (Polynomial.C a * Polynomial.X) = Polynomial.C a


@[to_additive]
theorem comp_lift (g : M →* N) (f : α → M) : g.comp (lift f) = lift (g ∘ f)

{α : Type u_1}
{M : Type u_4}
[Monoid M]
{N : Type u_5}
[Monoid N]
(g : M →* N)
(f : α → M)

g.comp (FreeMonoid.lift f) = FreeMonoid.lift (⇑g ∘ f)


theorem condexp_nonneg {E} [NormedLatticeAddCommGroup E] [CompleteSpace E] [NormedSpace ℝ E]
    [OrderedSMul ℝ E] {f : α → E} (hf : 0 ≤ᵐ[μ] f) : 0 ≤ᵐ[μ] μ[f|m]

{α : Type u_1}
{m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{E : Type u_5}
[NormedLatticeAddCommGroup E]
[CompleteSpace E]
[NormedSpace ℝ E]
[OrderedSMul ℝ E]
{f : α → E}
(hf : 0 ≤ᵐ[μ] f)


@[to_additive IsAddCyclic.card_nsmul_eq_zero_le]
theorem IsCyclic.card_pow_eq_one_le [DecidableEq α] [Fintype α] [IsCyclic α] {n : ℕ} (hn0 : 0 < n) :
    (univ.filter fun a : α => a ^ n = 1).card ≤ n

{α : Type u}
[AddGroup α]
[DecidableEq α]
[Fintype α]
[IsAddCyclic α]
{n : ℕ}
(hn0 : 0 < n)

(Finset.filter (fun a => n • a = 0) Finset.univ).card ≤ n


protected theorem FiberBundle.isCoveringMap {F : Type*} {E : X → Type*} [TopologicalSpace F]
    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
    [FiberBundle F E] : IsCoveringMap (π F E)


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


@[to_additive]
theorem min_mul_distrib' (a b c : α) : min (a * b) c = min (min a c * min b c) c

min (a + b) c = min (min a c + min b c) c


theorem leadingCoeff_of_single {a : Γ} {r : R} : leadingCoeff (single a r) = r

{Γ : Type u_1}
{R : Type u_2}
[PartialOrder Γ]
[Zero R]
{a : Γ}
{r : R}

((HahnSeries.single a) r).leadingCoeff = r


/-- If `H` is a subgroup of `G` of cardinality `p ^ n`, then the cardinality of the
  normalizer of `H` is congruent mod `p ^ (n + 1)` to the cardinality of `G`.  -/
theorem card_normalizer_modEq_card [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime] {H : Subgroup G}
    (hH : Nat.card H = p ^ n) : Nat.card (normalizer H) ≡ Nat.card G [MOD p ^ (n + 1)]

{G : Type u}
[Group G]
[Finite G]
{p n : ℕ}
[hp : Fact (Nat.Prime p)]
{H : Subgroup G}
(hH : Nat.card ↥H = p ^ n)

Nat.card ↥H.normalizer ≡ Nat.card G [MOD p ^ (n + 1)]


/--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap

(I : CategoryTheory.Limits.MultispanIndex C)


theorem monotone_restrict : Monotone fun π : Prepartition I => restrict π J

{ι : Type u_1}
{I J : BoxIntegral.Box ι}


theorem differentiableWithinAt_inter' (ht : t ∈ 𝓝[s] x) :
    DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
{x : E}
{s t : Set E}
(ht : t ∈ 𝓝[s] x)


theorem Summable.of_nnnorm {f : ι → E} (hf : Summable fun a => ‖f a‖₊) : Summable f

{ι : Type u_1}
{E : Type u_3}
[SeminormedAddCommGroup E]
[CompleteSpace E]
{f : ι → E}
(hf : Summable fun a => ‖f a‖₊)


@[simp]
theorem comap_id_apply (x : σ → R) : comap (AlgHom.id R (MvPolynomial σ R)) x = x

{σ : Type u_1}
{R : Type u_4}
[CommSemiring R]
(x : σ → R)

MvPolynomial.comap (AlgHom.id R (MvPolynomial σ R)) x = x


/-- `TrivSqZeroExt.inr` as a continuous linear map. -/
@[simps]
def inrCLM [CommSemiring R] [AddCommMonoid M] [Module R M] : M →L[R] tsze R M

(R : Type u_3)
(M : Type u_4)
[TopologicalSpace R]
[TopologicalSpace M]
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
(m : M)

(TrivSqZeroExt.inrCLM R M) m = TrivSqZeroExt.inr m


theorem pderiv_pow {i : σ} {f : MvPolynomial σ R} {n : ℕ} :
    pderiv i (f ^ n) = n * f ^ (n - 1) * pderiv i f

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

(MvPolynomial.pderiv i) (f ^ n) = ↑n * f ^ (n - 1) * (MvPolynomial.pderiv i) f


theorem front : ∀ {s}, ValidFor l (c :: m) r s → s.front = c

{l : List Char}
{c : Char}
{m r : List Char}
{s : Substring}

Substring.ValidFor l (c :: m) r s → s.front = c


@[reassoc (attr := simp)]
theorem biproduct.ι_matrix (m : ∀ j k, f j ⟶ g k) (j : J) :
    biproduct.ι f j ≫ biproduct.matrix m = biproduct.lift fun k => m j k

CategoryTheory.Limits.biproduct.ι f j ≫ CategoryTheory.Limits.biproduct.matrix m =
  CategoryTheory.Limits.biproduct.lift fun k => m j k


lemma isSMulRegular_iff_ker_lsmul_eq_bot :
    IsSMulRegular M r ↔ LinearMap.ker (LinearMap.lsmul R M r) = ⊥

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

IsSMulRegular M r ↔ LinearMap.ker ((LinearMap.lsmul R M) r) = ⊥


@[simp]
theorem algebraMap_eq_toLaurent (f : R[X]) : algebraMap R[X] R[T;T⁻¹] f = toLaurent f

{R : Type u_1}
[CommSemiring R]
(f : R[X])

(algebraMap R[X] R[T;T⁻¹]) f = Polynomial.toLaurent f


theorem coeff_inv_units (u : R[X]ˣ) (n : ℕ) : ((↑u : R[X]).coeff n)⁻¹ = (↑u⁻¹ : R[X]).coeff n

{R : Type u}
[Field R]
(u : R[X]ˣ)
(n : ℕ)


@[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Subgroup Gᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂

{G : Type u_2}
[AddGroup G]
{S₁ S₂ : AddSubgroup Gᵃᵒᵖ}


@[simp] protected theorem lt_irrefl (s : String) : ¬ s < s


protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
    Semiconj f (· + a) (· + b)

{F : Type u_1}
{G : Type u_2}
{H : Type u_3}
[FunLike F G H]
{a : G}
{b : H}
[Add G]
[Add H]
[AddConstMapClass F G H a b]
(f : F)

Function.Semiconj (⇑f) (fun x => x + a) fun x => x + b


theorem mk_coe_finset {α : Type u} {s : Finset α} : #s = ↑(Finset.card s)


@[simp] theorem length_merge (s : α → α → Bool) (l r) :
    (merge s l r).length = l.length + r.length

{α : Type u_1}
(s : α → α → Bool)
(l r : List α)

(List.merge s l r).length = l.length + r.length


@[simp]
theorem roots_pow (p : R[X]) (n : ℕ) : (p ^ n).roots = n • p.roots

{R : Type u}
[CommRing R]
[IsDomain R]
(p : Polynomial R)
(n : ℕ)


theorem Icc_mem_nhdsWithin_Ici (H : b ∈ Ico a c) : Icc a c ∈ 𝓝[≥] b

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


theorem closure_ae_eq_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    closure s =ᵐ[μ] s

{α' : Type u_6}
[TopologicalSpace α']
[MeasurableSpace α']
{μ : MeasureTheory.Measure α'}
{s : Set α'}
(h : μ (frontier s) = 0)


theorem eq_emptyOn [IsEmpty α] (M : Matroid α) : M = emptyOn α

{α : Type u_1}
[IsEmpty α]
(M : Matroid α)


@[simp]
theorem a_one_pow (k : ℕ) : (a 1 : QuaternionGroup n) ^ k = a k

QuaternionGroup.a 1 ^ k = QuaternionGroup.a ↑k


@[simp]
theorem id_comp {U V : Type*} [Quiver U] [Quiver V] (F : Prefunctor U V) :
    (id _).comp F = F

{U : Type u_1}
{V : Type u_2}
[Quiver U]
[Quiver V]
(F : U ⥤q V)


theorem isClopen_iInter_of_finite [Finite Y] {s : Y → Set X} (h : ∀ i, IsClopen (s i)) :
    IsClopen (⋂ i, s i)

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[Finite Y]
{s : Y → Set X}
(h : ∀ (i : Y), IsClopen (s i))


@[to_additive]
theorem Submonoid.mem_nhds_one (S : Submonoid M) (oS : IsOpen (S : Set M)) :
    (S : Set M) ∈ 𝓝 (1 : M)

{M : Type u_3}
[TopologicalSpace M]
[CommMonoid M]
(S : Submonoid M)
(oS : IsOpen ↑S)


/-- If `I` is a nonzero fractional ideal, then `I` is equal to the product `∏_v v^(count K v I)`. -/
theorem finprod_heightOneSpectrum_factorization' {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) :
    ∏ᶠ v : HeightOneSpectrum R, (v.asIdeal : FractionalIdeal R⁰ K) ^ (count K v I) = I

{R : Type u_1}
[CommRing R]
(K : Type u_2)
[Field K]
[Algebra R K]
[IsFractionRing R K]
[IsDedekindDomain R]
{I : FractionalIdeal R⁰ K}
(hI : I ≠ 0)

∏ᶠ (v : IsDedekindDomain.HeightOneSpectrum R), ↑v.asIdeal ^ FractionalIdeal.count K v I = I


@[simp]
theorem cospanExt_inv_app_left :
    (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.left = iX.inv

{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 ⟶ Z}
{g : Y ⟶ Z}
{f' : X' ⟶ Z'}
{g' : Y' ⟶ Z'}
(wf : iX.hom ≫ f' = f ≫ iZ.hom)
(wg : iY.hom ≫ g' = g ≫ iZ.hom)

(CategoryTheory.Limits.cospanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingCospan.left = iX.inv


theorem continuousOn_sub :
    ContinuousOn (fun p : ℝ≥0∞ × ℝ≥0∞ => p.fst - p.snd) { p : ℝ≥0∞ × ℝ≥0∞ | p ≠ ⟨∞, ∞⟩ }

ContinuousOn (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)}


@[reassoc (attr := simp)]
lemma whiskerLeft_snd (X : C) {Y₁ Y₂ : C} (g : Y₁ ⟶ Y₂) :
    (X ◁ g) ≫ snd _ _ = snd _ _ ≫ g

{C : Type u}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.ChosenFiniteProducts C]
(X : C)
{Y₁ Y₂ : C}
(g : Y₁ ⟶ Y₂)

CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X g)
    (CategoryTheory.ChosenFiniteProducts.snd X Y₂) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ChosenFiniteProducts.snd X Y₁) g


@[to_additive] lemma oneLePart_inf_leOnePart_eq_one (a : α) : a⁺ᵐ ⊓ a⁻ᵐ = 1

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

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

a⁺ᵐ ⊓ a⁻ᵐ = 1


/-- The application of a natural isomorphism to an object. We put this definition in a different
namespace, so that we can use `α.app` -/
@[simps]
def app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    F.obj X ≅ G.obj X

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{F G : C ⥤ D}
(α : F ≅ G)
(X : C)


theorem iSup_pair {f : β → α} {a b : β} : ⨆ x ∈ ({a, b} : Set β), f x = f a ⊔ f b

{α : Type u_1}
{β : Type u_2}
[CompleteLattice α]
{f : β → α}
{a b : β}


/-- `Finsupp.mapDomain` is an `AddMonoidHom`. -/
@[simps]
def mapDomain.addMonoidHom (f : α → β) : (α →₀ M) →+ β →₀ M

{α : Type u_1}
{β : Type u_2}
{M : Type u_5}
[AddCommMonoid M]
(f : α → β)
(v : α →₀ M)

(Finsupp.mapDomain.addMonoidHom f) v = Finsupp.mapDomain f v


/-- A nonempty convex set is path connected. -/
protected theorem Convex.isPathConnected {s : Set E} (hconv : Convex ℝ s) (hne : s.Nonempty) :
    IsPathConnected s

{E : Type u_3}
[AddCommGroup E]
[Module ℝ E]
[TopologicalSpace E]
[TopologicalAddGroup E]
[ContinuousSMul ℝ E]
{s : Set E}
(hconv : Convex ℝ s)
(hne : s.Nonempty)


/-- `g : R ≃+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S

{R : Type u_17}
{S : Type u_18}
[Semiring R]
[Semiring S]
(g : R ≃+* S)
(a : S)

(Module.compHom.toLinearEquiv g).symm a = g.symm a


@[simp] lemma den_ofNat (n : ℕ) [n.AtLeastTwo] : den (no_index (OfNat.ofNat n)) = 1


/-- Let `I` be a fractional ideal of `K`. Assume that `f : InfinitePlace K → ℝ≥0` is such that
`minkowskiBound K I < volume (convexBodyLT K f)` where `convexBodyLT K f` is the set of
points `x` such that `‖x w‖ < f w` for all infinite places `w` (see `convexBodyLT_volume` for
the computation of this volume), then there exists a nonzero algebraic number `a` in `I` such
that `w a < f w` for all infinite places `w`. -/
theorem exists_ne_zero_mem_ideal_lt (h : minkowskiBound K I < volume (convexBodyLT K f)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w

{f : NumberField.InfinitePlace K → NNReal}

(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ)

(h : NumberField.mixedEmbedding.minkowskiBound K I < MeasureTheory.volume (NumberField.mixedEmbedding.convexBodyLT K f))

∃ a ∈ ↑I, a ≠ 0 ∧ ∀ (w : NumberField.InfinitePlace K), w a < ↑(f w)


/-- Suppose that `p₁` and `p₂` lie in spheres `s₁` and `s₂`. Then the vector between the centers
of those spheres is orthogonal to that between `p₁` and `p₂`; this is a version of
`inner_vsub_vsub_of_dist_eq_of_dist_eq` for bundled spheres. (In two dimensions, this says that
the diagonals of a kite are orthogonal.) -/
theorem inner_vsub_vsub_of_mem_sphere_of_mem_sphere {p₁ p₂ : P} {s₁ s₂ : Sphere P} (hp₁s₁ : p₁ ∈ s₁)
    (hp₂s₁ : p₂ ∈ s₁) (hp₁s₂ : p₁ ∈ s₂) (hp₂s₂ : p₂ ∈ s₂) :
    ⟪s₂.center -ᵥ s₁.center, p₂ -ᵥ p₁⟫ = 0

{V : Type u_1}
{P : Type u_2}
[NormedAddCommGroup V]
[InnerProductSpace ℝ V]
[MetricSpace P]
[NormedAddTorsor V P]
{p₁ p₂ : P}
{s₁ s₂ : EuclideanGeometry.Sphere P}
(hp₁s₁ : p₁ ∈ s₁)
(hp₂s₁ : p₂ ∈ s₁)
(hp₁s₂ : p₁ ∈ s₂)
(hp₂s₂ : p₂ ∈ s₂)

⟪s₂.center -ᵥ s₁.center, p₂ -ᵥ p₁⟫_ℝ = 0


@[simp]
theorem get_replicate (a : α) (i : Fin n) : (Vector.replicate n a).get i = a

{n : ℕ}
{α : Type u_1}
(a : α)
(i : Fin n)

(Mathlib.Vector.replicate n a).get i = a


theorem nhdsWithin_subtype_eq_bot_iff {s t : Set X} {x : s} :
    𝓝[((↑) : s → X) ⁻¹' t] x = ⊥ ↔ 𝓝[t] (x : X) ⊓ 𝓟 s = ⊥

{X : Type u}
[TopologicalSpace X]
{s t : Set X}
{x : ↑s}

𝓝[Subtype.val ⁻¹' t] x = ⊥ ↔ 𝓝[t] ↑x ⊓ 𝓟 s = ⊥


@[to_additive nnnorm_zsmul_le]
theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊

{α : Type u_1}
[SeminormedAddCommGroup α]
(n : ℤ)
(a : α)

‖n • a‖₊ ≤ ‖n‖₊ * ‖a‖₊


theorem ClosedEmbedding.measurable {f : α → γ} (hf : ClosedEmbedding f) : Measurable f

{α : Type u_1}
{γ : Type u_3}
[TopologicalSpace α]
[MeasurableSpace α]
[OpensMeasurableSpace α]
[TopologicalSpace γ]
[MeasurableSpace γ]
[BorelSpace γ]
{f : α → γ}
(hf : ClosedEmbedding f)


theorem of_apply (x : K) : of K p x = mk _ _ (0, x)

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

(PerfectClosure.of K p) x = PerfectClosure.mk K p (0, x)


theorem Integrable.div_const {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => f x / c) μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{𝕜 : Type u_5}
[NormedDivisionRing 𝕜]
{f : α → 𝕜}
(h : MeasureTheory.Integrable f μ)
(c : 𝕜)

MeasureTheory.Integrable (fun x => f x / c) μ


/-- The vector space of functions on a `Fintype ι` has finrank equal to the cardinality of `ι`. -/
@[simp]
theorem FiniteDimensional.finrank_fintype_fun_eq_card : finrank R (η → R) = Fintype.card η

(R : Type u)
{η : Type u₁'}
[Ring R]
[StrongRankCondition R]
[Fintype η]

FiniteDimensional.finrank R (η → R) = Fintype.card η


lemma _root_.Set.Finite.absorbs_sUnion {T : Set (Set α)} (hT : T.Finite) :
    Absorbs M s (⋃₀ T) ↔ ∀ t ∈ T, Absorbs M s t

{M : Type u_1}
{α : Type u_2}
[Bornology M]
[SMul M α]
{s : Set α}
{T : Set (Set α)}
(hT : T.Finite)


theorem TendstoUniformlyOn.prod_map {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
    {f' : α' → β'} {p' : Filter ι'} {s' : Set α'} (h : TendstoUniformlyOn F f p s)
    (h' : TendstoUniformlyOn F' f' p' s') :
    TendstoUniformlyOn (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p')
      (s ×ˢ s')

{α : Type u}
{β : Type v}
{ι : Type x}
[UniformSpace β]
{F : ι → α → β}
{f : α → β}
{s : Set α}
{p : Filter ι}
{ι' : Type u_1}
{α' : Type u_2}
{β' : Type u_3}
[UniformSpace β']
{F' : ι' → α' → β'}
{f' : α' → β'}
{p' : Filter ι'}
{s' : Set α'}
(h : TendstoUniformlyOn F f p s)
(h' : TendstoUniformlyOn F' f' p' s')

TendstoUniformlyOn (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') (s ×ˢ s')


@[to_additive]
theorem nhds_hasBasis (B : GroupFilterBasis G) (x₀ : G) :
    HasBasis (@nhds G B.topology x₀) (fun V : Set G ↦ V ∈ B) fun V ↦ (fun y ↦ x₀ * y) '' V

{G : Type u}
[Group G]
(B : GroupFilterBasis G)
(x₀ : G)

(𝓝 x₀).HasBasis (fun V => V ∈ B) fun V => (fun y => x₀ * y) '' V


theorem associated_gcd_gcd [IsDomain R] [GCDMonoid R] :
    Associated (IsBezout.gcd x y) (GCDMonoid.gcd x y)

[Submodule.IsPrincipal (Ideal.span {x, y})]


@[to_additive]
theorem mul_lt_mul_of_lt_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α} (h₁ : a < b) (h₂ : c ≤ d) :
    a * c < b * d

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


@[aesop 90% apply]
theorem sub {x y : R} (hx : IsSelfAdjoint x) (hy : IsSelfAdjoint y) : IsSelfAdjoint (x - y)

{R : Type u_1}
[AddGroup R]
[StarAddMonoid R]
{x y : R}
(hx : IsSelfAdjoint x)
(hy : IsSelfAdjoint y)


theorem iff_true_right (ha : a) : (b ↔ a) ↔ b


theorem HasPDF.congr {X Y : Ω → E} {ℙ : Measure Ω} {μ : Measure E} (hXY : X =ᵐ[ℙ] Y)
    [hX : HasPDF X ℙ μ] : HasPDF Y ℙ μ

{Ω : Type u_1}
{E : Type u_2}
[MeasurableSpace E]

∀ {x : MeasurableSpace Ω} {X Y : Ω → E} {ℙ : MeasureTheory.Measure Ω} {μ : MeasureTheory.Measure E},
  X =ᵐ[ℙ] Y → ∀ [hX : MeasureTheory.HasPDF X ℙ μ], MeasureTheory.HasPDF Y ℙ μ


theorem Nat.not_lt_zero (n : Nat) : Not (LT.lt n 0)


theorem coeFn_const (b : β) : (const α b : α →ₘ[μ] β) =ᵐ[μ] Function.const α b

(α : Type u_1)
{β : Type u_2}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
[TopologicalSpace β]
(b : β)

↑(MeasureTheory.AEEqFun.const α b) =ᵐ[μ] Function.const α b


/-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity

(UniformSpace.uniformity.lift' fun s => s ○ s) ≤ UniformSpace.uniformity


/-- `x ↦ x / a` as an order isomorphism. -/
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α

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

(RelIso.symm (OrderIso.divRight a)) b = b * a


theorem measurePreserving_piFinSuccAbove {n : ℕ} {α : Fin (n + 1) → Type u}
    {m : ∀ i, MeasurableSpace (α i)} (μ : ∀ i, Measure (α i)) [∀ i, SigmaFinite (μ i)]
    (i : Fin (n + 1)) :
    MeasurePreserving (MeasurableEquiv.piFinSuccAbove α i) (Measure.pi μ)
      ((μ i).prod <| Measure.pi fun j => μ (i.succAbove j))

{m : (i : Fin (n + 1)) → MeasurableSpace (α i)}

(μ : (i : Fin (n + 1)) → MeasureTheory.Measure (α i))

[∀ (i : Fin (n + 1)), MeasureTheory.SigmaFinite (μ i)]

MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinSuccAbove α i)) (MeasureTheory.Measure.pi μ)
  ((μ i).prod (MeasureTheory.Measure.pi fun j => μ (i.succAbove j)))


/-- The fundamental property of the adjoint. -/
theorem adjoint_inner_left (A : E →L[𝕜] F) (x : E) (y : F) : ⟪(A†) y, x⟫ = ⟪y, A x⟫

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[RCLike 𝕜]
[NormedAddCommGroup E]
[NormedAddCommGroup F]
[InnerProductSpace 𝕜 E]
[InnerProductSpace 𝕜 F]
[CompleteSpace E]
[CompleteSpace F]
(A : E →L[𝕜] F)
(x : E)
(y : F)

⟪(ContinuousLinearMap.adjoint A) y, x⟫_𝕜 = ⟪y, A x⟫_𝕜


{α : Type u_1}
[Ring α]
[LinearOrder α]
(a : α)


/-- The union of the images of the maps `ExteriorAlgebra.ιMulti R n` for `n` running through
all natural numbers spans the exterior algebra. -/
lemma ιMulti_span :
    Submodule.span R (Set.range fun x : Σ n, (Fin n → M) => ιMulti R x.1 x.2) = ⊤

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

Submodule.span R (Set.range fun x => (ExteriorAlgebra.ιMulti R x.fst) x.snd) = ⊤


theorem mem_nhds {s : Set R} {x : R} : s ∈ 𝓝 x ↔ ∃ γ : Γ₀ˣ, { y | (v (y - x) : Γ₀) < γ } ⊆ s

{R : Type u}
[Ring R]
{Γ₀ : Type v}
[LinearOrderedCommGroupWithZero Γ₀]
[_i : Valued R Γ₀]
{s : Set R}
{x : R}

s ∈ 𝓝 x ↔ ∃ γ, {y | Valued.v (y - x) < ↑γ} ⊆ s


theorem IsPartition.infPrepartition (h₁ : π₁.IsPartition) {π₂ : Prepartition I}
    (h₂ : π₂.IsPartition) : (π₁.infPrepartition π₂).IsPartition

{ι : Type u_1}
{I : BoxIntegral.Box ι}
{π₁ : BoxIntegral.TaggedPrepartition I}
(h₁ : π₁.IsPartition)
{π₂ : BoxIntegral.Prepartition I}
(h₂ : π₂.IsPartition)


@[simp]
theorem map_neg [DecidableEq ι] (i : ι) (x : M') : g' (update v' i (-x)) = -g' (update v' i x)

{R : Type u_1}
[Semiring R]
{M' : Type u_5}
[AddCommGroup M']
[Module R M']
{N' : Type u_6}
[AddCommGroup N']
[Module R N']
{ι : Type u_7}
(g' : M' [⋀^ι]→ₗ[R] N')
(v' : ι → M')
[DecidableEq ι]
(i : ι)
(x : M')

g' (Function.update v' i (-x)) = -g' (Function.update v' i x)


/-- A version of `TrivSqZeroExt.snd_mul` with `*` instead of `•`. -/
@[simp]
theorem snd_mul [Semiring R] (x y : R[ε]) : snd (x * y) = fst x * snd y + snd x * fst y

{R : Type u_1}
[Semiring R]
(x y : R[ε])

TrivSqZeroExt.snd (x * y) = TrivSqZeroExt.fst x * TrivSqZeroExt.snd y + TrivSqZeroExt.snd x * TrivSqZeroExt.fst y


/-- A set of points is concyclic if it is cospherical and coplanar. (Most results are stated
directly in terms of `Cospherical` instead of using `Concyclic`.) -/
structure Concyclic (ps : Set P) : Prop where
  Cospherical : Cospherical ps
  Coplanar : Coplanar ℝ ps

{V : Type u_1}
{P : Type u_2}
[NormedAddCommGroup V]
[NormedSpace ℝ V]
[MetricSpace P]
[NormedAddTorsor V P]
{ps : Set P}
(self : EuclideanGeometry.Concyclic ps)


theorem IsOpen.upperSemicontinuousAt_indicator (hs : IsOpen s) (hy : y ≤ 0) :
    UpperSemicontinuousAt (indicator s fun _x => y) x

{α : Type u_1}
[TopologicalSpace α]
{β : Type u_2}
[Preorder β]
{x : α}
{s : Set α}
{y : β}
[Zero β]
(hs : IsOpen s)
(hy : y ≤ 0)

UpperSemicontinuousAt (s.indicator fun _x => y) x


protected theorem symm (h : e.IsImage s t) : e.symm.IsImage t s

{X : Type u_1}
{Y : Type u_3}
[TopologicalSpace X]
[TopologicalSpace Y]
{e : PartialHomeomorph X Y}
{s : Set X}
{t : Set Y}
(h : e.IsImage s t)


lemma predicateShift_predicateShift (a b c : A) (h : a + b = c) [ClosedUnderIsomorphisms P] :
    PredicateShift (PredicateShift P b) a = PredicateShift P c

CategoryTheory.PredicateShift (CategoryTheory.PredicateShift P b) a = CategoryTheory.PredicateShift P c


@[to_additive]
theorem Nonempty.of_mul_left : (s * t).Nonempty → s.Nonempty


theorem toIcoMod_eq_sub (a b : α) : toIcoMod hp a b = toIcoMod hp 0 (b - a) + a

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


/-- The identity morphism on a locally ringed space. -/
@[simps]
def id (X : LocallyRingedSpace.{u}) : Hom X X


theorem symm_apply (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e.symm b y = cast (congr_arg E (e.symm_coe_proj hb)) (e.toPartialEquiv.symm (b, y)).2

(e : Pretrivialization F Bundle.TotalSpace.proj)

e.symm b y = cast ⋯ (↑e.symm (b, y)).snd


theorem findMax_dual (t : Ordnode α) : findMax (dual t) = findMin t


/-- For any function `f : α → ℝ≥0∞`, there exists a measurable function `g ≤ f` with the same
integral over any measurable set. -/
theorem exists_measurable_le_setLintegral_eq_of_integrable {f : α → ℝ≥0∞} (hf : ∫⁻ a, f a ∂μ ≠ ∞) :
    ∃ (g : α → ℝ≥0∞), Measurable g ∧ g ≤ f ∧ ∀ s : Set α, MeasurableSet s →
      ∫⁻ a in s, f a ∂μ = ∫⁻ a in s, g a ∂μ

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

∃ g, Measurable g ∧ g ≤ f ∧ ∀ (s : Set α), MeasurableSet s → ∫⁻ (a : α) in s, f a ∂μ = ∫⁻ (a : α) in s, g a ∂μ


theorem image_update_Ioc (f : ∀ i, α i) (i : ι) (a b : α i) :
    update f i '' Ioc a b = Ioc (update f i a) (update f i b)

{ι : Type u_1}
{α : ι → Type u_2}
[DecidableEq ι]
[(i : ι) → PartialOrder (α i)]
(f : (i : ι) → α i)
(i : ι)
(a b : α i)

Function.update f i '' Set.Ioc a b = Set.Ioc (Function.update f i a) (Function.update f i b)


theorem normalize_finite_fraction_representation (U : Opens (PrimeSpectrum.Top R))
    (s : (structureSheaf R).1.obj (op U)) {ι : Type*} (t : Finset ι) (a h : ι → R)
    (iDh : ∀ i : ι, PrimeSpectrum.basicOpen (h i) ⟶ U)
    (h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i))
    (hs :
      ∀ i : ι,
        (const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) fun y hy => hy) =
          (structureSheaf R).1.map (iDh i).op s) :
    ∃ (a' h' : ι → R) (iDh' : ∀ i : ι, PrimeSpectrum.basicOpen (h' i) ⟶ U),
      (U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i)) ∧
        (∀ (i) (_ : i ∈ t) (j) (_ : j ∈ t), a' i * h' j = h' i * a' j) ∧
          ∀ i ∈ t,
            (structureSheaf R).1.map (iDh' i).op s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) fun y hy => hy

(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))

(s : ↑((AlgebraicGeometry.Spec.structureSheaf R).val.obj (Opposite.op U)))

(iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U)

(hs :
  ∀ (i : ι),
    AlgebraicGeometry.StructureSheaf.const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ =
      ((AlgebraicGeometry.Spec.structureSheaf R).val.map (iDh i).op) s)

∃ a' h' iDh',
  U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
    (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
      ∀ i ∈ t,
        ((AlgebraicGeometry.Spec.structureSheaf R).val.map (iDh' i).op) s =
          AlgebraicGeometry.StructureSheaf.const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


theorem AlgEquiv.restrictNormalHom_surjective [Normal F K₁] [Normal F E] :
    Function.Surjective (AlgEquiv.restrictNormalHom K₁ : (E ≃ₐ[F] E) → K₁ ≃ₐ[F] K₁)

{F : Type u_1}
{K₁ : Type u_3}
[Field F]
[Field K₁]
[Algebra F K₁]
(E : Type u_6)
[Field E]
[Algebra F E]
[Algebra K₁ E]
[IsScalarTower F K₁ E]
[Normal F K₁]
[Normal F E]


/-- If the `ChartedSpace` structure on a manifold `M` is given by an open embedding `e : M → H`,
then `e` is smooth. -/
lemma contMDiff_openEmbedding :
    haveI := h.singletonChartedSpace; ContMDiff I I n e

{𝕜 : 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]
[Nonempty M]
{e : M → H}
(h : OpenEmbedding e)
{n : WithTop ℕ}


theorem floor_eq_on_Ico' (n : ℕ) :
    ∀ a ∈ (Set.Ico n (n + 1) : Set α), (⌊a⌋₊ : α) = n

{α : Type u_2}
[LinearOrderedSemiring α]
[FloorSemiring α]
(n : ℕ)
(a : α)


@[simp]
theorem autToPow_spec (f : S ≃ₐ[R] S) : μ ^ (hμ.autToPow R f : ZMod n).val = f μ

(R : Type u_4)
{S : Type u_5}
[CommRing S]
[IsDomain S]
{μ : S}
{n : ℕ+}
(hμ : IsPrimitiveRoot μ ↑n)
[CommRing R]
[Algebra R S]
(f : S ≃ₐ[R] S)

μ ^ (↑((IsPrimitiveRoot.autToPow R hμ) f)).val = f μ


@[simp] theorem gcd_one {a : Int} : gcd a 1 = 1


theorem NeBot.comap_of_surj {f : Filter β} {m : α → β} (hf : NeBot f) (hm : Surjective m) :
    NeBot (comap m f)

{α : Type u}
{β : Type v}
{f : Filter β}
{m : α → β}
(hf : f.NeBot)
(hm : Function.Surjective m)


@[simp]
theorem zero_posPart : (0 : JordanDecomposition α).posPart = 0

MeasureTheory.JordanDecomposition.posPart 0 = 0


/-- Given submodules `M ⊆ R` and `N ⊆ S = M⁻¹R`, with `f : R →+* S` the localization map, we have
`N ⁻¹ S = T = (f⁻¹ (N • f(M))) ⁻¹ R`. I.e., the localization of a localization is a localization.
-/
theorem localization_localization_isLocalization [IsLocalization N T] :
    IsLocalization (localizationLocalizationSubmodule M N) T

{R : Type u_1}
[CommSemiring R]
(M : Submonoid R)
{S : Type u_2}
[CommSemiring S]
[Algebra R S]
(N : Submonoid S)
(T : Type u_4)
[CommSemiring T]
[Algebra R T]
[Algebra S T]
[IsScalarTower R S T]
[IsLocalization M S]
[IsLocalization N T]

IsLocalization (IsLocalization.localizationLocalizationSubmodule M N) T


@[simp]
theorem sublistsLen_length : ∀ l : List α, sublistsLen l.length l = [l]


protected theorem Iff.rfl {a : Prop} : a ↔ a


/-- Two non-unital subrings are equal if they have the same elements. -/
@[ext]
theorem ext {S T : NonUnitalSubring R} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T

{R : Type u}
[NonUnitalNonAssocRing R]
{S T : NonUnitalSubring R}
(h : ∀ (x : R), x ∈ S ↔ x ∈ T)


@[simp]
theorem univ_filter_exists (f : α → β) [Fintype β] [DecidablePred fun y => ∃ x, f x = y]
    [DecidableEq β] : (Finset.univ.filter fun y => ∃ x, f x = y) = Finset.univ.image f

{α : Type u_1}
{β : Type u_2}
[Fintype α]
(f : α → β)
[Fintype β]
[DecidablePred fun y => ∃ x, f x = y]
[DecidableEq β]

Finset.filter (fun y => ∃ x, f x = y) Finset.univ = Finset.image f Finset.univ


@[simp]
theorem pos_iff {a : SignType} : 0 < a ↔ a = 1


theorem integrable_inv_one_add_sq : Integrable fun (x : ℝ) ↦ (1 + x ^ 2)⁻¹

MeasureTheory.Integrable (fun x => (1 + x ^ 2)⁻¹) MeasureTheory.volume


@[simp]
theorem CompositionAsSet.toComposition_boundaries (c : CompositionAsSet n) :
    c.toComposition.boundaries = c.boundaries


theorem _root_.Function.LeftInverse.rightInverse_of_card_le {f : α → β} {g : β → α}
    (hfg : LeftInverse f g) (hcard : card α ≤ card β) : RightInverse f g

(hcard : Fintype.card α ≤ Fintype.card β)


@[simp]
theorem binary_cofan_inr_toCocone (c : BinaryBicone P Q) : BinaryCofan.inr c.toCocone = c.inr

(c : CategoryTheory.Limits.BinaryBicone P Q)

CategoryTheory.Limits.BinaryCofan.inr c.toCocone = c.inr


theorem map_update_update [DecidableEq ι] {i j : ι} (hij : i ≠ j) (m : M) :
    f (Function.update (Function.update v i m) j m) = 0

{R : Type u_1}
[Semiring R]
{M : Type u_2}
[AddCommMonoid M]
[Module R M]
{N : Type u_3}
[AddCommMonoid N]
[Module R N]
{ι : Type u_7}
(f : M [⋀^ι]→ₗ[R] N)
(v : ι → M)
[DecidableEq ι]
{i j : ι}
(hij : i ≠ j)
(m : M)


@[to_additive]
theorem TopologicalGroup.ext_iff {G : Type*} [Group G] {t t' : TopologicalSpace G}
    (tg : @TopologicalGroup G t _) (tg' : @TopologicalGroup G t' _) :
    t = t' ↔ @nhds G t 1 = @nhds G t' 1

{G : Type u_1}
[AddGroup G]
{t t' : TopologicalSpace G}
(tg : TopologicalAddGroup G)
(tg' : TopologicalAddGroup G)


@[simp]
theorem range_exp_mul_I : (Set.range fun x : ℝ => exp (x * I)) = Metric.sphere 0 1

(Set.range fun x => Complex.exp (↑x * Complex.I)) = Metric.sphere 0 1


theorem ext_get {l₁ l₂ : List α} (hl : length l₁ = length l₂)
    (h : ∀ n h₁ h₂, get l₁ ⟨n, h₁⟩ = get l₂ ⟨n, h₂⟩) : l₁ = l₂

(h : ∀ (n : Nat) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁.get ⟨n, h₁⟩ = l₂.get ⟨n, h₂⟩)


@[to_additive]
theorem freeGroupCongr_trans {α β γ} (e : α ≃ β) (f : β ≃ γ) :
    (freeGroupCongr e).trans (freeGroupCongr f) = freeGroupCongr (e.trans f)

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

(FreeGroup.freeGroupCongr e).trans (FreeGroup.freeGroupCongr f) = FreeGroup.freeGroupCongr (e.trans f)


theorem jacobson_eq_maximalIdeal (I : Ideal R) (h : I ≠ ⊤) :
    I.jacobson = LocalRing.maximalIdeal R

{R : Type u_1}
[CommRing R]
[LocalRing R]
(I : Ideal R)
(h : I ≠ ⊤)


theorem Zlattice.module_finite [IsZlattice K L] : Module.Finite ℤ L

(K : Type u_1)
[NormedLinearOrderedField K]
[HasSolidNorm K]
[FloorRing K]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace K E]
[FiniteDimensional K E]
[ProperSpace E]
(L : AddSubgroup E)
[DiscreteTopology ↥L]
[IsZlattice K L]


lemma _root_.IsPrimitiveRoot.toInteger_cube_eq_one : hζ.toInteger ^ 3 = 1

{K : Type u_1}
[Field K]
{ζ : K}
(hζ : IsPrimitiveRoot ζ ↑3)


protected theorem integralClosure : integralClosure O R = ⊥

{R : Type u}
{Γ₀ : Type v}
[CommRing R]
[LinearOrderedCommGroupWithZero Γ₀]
{v : Valuation R Γ₀}
{O : Type w}
[CommRing O]
[Algebra O R]
(hv : v.Integers O)


/-- A strong monomorphism that is an epimorphism is an isomorphism. -/
theorem isIso_of_epi_of_strongMono (f : P ⟶ Q) [Epi f] [StrongMono f] : IsIso f

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{P Q : C}
(f : P ⟶ Q)
[CategoryTheory.Epi f]
[CategoryTheory.StrongMono f]


theorem comp_hasFDerivWithinAt_iff' {f : G → E} {s : Set G} {x : G} {f' : G →L[𝕜] F} :
    HasFDerivWithinAt (iso ∘ f) f' s x ↔
      HasFDerivWithinAt f ((iso.symm : F →L[𝕜] E).comp f') s 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 : G → E}
{s : Set G}
{x : G}
{f' : G →L[𝕜] F}

HasFDerivWithinAt (⇑iso ∘ f) f' s x ↔ HasFDerivWithinAt f ((↑iso.symm).comp f') s x


/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, which is
the inverse functor of the Dold-Kan equivalence when `C` is an abelian
category, or more generally a pseudoabelian category. -/
@[simps!]
def Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C

∀ {X_1 Y : SimplexCategoryᵒᵖ} (θ : X_1 ⟶ Y),
  (AlgebraicTopology.DoldKan.Γ₀.obj X).map θ = AlgebraicTopology.DoldKan.Γ₀.Obj.map X θ


@[to_additive]
theorem mulIndicator_comp_right {s : Set α} (f : β → α) {g : α → M} {x : β} :
    mulIndicator (f ⁻¹' s) (g ∘ f) x = mulIndicator s g (f x)

{α : Type u_1}
{β : Type u_2}
{M : Type u_4}
[One M]
{s : Set α}
(f : β → α)
{g : α → M}
{x : β}

(f ⁻¹' s).mulIndicator (g ∘ f) x = s.mulIndicator g (f x)


/-- The counit isomorphism upgrades to a monoidal isomorphism. -/
@[simps! hom inv]
def transportedMonoidalCounitIso (e : C ≌ D) :
    (fromTransported e).toLaxMonoidalFunctor ⊗⋙ (toTransported e).toLaxMonoidalFunctor ≅
      LaxMonoidalFunctor.id (Transported e)

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D)

(CategoryTheory.Monoidal.transportedMonoidalCounitIso e).inv =
  CategoryTheory.monoidalUnit (CategoryTheory.Monoidal.fromTransported e) e.symm.toAdjunction


theorem set_biUnion_option_toFinset (o : Option α) (f : α → Set β) :
    ⋃ x ∈ o.toFinset, f x = ⋃ x ∈ o, f x

{α : Type u_2}
{β : Type u_3}
(o : Option α)
(f : α → Set β)


lemma SupClosed.prod {t : Set β} (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ×ˢ t)

{α : Type u_2}
{β : Type u_3}
[SemilatticeSup α]
[SemilatticeSup β]
{s : Set α}
{t : Set β}
(hs : SupClosed s)
(ht : SupClosed t)


@[simp]
theorem top_ne_coe (x : ℝ) : (⊤ : EReal) ≠ x


theorem Pairwise.tail : ∀ {l : List α} (_p : Pairwise R l), Pairwise R l.tail

{α : Type u_1}
{R : α → α → Prop}
{l : List α}
(_p : List.Pairwise R l)


/-- A helper function used in defining the Čech adjunction. -/
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve)

[∀ (n : ℕ) (f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]

(X : CategoryTheory.SimplicialObject.Augmented C)

(G : CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F)

(CategoryTheory.SimplicialObject.cechNerveEquiv X F) G = CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G


theorem Commute.minimalPeriod_of_comp_eq_mul_of_coprime {g : α → α} (h : Commute f g)
    (hco : Coprime (minimalPeriod f x) (minimalPeriod g x)) :
    minimalPeriod (f ∘ g) x = minimalPeriod f x * minimalPeriod g x

(hco : (Function.minimalPeriod f x).Coprime (Function.minimalPeriod g x))

Function.minimalPeriod (f ∘ g) x = Function.minimalPeriod f x * Function.minimalPeriod g x


protected theorem zsmul : a ≡ b [PMOD p] → z • a ≡ z • b [PMOD z • p]

{α : Type u_1}
[AddCommGroup α]
{p a b : α}
{z : ℤ}


theorem zneg_bit1 (n : ZNum) : -n.bit1 = (-n).bitm1


theorem Subring.topologicalClosure_minimal (s : Subring α) {t : Subring α} (h : s ≤ t)
    (ht : IsClosed (t : Set α)) : s.topologicalClosure ≤ t

{α : Type u_1}
[TopologicalSpace α]
[Ring α]
[TopologicalRing α]
(s : Subring α)
{t : Subring α}
(h : s ≤ t)
(ht : IsClosed ↑t)


/-- In a T₀ space, each set has at most one generic point. -/
protected theorem eq [T0Space α] (h : IsGenericPoint x S) (h' : IsGenericPoint y S) : x = y

{α : Type u_1}
[TopologicalSpace α]
{x y : α}
{S : Set α}
[T0Space α]
(h : IsGenericPoint x S)
(h' : IsGenericPoint y S)


@[to_additive]
theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂

{α : Type u_2}
{β : Type u_3}
[VAdd α β]
{f : Filter α}
{g₁ g₂ : Filter β}

g₁ ≤ g₂ → f +ᵥ g₁ ≤ f +ᵥ g₂


theorem tendsto_intCast_atTop_iff [StrictOrderedRing R] [Archimedean R] {f : α → ℤ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop

{α : Type u_1}
{R : Type u_2}
[StrictOrderedRing R]
[Archimedean R]
{f : α → ℤ}
{l : Filter α}

Filter.Tendsto (fun n => ↑(f n)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop


@[simp]
theorem eval_singleton (a : α) : M.eval [a] = M.step M.start a

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


theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₗ⁅R,L⁆ N) → M ≃ N)

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


theorem zip_map (f : α → γ) (g : β → δ) :
    ∀ (l₁ : List α) (l₂ : List β), zip (l₁.map f) (l₂.map g) = (zip l₁ l₂).map (Prod.map f g)

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

(List.map f l₁).zip (List.map g l₂) = List.map (Prod.map f g) (l₁.zip l₂)


lemma uniformInducing_iff' {f : α → β} :
    UniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α

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

UniformInducing f ↔ UniformContinuous f ∧ Filter.comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α


@[simp]
theorem constantCoeff_smul {S : Type*} [Semiring S] [Module R S] (φ : PowerSeries S) (a : R) :
    constantCoeff S (a • φ) = a • constantCoeff S φ

{R : Type u_1}
[Semiring R]
{S : Type u_2}
[Semiring S]
[Module R S]
(φ : PowerSeries S)
(a : R)

(PowerSeries.constantCoeff S) (a • φ) = a • (PowerSeries.constantCoeff S) φ


@[simp] theorem beq_self_eq_true' [DecidableEq α] (a : α) : (a == a) = true


@[simp] theorem perm_nil {l₁ : List α} : l₁ ~ [] ↔ l₁ = []


@[to_additive]
lemma inf_div (a b c : α) : (a ⊓ b) / c = a / c ⊓ b / c

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


theorem sign_of_pos {r : ℝ} (hr : 0 < r) : sign r = 1


theorem Finset.prod {β : Type*} {p : α} (hp : Prime p) (s : Finset β) (f : β → α) :
    multiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, multiplicity p (f x)

{α : Type u_1}
[CancelCommMonoidWithZero α]
[DecidableRel fun x x_1 => x ∣ x_1]
{β : Type u_3}
{p : α}
(hp : Prime p)
(s : Finset β)
(f : β → α)


@[simp]
theorem out_empty_iff_eq_zero {o : Ordinal} : IsEmpty o.out.α ↔ o = 0


theorem abs_sub_round_eq_min (x : α) : |x - round x| = min (fract x) (1 - fract x)

{α : Type u_2}
[LinearOrderedRing α]
[FloorRing α]
(x : α)

|x - ↑(round x)| = min (Int.fract x) (1 - Int.fract x)


lemma Base.closure_eq (hB : M.Base B) : M.closure B = M.E

{α : Type u_2}
{M : Matroid α}
{B : Set α}
(hB : M.Base B)


@[simp]
theorem toHamming_neg [∀ i, Neg (β i)] {x : ∀ i, β i} : toHamming (-x) = -toHamming x

{ι : Type u_2}
{β : ι → Type u_3}
[(i : ι) → Neg (β i)]
{x : (i : ι) → β i}

Hamming.toHamming (-x) = -Hamming.toHamming x


/-- An encoding of terms as lists. -/
@[simps]
protected def encoding : Encoding (L.Term α)

(l : List (α ⊕ (i : ℕ) × L.Functions i))

FirstOrder.Language.Term.encoding.decode l =
  (do
      let a ← (FirstOrder.Language.Term.listDecode l).head?
      pure (some a)).join


theorem eval_unique (φ : R[X] →ₐ[R] A) (p) : φ p = eval₂ (algebraMap R A) (φ X) p

{R : Type u}
{A : Type z}
[CommSemiring R]
[Semiring A]
[Algebra R A]
(φ : R[X] →ₐ[R] A)
(p : R[X])

φ p = Polynomial.eval₂ (algebraMap R A) (φ Polynomial.X) p


theorem isInt_mul {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HMul.hMul → IsInt a a' → IsInt b b' → Int.mul a' b' = c → IsInt (a * b) c

{α : Type u_1}
[Ring α]
{f : α → α → α}
{a b : α}
{a' b' c : ℤ}

f = HMul.hMul →
  Mathlib.Meta.NormNum.IsInt a a' →
    Mathlib.Meta.NormNum.IsInt b b' → a'.mul b' = c → Mathlib.Meta.NormNum.IsInt (a * b) c


@[simp]
theorem of_eq_same (i : ι) (x : β i) : (of _ i x) i = x

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


theorem sl_bracket [Fintype n] (A B : sl n R) : ⁅A, B⁆.val = A.val * B.val - B.val * A.val

(A B : ↥(LieAlgebra.SpecialLinear.sl n R))


@[to_additive (attr := simp)]
theorem ofLex_mul [Mul α] (a b : Lex α) : ofLex (a * b) = ofLex a * ofLex b


protected theorem norm_sum_single (hp : 0 < p.toReal) (f : ∀ i, E i) (s : Finset α) :
    ‖∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal = ∑ i ∈ s, ‖f i‖ ^ p.toReal

{α : Type u_1}
{E : α → Type u_2}
{p : ℝ≥0∞}
[(i : α) → NormedAddCommGroup (E i)]
[DecidableEq α]
(hp : 0 < p.toReal)
(f : (i : α) → E i)
(s : Finset α)


@[simp]
lemma homologyMap'_smul :
    homologyMap' (a • φ) h₁ h₂ = a • homologyMap' φ h₁ h₂

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

CategoryTheory.ShortComplex.homologyMap' (a • φ) h₁ h₂ = a • CategoryTheory.ShortComplex.homologyMap' φ h₁ h₂


theorem Summable.smul_const (hf : Summable f) (a : M) : Summable fun z ↦ f z • a

{ι : Type u_5}
{R : Type u_7}
{M : Type u_9}
[Semiring R]
[TopologicalSpace R]
[TopologicalSpace M]
[AddCommMonoid M]
[Module R M]
[ContinuousSMul R M]
{f : ι → R}
(hf : Summable f)
(a : M)


/-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E

{A : Type u_2}
{B : Type u_3}
{E : Type u_6}
[AddMonoid A]
[AddMonoid B]
[AddCommGroup E]
[TopologicalSpace A]
[TopologicalSpace B]
[TopologicalSpace E]
[TopologicalAddGroup E]
(f : ContinuousAddMonoidHom A E)
(g : ContinuousAddMonoidHom B E)

∀ (a : A × B), (f.coprod g) a = (ContinuousAddMonoidHom.add E).toAddMonoidHom ((f.sum_map g).toAddMonoidHom a)


@[simp] theorem unopFunctor_comp_opFunctor_eq :
    Functor.comp unopFunctor opFunctor = Functor.id _

CategoryTheory.RelCat.unopFunctor.comp CategoryTheory.RelCat.opFunctor =
  CategoryTheory.Functor.id CategoryTheory.RelCatᵒᵖ


/-- The identification `- ⊗ mop X = mop (- ⊗ unmop X)` as a natural isomorphism. -/
@[simps!]
def MonoidalOpposite.tensorRightMopIso (X : C) :
    tensorRight (mop X) ≅ unmopFunctor C ⋙ tensorLeft X ⋙ mopFunctor C

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

∀ (X_1 : Cᴹᵒᵖ),
  ((CategoryTheory.MonoidalOpposite.tensorRightMopIso X).hom.app X_1).unmop =
    𝟙 (CategoryTheory.MonoidalCategory.tensorObj X X_1.unmop)


@[simp]
theorem inl_mem_disjSum : inl a ∈ s.disjSum t ↔ a ∈ s

{α : Type u_1}
{β : Type u_2}
{s : Multiset α}
{t : Multiset β}
{a : α}


@[simp]
theorem comp_id (f : α →o β) : comp f id = f

{α : Type u_2}
{β : Type u_3}
[Preorder α]
[Preorder β]
(f : α →o β)


theorem sup_lt_of_lt_sdiff_left (h : y < z \ x) (hxz : x ≤ z) : x ⊔ y < z

{α : Type u}
{x y z : α}
[GeneralizedBooleanAlgebra α]
(h : y < z \ x)
(hxz : x ≤ z)


theorem mem_add (T : Subspace K V) (v w : V) (hv : v ≠ 0) (hw : w ≠ 0) (hvw : v + w ≠ 0) :
    Projectivization.mk K v hv ∈ T →
      Projectivization.mk K w hw ∈ T → Projectivization.mk K (v + w) hvw ∈ T

{K : Type u_1}
{V : Type u_2}
[Field K]
[AddCommGroup V]
[Module K V]
(T : Projectivization.Subspace K V)
(v w : V)
(hv : v ≠ 0)
(hw : w ≠ 0)
(hvw : v + w ≠ 0)


theorem _root_.Batteries.RBNode.Ordered.zoom' {t : RBNode α} {path : Path α}
    (ht : t.Ordered cmp) (hp : path.Ordered cmp) (tp : t.All (path.RootOrdered cmp))
    (pz : path.Zoomed cut) (eq : t.zoom cut path = (t', path')) :
    t'.Ordered cmp ∧ path'.Ordered cmp ∧ t'.All (path'.RootOrdered cmp) ∧ path'.Zoomed cut

(hp : Batteries.RBNode.Path.Ordered cmp path)

(tp : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path) t)

(pz : Batteries.RBNode.Path.Zoomed cut path)

(eq : Batteries.RBNode.zoom cut t path = (t', path'))

Batteries.RBNode.Ordered cmp t' ∧
  Batteries.RBNode.Path.Ordered cmp path' ∧
    Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path') t' ∧ Batteries.RBNode.Path.Zoomed cut path'


@[to_additive]
protected lemma IsOfFinOrder.orderOf_pos (h : IsOfFinOrder x) : 0 < orderOf x

{G : Type u_1}
[Monoid G]
{x : G}
(h : IsOfFinOrder x)


theorem mono_blimsup' (h : ∀ᶠ x in f, p x → u x ≤ v x) : blimsup u f p ≤ blimsup v f p

{α : Type u_1}
{β : Type u_2}
[CompleteLattice α]
{f : Filter β}
{p : β → Prop}
{u v : β → α}
(h : ∀ᶠ (x : β) in f, p x → u x ≤ v x)

Filter.blimsup u f p ≤ Filter.blimsup v f p


@[simp]
theorem sqrt_ofNat (n : ℕ) : Int.sqrt (no_index (OfNat.ofNat n) : ℤ) = Nat.sqrt (OfNat.ofNat n)

Int.sqrt (OfNat.ofNat n) = ↑(Nat.sqrt (OfNat.ofNat n))


theorem not_iff_not : ∀ {b : Bool}, !b ↔ ¬b


@[simp]
theorem ne_iff_lt_iff_le [PartialOrder α] {a b : α} : (a ≠ b ↔ a < b) ↔ a ≤ b

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


@[to_additive]
theorem MeasurePreserving.zpow [CompactSpace G] [RootableBy G ℤ]
    {n : ℤ} (hn : n ≠ 0) {X : Type*}
    [MeasurableSpace X] {μ' : Measure X} {f : X → G} (hf : MeasurePreserving f μ' μ) :
    MeasurePreserving (fun x => f x ^ n) μ' μ

(hf : MeasureTheory.MeasurePreserving f μ' μ)

MeasureTheory.MeasurePreserving (fun x => f x ^ n) μ' μ


theorem rec_prim' {α σ} [Primcodable α] [Primcodable σ] {c : α → Code} (hc : Primrec c) {z : α → σ}
    (hz : Primrec z) {s : α → σ} (hs : Primrec s) {l : α → σ} (hl : Primrec l) {r : α → σ}
    (hr : Primrec r) {pr : α → Code × Code × σ × σ → σ} (hpr : Primrec₂ pr)
    {co : α → Code × Code × σ × σ → σ} (hco : Primrec₂ co) {pc : α → Code × Code × σ × σ → σ}
    (hpc : Primrec₂ pc) {rf : α → Code × σ → σ} (hrf : Primrec₂ rf) :
    let PR (a) cf cg hf hg := pr a (cf, cg, hf, hg)
    let CO (a) cf cg hf hg := co a (cf, cg, hf, hg)
    let PC (a) cf cg hf hg := pc a (cf, cg, hf, hg)
    let RF (a) cf hf := rf a (cf, hf)
    let F (a : α) (c : Code) : σ :=
      Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a)
    Primrec (fun a => F a (c a) : α → σ)

{pr : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ}

{co : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ}

{pc : α → Nat.Partrec.Code × Nat.Partrec.Code × σ × σ → σ}

let PR := fun a cf cg hf hg => pr a (cf, cg, hf, hg);
let CO := fun a cf cg hf hg => co a (cf, cg, hf, hg);
let PC := fun a cf cg hf hg => pc a (cf, cg, hf, hg);
let RF := fun a cf hf => rf a (cf, hf);
let F := fun a c => Nat.Partrec.Code.recOn c (z a) (s a) (l a) (r a) (PR a) (CO a) (PC a) (RF a);
Primrec fun a => F a (c a)


@[to_additive (attr := simp)]
theorem bot_smul : (⊥ : Filter α) • g = ⊥

{α : Type u_2}
{β : Type u_3}
[VAdd α β]
{g : Filter β}


theorem pow_two_sub_pow (hyx : y < x) (hxy : 2 ∣ x - y) (hx : ¬2 ∣ x) {n : ℕ} (hn : n ≠ 0)
    (hneven : Even n) :
    padicValNat 2 (x ^ n - y ^ n) + 1 =
      padicValNat 2 (x + y) + padicValNat 2 (x - y) + padicValNat 2 n

{x y : ℕ}
(hyx : y < x)
(hxy : 2 ∣ x - y)
(hx : ¬2 ∣ x)
{n : ℕ}
(hn : n ≠ 0)
(hneven : Even n)


/-- Let `F` be a semi-`NormedSpace` over a `NontriviallyNormedField`, and let `q` be a
seminorm on `F`. If `q` is continuous, then it is uniformly controlled by the norm, that is there
is some `C > 0` such that `∀ x, q x ≤ C * ‖x‖`.
The continuity ensures boundedness on a ball of some radius `ε`. The nontriviality of the
norm is then used to rescale any element into an element of norm in `[ε/C, ε[`, thus with a
controlled image by `q`. The control of `q` at the original element follows by rescaling. -/
lemma bound_of_continuous_normedSpace (q : Seminorm 𝕜 F)
    (hq : Continuous q) : ∃ C, 0 < C ∧ (∀ x : F, q x ≤ C * ‖x‖)

{𝕜 : Type u_1}
{F : Type u_6}
[NontriviallyNormedField 𝕜]
[SeminormedAddCommGroup F]
[NormedSpace 𝕜 F]
(q : Seminorm 𝕜 F)
(hq : Continuous ⇑q)


/-- (Implementation) The object part of the compactification functor from topological spaces to
compact Hausdorff spaces.
-/
@[simps!]
def stoneCechObj (X : TopCat) : CompHaus


@[simp]
lemma whiskerLeftIso_refl (W X : C) :
    whiskerLeftIso W (Iso.refl X) = Iso.refl (W ⊗ X)

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

CategoryTheory.MonoidalCategory.whiskerLeftIso W (CategoryTheory.Iso.refl X) =
  CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategory.tensorObj W X)


theorem lhopital_zero_left_on_Ioc (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)
    (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hcf : ContinuousOn f (Ioc a b))
    (hcg : ContinuousOn g (Ioc a b)) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0) (hfb : f b = 0) (hgb : g b = 0)
    (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] b) l) :
    Tendsto (fun x => f x / g x) (𝓝[<] b) l

(hff' : ∀ x ∈ Set.Ioo a b, HasDerivAt f (f' x) x)

(hgg' : ∀ x ∈ Set.Ioo a b, HasDerivAt g (g' x) x)

(hdiv : Filter.Tendsto (fun x => f' x / g' x) (𝓝[<] b) l)

Filter.Tendsto (fun x => f x / g x) (𝓝[<] b) l


theorem Ico_filter_le_of_right_le {a b : α} [DecidablePred (b ≤ ·)] :
    (Ico a b).filter (b ≤ ·) = ∅

{α : Type u_2}
[Preorder α]
[LocallyFiniteOrder α]
{a b : α}
[DecidablePred fun x => b ≤ x]

Finset.filter (fun x => b ≤ x) (Finset.Ico a b) = ∅


/-- If `b` is odd, then `J(-a | b) = χ₄ b * J(a | b)`. -/
protected theorem neg (a : ℤ) {b : ℕ} (hb : Odd b) : J(-a | b) = χ₄ b * J(a | b)

jacobiSym (-a) b = ZMod.χ₄ ↑b * jacobiSym a b


theorem measure_mul_setLaverage (f : α → ℝ≥0∞) (h : μ s ≠ ∞) :
    μ s * ⨍⁻ x in s, f x ∂μ = ∫⁻ x in s, f x ∂μ

{α : Type u_1}
{m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{s : Set α}
(f : α → ℝ≥0∞)
(h : μ s ≠ ⊤)

μ s * ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, f x ∂μ


lemma densityProcess_fst_univ [IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ) :
    densityProcess κ (fst κ) n a x univ
      = if fst κ a (countablePartitionSet n x) = 0 then 0 else 1

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

κ.densityProcess κ.fst n a x Set.univ = if (κ.fst a) (MeasurableSpace.countablePartitionSet n x) = 0 then 0 else 1


theorem domRestrict (H : B.IsSymm) (p : Submodule R M) : (B.domRestrict₁₂ p p).IsSymm

{R : Type u_1}
{M : Type u_5}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
{I : R →+* R}
{B : M →ₛₗ[I] M →ₗ[R] R}
(H : B.IsSymm)
(p : Submodule R M)


@[to_additive]
theorem elim_mul_mul [Mul γ] : Sum.elim (a * a') (b * b') = Sum.elim a b * Sum.elim a' b'

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(a a' : α → γ)
(b b' : β → γ)
[Add γ]

Sum.elim (a + a') (b + b') = Sum.elim a b + Sum.elim a' b'


theorem im_sq_le_normSq (z : ℂ) : z.im * z.im ≤ normSq z


theorem QInfty_f (n : ℕ) : (QInfty.f n : X _[n] ⟶ X _[n]) = (Q n).f n

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

AlgebraicTopology.DoldKan.QInfty.f n = (AlgebraicTopology.DoldKan.Q n).f n


/-- The orthogonal projection onto `Kᗮ` of an element of `K` is zero. -/
theorem orthogonalProjection_mem_subspace_orthogonal_precomplement_eq_zero
    [HasOrthogonalProjection Kᗮ] {v : E} (hv : v ∈ K) : orthogonalProjection Kᗮ v = 0

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E}
[HasOrthogonalProjection Kᗮ]
{v : E}
(hv : v ∈ K)


theorem contDiff_cosh {n} : ContDiff ℝ n cosh


/-- The quotient map by a group action is open, i.e. the quotient by a group action is an open
  quotient. -/
@[to_additive "The quotient map by a group action is open, i.e. the quotient by a group
action is an open quotient. "]
theorem isOpenMap_quotient_mk'_mul [ContinuousConstSMul Γ T] :
    letI := MulAction.orbitRel Γ T
    IsOpenMap (Quotient.mk' : T → Quotient (MulAction.orbitRel Γ T))

{Γ : Type u_4}
[AddGroup Γ]
{T : Type u_5}
[TopologicalSpace T]
[AddAction Γ T]
[ContinuousConstVAdd Γ T]


@[simp] theorem derivative_inv {R} [CommRing R] (f : R⟦X⟧ˣ) :
    d⁄dX R ↑f⁻¹ = -(↑f⁻¹ : R⟦X⟧) ^ 2 * d⁄dX R f

{R : Type u_1}
[CommRing R]
(f : (PowerSeries R)ˣ)

(PowerSeries.derivative R) ↑f⁻¹ = -↑f⁻¹ ^ 2 * (PowerSeries.derivative R) ↑f


@[simp]
theorem ker_comp (l : M →ₛₗ[σ₁₂] M₂) :
    LinearMap.ker (((e'' : M₂ →ₛₗ[σ₂₃] M₃).comp l : M →ₛₗ[σ₁₃] M₃) : M →ₛₗ[σ₁₃] M₃) =
    LinearMap.ker l

{R : Type u_1}
{R₂ : Type u_3}
{R₃ : Type u_4}
{M : Type u_6}
{M₂ : Type u_8}
{M₃ : Type u_9}
[Semiring R]
[Semiring R₂]
[Semiring R₃]
[AddCommMonoid M]
[AddCommMonoid M₂]
[AddCommMonoid M₃]
{module_M : Module R M}
{module_M₂ : Module R₂ M₂}
{module_M₃ : Module R₃ M₃}
{σ₁₂ : R →+* R₂}
{σ₂₃ : R₂ →+* R₃}
{σ₁₃ : R →+* R₃}
[RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
{σ₃₂ : R₃ →+* R₂}
{re₂₃ : RingHomInvPair σ₂₃ σ₃₂}
{re₃₂ : RingHomInvPair σ₃₂ σ₂₃}
(e'' : M₂ ≃ₛₗ[σ₂₃] M₃)
(l : M →ₛₗ[σ₁₂] M₂)

LinearMap.ker ((↑e'').comp l) = LinearMap.ker l


theorem symm_bijective :
    Function.Bijective (ComplexShape.symm : ComplexShape ι → ComplexShape ι)


@[continuity, fun_prop]
theorem continuous_isLeft : Continuous (isLeft : X ⊕ Y → Bool)

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


theorem natAbs_dvd_self {a : Int} : (a.natAbs : Int) ∣ a


/-- The triangle `Z₁₂ ⟶ Z₁₃ ⟶ Z₂₃ ⟶ Z₁₂⟦1⟧` given by an octahedron. -/
@[simps!]
def triangle : Triangle C

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

{comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃}

{v₁₂ : X₂ ⟶ Z₁₂}

{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}

{h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}

{v₂₃ : X₃ ⟶ Z₂₃}

{w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂}

{h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}

{v₁₃ : X₃ ⟶ Z₁₃}

{w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}

{h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}

(h : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃)


@[simp]
theorem mapLe_isTrail {G G' : SimpleGraph V} (h : G ≤ G') {u v : V} {p : G.Walk u v} :
    (p.mapLe h).IsTrail ↔ p.IsTrail

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

(SimpleGraph.Walk.mapLe h p).IsTrail ↔ p.IsTrail


/-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.up : C ⥤ AsSmall C

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

(CategoryTheory.AsSmall.up.obj X).down = X


@[to_additive (attr := elab_as_elim, induction_eliminator)]
protected theorem induction_on {C : AssocQuotient α → Prop} (x : AssocQuotient α)
    (ih : ∀ x, C (of x)) : C x

{C : AddMagma.FreeAddSemigroup α → Prop}

(ih : ∀ (x : α), C (AddMagma.FreeAddSemigroup.of x))


theorem lt_top_of_sum_ne_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∑ x ∈ s, f x ≠ ∞) {a : α}
    (ha : a ∈ s) : f a < ∞

{α : Type u_1}
{s : Finset α}
{f : α → ℝ≥0∞}
(h : ∑ x ∈ s, f x ≠ ⊤)
{a : α}
(ha : a ∈ s)


theorem Nondegenerate.ne_zero [Nontrivial M] {B : BilinForm R M} (h : B.Nondegenerate) : B ≠ 0

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
[Nontrivial M]
{B : LinearMap.BilinForm R M}
(h : B.Nondegenerate)


/-- A component of a transposed form of the conjugation definition. -/
theorem conjugateEquiv_counit (α : L₂ ⟶ L₁) (d : D) :
    L₂.map ((conjugateEquiv adj₁ adj₂ α).app _) ≫ adj₂.counit.app d =
      α.app _ ≫ adj₁.counit.app d

{C : Type u₁}
{D : Type u₂}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Category.{v₂, u₂} D]
{L₁ L₂ : CategoryTheory.Functor C D}
{R₁ R₂ : CategoryTheory.Functor D C}
(adj₁ : L₁ ⊣ R₁)
(adj₂ : L₂ ⊣ R₂)
(α : L₂ ⟶ L₁)
(d : D)

CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.conjugateEquiv adj₁ adj₂) α).app d)) (adj₂.counit.app d) =
  CategoryTheory.CategoryStruct.comp (α.app (R₁.obj d)) (adj₁.counit.app d)


@[to_additive] lemma mulEnergy_comm (s t : Finset α) : Eₘ[s, t] = Eₘ[t, s]

{α : Type u_1}
[DecidableEq α]
[CommMonoid α]
(s t : Finset α)


theorem norm_compContinuous_le [TopologicalSpace γ] (f : α →ᵇ β) (g : C(γ, α)) :
    ‖f.compContinuous g‖ ≤ ‖f‖

{α : Type u}
{β : Type v}
{γ : Type w}
[TopologicalSpace α]
[SeminormedAddCommGroup β]
[TopologicalSpace γ]
(f : BoundedContinuousFunction α β)
(g : C(γ, α))


private theorem eval_soln : F.eval soln = 0

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


theorem inf_le_of_mem_convexHull {s : Finset E} (hf : ConcaveOn 𝕜 (convexHull 𝕜 (s : Set E)) f)
    (hx : x ∈ convexHull 𝕜 (s : Set E)) :
    s.inf' (coe_nonempty.1 <| convexHull_nonempty_iff.1 ⟨x, hx⟩) f ≤ f x

(hf : ConcaveOn 𝕜 ((convexHull 𝕜) ↑s) f)


theorem foldr_const (f : β → β) (b : β) : ∀ l : List α, l.foldr (fun _ ↦ f) b = f^[l.length] b

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

List.foldr (fun x => f) b l = f^[l.length] b


theorem bounded_ge_Icc [Preorder α] (a b : α) : Bounded (· ≥ ·) (Icc a b)

Set.Bounded (fun x x_1 => x ≥ x_1) (Set.Icc a b)


theorem mem_range' : ∀{n}, m ∈ range' s n step ↔ ∃ i < n, m = s + step * i

m ∈ List.range' s n step ↔ ∃ i, i < n ∧ m = s + step * i


@[simp]
theorem prod_self_lt_prod_self : s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂

{α : Type u_1}
[Preorder α]
{s₁ s₂ : UpperSet α}

s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂


@[simp]
theorem coeFn_star (f : lp E p) : ⇑(star f) = star (⇑f)

{α : Type u_1}
{E : α → Type u_2}
{p : ℝ≥0∞}
[(i : α) → NormedAddCommGroup (E i)]
[(i : α) → StarAddMonoid (E i)]
[∀ (i : α), NormedStarGroup (E i)]
(f : ↥(lp E p))


protected theorem div_mul_cancel (h0 : a ≠ 0) (hI : a ≠ ∞) : b / a * a = b

{a b : ENNReal}
(h0 : a ≠ 0)
(hI : a ≠ ⊤)


@[simp]
theorem cons_ne_zero {a : α} {m : Multiset α} : a ::ₘ m ≠ 0


@[simp]
theorem tan_pi_div_two : tan (π / 2) = 0


/-- The operator norm satisfies the triangle inequality. -/
theorem opNorm_add_le : ‖f + g‖ ≤ ‖f‖ + ‖g‖

[(i : ι) → SeminormedAddCommGroup (E i)]

‖f + g‖ ≤ ‖f‖ + ‖g‖


theorem nodup_of_separable_prod [Nontrivial R] {s : Multiset R}
    (hs : Separable (Multiset.map (fun a => X - C a) s).prod) : s.Nodup

(hs : (Multiset.map (fun a => Polynomial.X - Polynomial.C a) s).prod.Separable)


theorem mem_upperCentralSeriesStep (x : G) :
    x ∈ upperCentralSeriesStep H ↔ ∀ y, x * y * x⁻¹ * y⁻¹ ∈ H

{G : Type u_1}
[Group G]
(H : Subgroup G)
[H.Normal]
(x : G)

x ∈ upperCentralSeriesStep H ↔ ∀ (y : G), x * y * x⁻¹ * y⁻¹ ∈ H


/-- `A.nonunits` agrees with the maximal ideal of `A`, after taking its image in `K`. -/
theorem image_maximalIdeal : ((↑) : A → K) '' LocalRing.maximalIdeal A = A.nonunits

{K : Type u}
[Field K]
{A : ValuationSubring K}

Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) = ↑A.nonunits


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

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


/-- Measurable equivalence between (dependent) functions on a type and pairs of functions on
`{i // p i}` and `{i // ¬p i}`. See also `Equiv.piEquivPiSubtypeProd`. -/
@[simps! (config := .asFn)]
def piEquivPiSubtypeProd (p : δ' → Prop) [DecidablePred p] :
    (∀ i, π i) ≃ᵐ (∀ i : Subtype p, π i) × ∀ i : { i // ¬p i }, π i

{δ' : Type u_5}
(π : δ' → Type u_6)
[(x : δ') → MeasurableSpace (π x)]
(p : δ' → Prop)
[DecidablePred p]

⇑(MeasurableEquiv.piEquivPiSubtypeProd π p).symm = fun f x => if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩


/-- Given a monotone family `U` of complete submodules of `E` and a fixed `x : E`,
the orthogonal projection of `x` on `U i` tends to the orthogonal projection of `x` on
`(⨆ i, U i).topologicalClosure` along `atTop`. -/
theorem orthogonalProjection_tendsto_closure_iSup [CompleteSpace E] {ι : Type*} [SemilatticeSup ι]
    (U : ι → Submodule 𝕜 E) [∀ i, CompleteSpace (U i)] (hU : Monotone U) (x : E) :
    Filter.Tendsto (fun i => (orthogonalProjection (U i) x : E)) atTop
      (𝓝 (orthogonalProjection (⨆ i, U i).topologicalClosure x : E))

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
[CompleteSpace E]
{ι : Type u_4}
[SemilatticeSup ι]
(U : ι → Submodule 𝕜 E)
[∀ (i : ι), CompleteSpace ↥(U i)]
(hU : Monotone U)
(x : E)

Filter.Tendsto (fun i => ↑((orthogonalProjection (U i)) x)) Filter.atTop
  (𝓝 ↑((orthogonalProjection (⨆ i, U i).topologicalClosure) x))


@[simp]
theorem fold_insert_idem [DecidableEq α] [hi : Std.IdempotentOp op] :
    (insert a s).fold op b f = f a * s.fold op b f

{α : Type u_1}
{β : Type u_2}
{op : β → β → β}
[hc : Std.Commutative op]
[ha : Std.Associative op]
{f : α → β}
{b : β}
{s : Finset α}
{a : α}
[DecidableEq α]
[hi : Std.IdempotentOp op]

Finset.fold op b f (insert a s) = op (f a) (Finset.fold op b f s)


theorem eq_smul_self_of_isLocalExtrOn (hT : IsSelfAdjoint T) {x₀ : E}
    (hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere (0 : E) ‖x₀‖) x₀) :
    T x₀ = (↑(T.rayleighQuotient x₀) : 𝕜) • x₀

(hextr : IsLocalExtrOn T.reApplyInnerSelf (Metric.sphere 0 ‖x₀‖) x₀)


theorem HasFDerivAt.sin (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun x => Real.sin (f x)) (Real.cos (f x) • f') x

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{f : E → ℝ}
{f' : E →L[ℝ] ℝ}
{x : E}
(hf : HasFDerivAt f f' x)


theorem WCovBy.inf_eq (hca : c ⩿ a) (hcb : c ⩿ b) (hab : a ≠ b) : a ⊓ b = c

{α : Type u_1}
[SemilatticeInf α]
{a b c : α}
(hca : c ⩿ a)
(hcb : c ⩿ b)
(hab : a ≠ b)


@[to_additive (attr := simp, norm_cast)]
theorem coe_inf : (↑(U ⊓ V) : Set G) = (U : Set G) ∩ V

{G : Type u_1}
[AddGroup G]
[TopologicalSpace G]
{U V : OpenAddSubgroup G}


theorem of_div_nat (m : ℕ) (h : Irrational (x / m)) : Irrational x

{x : ℝ}
(m : ℕ)
(h : Irrational (x / ↑m))


/-- A primitive additive character on `ZMod n` takes the value `1` only at `0`. -/
theorem IsPrimitive.zmod_char_eq_one_iff (n : ℕ) [NeZero n]
    {ψ : AddChar (ZMod n) C} (hψ : IsPrimitive ψ) (a : ZMod n) :
    ψ a = 1 ↔ a = 0

{C : Type v}
[CommMonoid C]
(n : ℕ)
[NeZero n]
{ψ : AddChar (ZMod n) C}
(hψ : ψ.IsPrimitive)
(a : ZMod n)


theorem ceil_add_le (a b : α) : ⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉

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

⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉


theorem subtype_apply (x : p) : p.subtype x = x

{R : Type u}
{M : Type v}
[Semiring R]
[AddCommMonoid M]
{module_M : Module R M}
(p : Submodule R M)
(x : ↥p)


theorem objSupIsoProdEqLocus_hom_fst {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
    ((F.objSupIsoProdEqLocus U V).hom x).1.fst = F.1.map (homOfLE le_sup_left).op x

(x : ↑(F.val.obj (Opposite.op (U ⊔ V))))

(↑((F.objSupIsoProdEqLocus U V).hom x)).1 = (F.val.map (CategoryTheory.homOfLE ⋯).op) x


@[simp]
theorem valuationOfNeZero_eq (x : Kˣ) : (v.valuationOfNeZero x : ℤₘ₀) = v.valuation (x : K)

(v : IsDedekindDomain.HeightOneSpectrum R)

↑(v.valuationOfNeZero x) = v.valuation ↑x


theorem map_toSubmodule {S : NonUnitalSubalgebra R A} {f : F} :
    -- TODO: introduce a better coercion from `NonUnitalAlgHomClass` to `LinearMap`
    (map f S).toSubmodule = Submodule.map (LinearMapClass.linearMap f) S.toSubmodule

{F : Type v'}
{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[NonUnitalNonAssocSemiring B]
[Module R A]
[Module R B]
[FunLike F A B]
[NonUnitalAlgHomClass F R A B]
{S : NonUnitalSubalgebra R A}
{f : F}

(NonUnitalSubalgebra.map f S).toSubmodule = Submodule.map (LinearMapClass.linearMap f) S.toSubmodule


/-- `idealOfCofinals p 𝒟` is `𝒟`-generic. -/
theorem cofinal_meets_idealOfCofinals (i : ι) : ∃ x : P, x ∈ 𝒟 i ∧ x ∈ idealOfCofinals p 𝒟

{P : Type u_1}
[Preorder P]
(p : P)
{ι : Type u_2}
[Encodable ι]
(𝒟 : ι → Order.Cofinal P)
(i : ι)

∃ x ∈ 𝒟 i, x ∈ Order.idealOfCofinals p 𝒟


@[deprecated (since := "2024-07-25")]
theorem sizeOf_dropSlice_lt [SizeOf α] (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length) :
    SizeOf.sizeOf (List.dropSlice i j xs) < SizeOf.sizeOf xs

{α : Type u}
[SizeOf α]
(i j : ℕ)
(hj : 0 < j)
(xs : List α)
(hi : i < xs.length)

sizeOf (List.dropSlice i j xs) < sizeOf xs


@[to_additive (attr := simp)]
theorem prod_div_prod_filter [CommGroup G] (g : α → M → G) :
    f.prod g / (f.filter p).prod g = (f.filter fun a => ¬p a).prod g

{α : Type u_1}
{M : Type u_5}
{G : Type u_9}
[Zero M]
(p : α → Prop)
[DecidablePred p]
(f : α →₀ M)
[AddCommGroup G]
(g : α → M → G)

f.sum g - (Finsupp.filter p f).sum g = (Finsupp.filter (fun a => ¬p a) f).sum g


theorem mem_span_insert {y} :
    x ∈ span R (insert y s) ↔ ∃ a : R, ∃ z ∈ span R s, x = a • y + z

{R : Type u_1}
{M : Type u_4}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{x : M}
{s : Set M}
{y : M}

x ∈ Submodule.span R (insert y s) ↔ ∃ a, ∃ z ∈ Submodule.span R s, x = a • y + z


/-- `TopHomClass F α β` states that `F` is a type of `⊤`-preserving morphisms.

You should extend this class when you extend `TopHom`. -/
class TopHomClass (F α β : Type*) [Top α] [Top β] [FunLike F α β] : Prop where
  /-- A `TopHomClass` morphism preserves the top element. -/
  map_top (f : F) : f ⊤ = ⊤

{F : Type u_6}
{α : Type u_7}
{β : Type u_8}
[Top α]
[Top β]
[FunLike F α β]
[self : TopHomClass F α β]
(f : F)


@[to_additive addOrder_dvd_exponent]
theorem order_dvd_exponent (g : G) : orderOf g ∣ exponent G


@[to_additive (attr := simp, norm_cast)]
theorem coe_one [One β] : ⇑(1 : α →ₛ β) = 1

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[Zero β]


theorem valFromGraph_mem {g : Submodule R (E × F)}
    (hg : ∀ (x : E × F) (_hx : x ∈ g) (_hx' : x.fst = 0), x.snd = 0) {a : E}
    (ha : a ∈ g.map (LinearMap.fst R E F)) : (a, valFromGraph hg ha) ∈ g

(ha : a ∈ Submodule.map (LinearMap.fst R E F) g)


theorem continuous_iff_le_induced {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β} :
    Continuous[t₁, t₂] f ↔ t₁ ≤ induced f t₂

{α : Type u}
{β : Type v}
{f : α → β}
{t₁ : TopologicalSpace α}
{t₂ : TopologicalSpace β}

Continuous f ↔ t₁ ≤ TopologicalSpace.induced f t₂


@[simp]
theorem inf_singleton {a : α} : ({a} : Multiset α).inf = a

{α : Type u_1}
[SemilatticeInf α]
[OrderTop α]
{a : α}


@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_ι_inv {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G)
    (j : J) : colimit.ι G j ≫ (HasColimit.isoOfNatIso w).inv = w.inv.app j ≫ colimit.ι F j

{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u}
[CategoryTheory.Category.{v, u} C]
{F G : J ⥤ C}
[CategoryTheory.Limits.HasColimit F]
[CategoryTheory.Limits.HasColimit G]
(w : F ≅ G)
(j : J)

CategoryTheory.Limits.colimit.ι G j ≫ (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv =
  w.inv.app j ≫ CategoryTheory.Limits.colimit.ι F j


theorem SetLike.natCast_mem_graded [Zero ι] [AddMonoidWithOne R] [SetLike σ R]
    [AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedOne A] (n : ℕ) : (n : R) ∈ A 0

{ι : Type u_1}
{σ : Type u_2}
{R : Type u_4}
[Zero ι]
[AddMonoidWithOne R]
[SetLike σ R]
[AddSubmonoidClass σ R]
(A : ι → σ)
[SetLike.GradedOne A]
(n : ℕ)


@[simp]
theorem mul_annihilator (I : Ideal R) : I * annihilator I = ⊥

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


/-- The general adjoint functor theorem says that if `G : D ⥤ C` preserves limits and `D` has them,
if `G` satisfies the solution set condition then `G` is a right adjoint.
-/
lemma isRightAdjoint_of_preservesLimits_of_solutionSetCondition [HasLimits D]
    [PreservesLimits G] (hG : SolutionSetCondition G) : G.IsRightAdjoint

(hG : CategoryTheory.SolutionSetCondition G)


lemma div_left_inj' (hc : c ≠ 0) : a / c = b / c ↔ a = b

{G₀ : Type u_3}
[GroupWithZero G₀]
{a b c : G₀}
(hc : c ≠ 0)


@[reassoc (attr := simp)]
lemma whiskerRight_app_snd {F₁ F₁' : J ⥤ C} (f : F₁ ⟶ F₁') (F₂ : J ⥤ C) (j : J) :
    (f ▷ F₂).app j ≫ snd _ _ = snd _ _

{J : Type u_1}
{C : Type u_2}
[CategoryTheory.Category.{u_3, u_1} J]
[CategoryTheory.Category.{u_4, u_2} C]
[CategoryTheory.ChosenFiniteProducts C]
{F₁ F₁' : CategoryTheory.Functor J C}
(f : F₁ ⟶ F₁')
(F₂ : CategoryTheory.Functor J C)
(j : J)

CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.whiskerRight f F₂).app j)
    (CategoryTheory.ChosenFiniteProducts.snd (F₁'.obj j) (F₂.obj j)) =
  CategoryTheory.ChosenFiniteProducts.snd (F₁.obj j) (F₂.obj j)


theorem lookup_union_left_of_not_in {a} {s₁ s₂ : Finmap β} (h : a ∉ s₂) :
    lookup a (s₁ ∪ s₂) = lookup a s₁

{α : Type u}
{β : α → Type v}
[DecidableEq α]
{a : α}
{s₁ s₂ : Finmap β}
(h : a ∉ s₂)

Finmap.lookup a (s₁ ∪ s₂) = Finmap.lookup a s₁


/-- A homeomorphism is a cocompact map. -/
@[simps]
def Homeomorph.toCocompactMap {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    (f : α ≃ₜ β) : CocompactMap α β

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
(f : α ≃ₜ β)
(a : α)


theorem EventuallyEq.rw {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) (p : α → β → Prop)
    (hf : ∀ᶠ x in l, p x (f x)) : ∀ᶠ x in l, p x (g x)

{α : Type u}
{β : Type v}
{l : Filter α}
{f g : α → β}
(h : f =ᶠ[l] g)
(p : α → β → Prop)
(hf : ∀ᶠ (x : α) in l, p x (f x))


/-- If a property of maps of topological spaces is satisfied by homeomorphisms and is stable
under composition, the induced property on schemes respects isomorphisms. -/
lemma topologically_respectsIso
    (hP₁ : ∀ {α β : Type u} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β), P f)
    (hP₂ : ∀ {α β γ : Type u} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ]
      (f : α → β) (g : β → γ) (_ : P f) (_ : P g), P (g ∘ f)) :
      (topologically P).RespectsIso

(P : {α β : Type u} → [inst : TopologicalSpace α] → [inst : TopologicalSpace β] → (α → β) → Prop)

(hP₁ : ∀ {α β : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α ≃ₜ β), P ⇑f)

(hP₂ :
  ∀ {α β γ : Type u} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace γ] (f : α → β)
    (g : β → γ), P f → P g → P (g ∘ f))

(AlgebraicGeometry.topologically fun {α β} [TopologicalSpace α] [TopologicalSpace β] => P).RespectsIso


@[reassoc (attr := simp)]
theorem σ_naturality {X' X : SimplicialObject C} (f : X ⟶ X') {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ f.app (op [n + 1]) = f.app (op [n]) ≫ X'.σ i

{X' X : CategoryTheory.SimplicialObject C}

X.σ i ≫ f.app (Opposite.op (SimplexCategory.mk (n + 1))) = f.app (Opposite.op (SimplexCategory.mk n)) ≫ X'.σ i


/-- If `s` is a measurable set, a weakly regular measure `μ` is finite on `s`, and `ε` is a positive
number, then there exist a closed set `K ⊆ s` such that `μ s < μ K + ε`. -/
theorem _root_.MeasurableSet.exists_isClosed_lt_add [WeaklyRegular μ] {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ K, K ⊆ s ∧ IsClosed K ∧ μ s < μ K + ε

{α : Type u_1}
[MeasurableSpace α]
[TopologicalSpace α]
{μ : MeasureTheory.Measure α}
[μ.WeaklyRegular]
{s : Set α}
(hs : MeasurableSet s)
(hμs : μ s ≠ ⊤)
{ε : ℝ≥0∞}
(hε : ε ≠ 0)


theorem tendsto_pow_const_div_const_pow_of_one_lt (k : ℕ) {r : ℝ} (hr : 1 < r) :
    Tendsto (fun n ↦ (n : ℝ) ^ k / r ^ n : ℕ → ℝ) atTop (𝓝 0)

Filter.Tendsto (fun n => ↑n ^ k / r ^ n) Filter.atTop (𝓝 0)


theorem _root_.PrincipalSeg.ordinal_type_lt {α β} {r : α → α → Prop} {s : β → β → Prop}
    [IsWellOrder α r] [IsWellOrder β s] (h : r ≺i s) : type r < type s

{α β : Type u_3}
{r : α → α → Prop}
{s : β → β → Prop}
[IsWellOrder α r]
[IsWellOrder β s]
(h : r ≺i s)


theorem tendsto_pow_div_pow_atTop_zero [TopologicalSpace 𝕜] [OrderTopology 𝕜] {p q : ℕ}
    (hpq : p < q) : Tendsto (fun x : 𝕜 => x ^ p / x ^ q) atTop (𝓝 0)

{𝕜 : Type u_1}
[LinearOrderedField 𝕜]
[TopologicalSpace 𝕜]
[OrderTopology 𝕜]
{p q : ℕ}
(hpq : p < q)

Filter.Tendsto (fun x => x ^ p / x ^ q) Filter.atTop (𝓝 0)


theorem mul_mono_right (h : J ≤ K) : I * J ≤ I * K

{R : Type u}
[CommSemiring R]
{I J K : Ideal R}
(h : J ≤ K)


theorem and_congr_right_eq (h : a → b = c) : (a ∧ b) = (a ∧ c)


theorem isPerfectMatching_iff : M.IsPerfectMatching ↔ ∀ v, ∃! w, M.Adj v w

{V : Type u_1}
{G : SimpleGraph V}
{M : G.Subgraph}

M.IsPerfectMatching ↔ ∀ (v : V), ∃! w, M.Adj v w


theorem lintegral_rw₂ {f₁ f₁' : α → β} {f₂ f₂' : α → γ} (h₁ : f₁ =ᵐ[μ] f₁') (h₂ : f₂ =ᵐ[μ] f₂')
    (g : β → γ → ℝ≥0∞) : ∫⁻ a, g (f₁ a) (f₂ a) ∂μ = ∫⁻ a, g (f₁' a) (f₂' a) ∂μ

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f₁ f₁' : α → β}
{f₂ f₂' : α → γ}
(h₁ : f₁ =ᵐ[μ] f₁')
(h₂ : f₂ =ᵐ[μ] f₂')
(g : β → γ → ℝ≥0∞)

∫⁻ (a : α), g (f₁ a) (f₂ a) ∂μ = ∫⁻ (a : α), g (f₁' a) (f₂' a) ∂μ


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

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


theorem coeq₃_condition₂ {j₁ j₂ : C} (f g h : j₁ ⟶ j₂) :
    g ≫ coeq₃Hom f g h = h ≫ coeq₃Hom f g h

{C : Type u}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.IsFilteredOrEmpty C]
{j₁ j₂ : C}
(f g h : j₁ ⟶ j₂)

CategoryTheory.CategoryStruct.comp g (CategoryTheory.IsFiltered.coeq₃Hom f g h) =
  CategoryTheory.CategoryStruct.comp h (CategoryTheory.IsFiltered.coeq₃Hom f g h)


@[simp]
theorem trans_toRingEquiv_aux (f : α ≃+*o β) (g : β ≃+*o γ) :
    RingEquivClass.toRingEquiv (OrderRingIso.trans f g)
      = RingEquiv.trans f.toRingEquiv g.toRingEquiv

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[Mul α]
[Add α]
[LE α]
[Mul β]
[Add β]
[LE β]
[Mul γ]
[Add γ]
[LE γ]
(f : α ≃+*o β)
(g : β ≃+*o γ)


@[simp]
theorem PInfty_add_QInfty : (PInfty : K[X] ⟶ _) + QInfty = 𝟙 _

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
[CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C}

AlgebraicTopology.DoldKan.PInfty + AlgebraicTopology.DoldKan.QInfty = 𝟙 K[X]


/-- Scaling by a negative unit is negation. -/
theorem units_smul_of_neg (u : Rˣ) (hu : u.1 < 0) (v : Module.Ray R M) : u • v = -v

{R : Type u_1}
[StrictOrderedCommRing R]
{M : Type u_2}
[AddCommGroup M]
[Module R M]
(u : Rˣ)
(hu : ↑u < 0)
(v : Module.Ray R M)


@[to_additive]
theorem orbit_subgroup_one_eq_self : MulAction.orbit s (1 : α) = s

{α : Type u_1}
[Group α]
(s : Subgroup α)


/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤

{D : Type u_1}
[DivisionRing D]
[Finite D]
(hD : LittleWedderburn.InductionHyp D)


/-- A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side. -/
theorem norm_div_tan_angle_add_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) (h0 : x = 0 ∨ y ≠ 0) :
    ‖y‖ / Real.tan (angle x (x + y)) = ‖x‖

{V : Type u_1}
[NormedAddCommGroup V]
[InnerProductSpace ℝ V]
{x y : V}
(h : ⟪x, y⟫_ℝ = 0)
(h0 : x = 0 ∨ y ≠ 0)

‖y‖ / Real.tan (InnerProductGeometry.angle x (x + y)) = ‖x‖


theorem ContinuousOn.integrableOn_Icc [Preorder X] [CompactIccSpace X] [T2Space X]
    (hf : ContinuousOn f (Icc a b)) : IntegrableOn f (Icc a b) μ

MeasureTheory.IntegrableOn f (Set.Icc a b) μ


@[simp]
theorem center_eq_bot_of_subsingleton [Subsingleton n] :
    center (SpecialLinearGroup n R) = ⊥

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

Subgroup.center (Matrix.SpecialLinearGroup n R) = ⊥


@[to_additive add_nsmul]
lemma pow_add (a : M) (m : ℕ) : ∀ n, a ^ (m + n) = a ^ m * a ^ n

{M : Type u_2}
[AddMonoid M]
(a : M)
(m n : ℕ)


@[simp, deprecated get_singleton (since := "2023-01-05")]
theorem nthLe_singleton (a : α) {n : ℕ} (hn : n < 1) : nthLe [a] n hn = a


@[to_additive (attr := simp)]
theorem snd_comp_inr : (snd M N).comp (inr M N) = id N

{M : Type u_5}
{N : Type u_6}
[MulOneClass M]
[MulOneClass N]

(MonoidHom.snd M N).comp (MonoidHom.inr M N) = MonoidHom.id N


/-- The Radon-Nikodym derivative of the restriction of a measure to a measurable set is the
indicator function of this set. -/
theorem rnDeriv_restrict_self (ν : Measure α) [SigmaFinite ν] {s : Set α} (hs : MeasurableSet s) :
    (ν.restrict s).rnDeriv ν =ᵐ[ν] s.indicator 1

{α : Type u_1}
{m : MeasurableSpace α}
(ν : MeasureTheory.Measure α)
[MeasureTheory.SigmaFinite ν]
{s : Set α}
(hs : MeasurableSet s)


@[simp]
theorem mk_coe (e : R ≃+* S) (e' h₁ h₂ h₃ h₄) : (⟨⟨e, e', h₁, h₂⟩, h₃, h₄⟩ : R ≃+* S) = e

(h₃ :
  ∀ (x y : R),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun (x * y) =
      { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun x *
        { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun y)

(h₄ :
  ∀ (x y : R),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun (x + y) =
      { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun x +
        { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun y)

{ toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_mul' := h₃, map_add' := h₄ } = e


/-- A functor `F : T ⥤ D` induces a functor `Over X ⥤ Over (F.obj X)` in the obvious way. -/
@[simps]
def post (F : T ⥤ D) : Over X ⥤ Over (F.obj X)

{T : Type u₁}
[CategoryTheory.Category.{v₁, u₁} T]
{X : T}
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D)

∀ {X_1 Y : CategoryTheory.Over X} (f : X_1 ⟶ Y),
  (CategoryTheory.Over.post F).map f = CategoryTheory.Over.homMk (F.map f.left) ⋯


lemma Monotone.partBind (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x ↦ (f x).bind (g x)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[Preorder α]
{f : α → Part β}
{g : α → β → Part γ}
(hf : Monotone f)
(hg : Monotone g)


@[simp]
theorem edgeSet_univ_card : (univ : Finset G.edgeSet).card = G.edgeFinset.card

{V : Type u_1}
{G : SimpleGraph V}
[Fintype ↑G.edgeSet]


theorem ContMDiffWithinAt.of_succ {n : ℕ} (h : ContMDiffWithinAt I I' n.succ f s x) :
    ContMDiffWithinAt I I' n f s x

(h : ContMDiffWithinAt I I' (↑n.succ) f s x)


@[simp]
theorem map_inr : q.map (inr R M M₂) = prod ⊥ q

{R : Type u}
{M : Type v}
{M₂ : Type w}
[Semiring R]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R M₂]
(q : Submodule R M₂)

Submodule.map (LinearMap.inr R M M₂) q = ⊥.prod q


theorem mem_span_range_iff_exists_finsupp {v : α → M} {x : M} :
    x ∈ span R (range v) ↔ ∃ c : α →₀ R, (c.sum fun i a => a • v i) = x

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

x ∈ Submodule.span R (Set.range v) ↔ ∃ c, (c.sum fun i a => a • v i) = x


theorem map_toDual_min (s : Finset α) : s.min.map toDual = (s.image toDual).max

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

WithTop.map (⇑OrderDual.toDual) s.min = (Finset.image (⇑OrderDual.toDual) s).max


/-- `g : R →+* S` is `R`-linear when the module structure on `S` is `Module.compHom S g` . -/
@[simps]
def compHom.toLinearMap {R S : Type*} [Semiring R] [Semiring S] (g : R →+* S) :
    letI := compHom S g; R →ₗ[R] S

{R : Type u_17}
{S : Type u_18}
[Semiring R]
[Semiring S]
(g : R →+* S)
(a : R)


theorem IsCoreflexivePair.common_retraction (f g : A ⟶ B) [IsCoreflexivePair f g] :
    ∃ s : B ⟶ A, f ≫ s = 𝟙 A ∧ g ≫ s = 𝟙 A

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

∃ s,
  CategoryTheory.CategoryStruct.comp f s = CategoryTheory.CategoryStruct.id A ∧
    CategoryTheory.CategoryStruct.comp g s = CategoryTheory.CategoryStruct.id A


/--
This is a variant of `GlueData` that only requires conditions on `V (i, j)` when `i ≠ j`.
See `GlueData.ofGlueData'`
-/
structure GlueData' where
  /-- Indexing type of a glue data. -/
  J : Type v
  /-- Objects of a glue data to be glued. -/
  U : J → C
  /-- Objects representing the intersections. -/
  V : ∀ (i j : J), i ≠ j → C
  /-- The inclusion maps of the intersection into the object. -/
  f : ∀ i j h, V i j h ⟶ U i
  f_mono : ∀ i j h, Mono (f i j h) := by infer_instance
  f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
  /-- The transition maps between the intersections. -/
  t : ∀ i j h, V i j h ⟶ V j i h.symm
  /-- The transition maps between the intersection of intersections. -/
  t' : ∀ i j k hij hik hjk,
    pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
  t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ t i j hij
  t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
  cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
    t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _

{C : Type u₁}
[CategoryTheory.Category.{v, u₁} C]
(self : CategoryTheory.GlueData' C)
(i j : self.J)
(h : i ≠ j)


theorem integrable_iff {f : α →ₛ E} : Integrable f μ ↔ ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞

{α : Type u_1}
{E : Type u_4}
[MeasurableSpace α]
[NormedAddCommGroup E]
{μ : MeasureTheory.Measure α}
{f : MeasureTheory.SimpleFunc α E}

MeasureTheory.Integrable (↑f) μ ↔ ∀ (y : E), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤


theorem subset_of_mem_nhdsSet (h : t ∈ 𝓝ˢ s) : s ⊆ t

{X : Type u_1}
[TopologicalSpace X]
{s t : Set X}
(h : t ∈ 𝓝ˢ s)


theorem toLp_smul (f : α →ₛ E) (hf : Memℒp f p μ) (c : 𝕜) :
    toLp (c • f) (hf.const_smul c) = c • toLp f hf

{α : Type u_1}
{E : Type u_4}
{𝕜 : Type u_6}
[MeasurableSpace α]
[NormedAddCommGroup E]
{p : ℝ≥0∞}
{μ : MeasureTheory.Measure α}
[NormedRing 𝕜]
[Module 𝕜 E]
[BoundedSMul 𝕜 E]
(f : MeasureTheory.SimpleFunc α E)
(hf : MeasureTheory.Memℒp (↑f) p μ)
(c : 𝕜)

MeasureTheory.Lp.simpleFunc.toLp (c • f) ⋯ = c • MeasureTheory.Lp.simpleFunc.toLp f hf


@[simp]
theorem isSymm_one [DecidableEq n] [Zero α] [One α] : (1 : Matrix n n α).IsSymm

{α : Type u_1}
{n : Type u_3}
[DecidableEq n]
[Zero α]
[One α]


theorem compl_iSup : (iSup f)ᶜ = ⨅ i, (f i)ᶜ

{α : Type u}
{ι : Sort w}
[CompleteBooleanAlgebra α]
{f : ι → α}


protected theorem ediv_eq_of_eq_mul_left {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = c * b) : a / b = c


@[simp]
theorem coe_neg : ⇑(neg R : M ≃ₗ[R] M) = -id

{R : Type u_1}
{M : Type u_8}
[Semiring R]
[AddCommGroup M]
[Module R M]


theorem opensImagePreimageMap_app_assoc (i j k : D.J) (U : Opens (D.U i).carrier) {X' : C}
    (f' : _ ⟶ X') :
    D.opensImagePreimageMap i j U ≫ (D.f j k).c.app _ ≫ f' =
      ((π₁ j, i, k) ≫ D.t j i ≫ D.f i j).c.app (op U) ≫
        (π₂⁻¹ j, i, k) (unop _) ≫
          (D.V (j, k)).presheaf.map
            (eqToHom (opensImagePreimageMap_app' D i j k U).choose) ≫ f'

(D : AlgebraicGeometry.PresheafedSpace.GlueData C)

(f' :
  ((TopCat.Presheaf.pushforward C (D.f j k).base).obj (D.V (j, k)).presheaf).obj
      (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U))) ⟶
    X')

D.opensImagePreimageMap i j U ≫
    (D.f j k).c.app (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U))) ≫ f' =
  (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k) ≫ D.t j i ≫ D.f i j).c.app (Opposite.op U) ≫
    AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j k))
        (Opposite.unop
          (Opposite.op
            ((TopologicalSpace.Opens.map
                    (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k) ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1
              (Opposite.unop (Opposite.op U))))) ≫
      (D.V (j, k)).presheaf.map (CategoryTheory.eqToHom ⋯) ≫ f'


@[to_additive]
lemma BddBelow.range_inv {α : Type*} {f : α → G} (hf : BddBelow (range f)) :
    BddAbove (range (fun x => (f x)⁻¹))

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

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


theorem Chain'.cons' {x} : ∀ {l : List α}, Chain' R l → (∀ y ∈ l.head?, R x y) → Chain' R (x :: l)

{α : Type u}
{R : α → α → Prop}
{x : α}
{l : List α}

List.Chain' R l → (∀ (y : α), y ∈ l.head? → R x y) → List.Chain' R (x :: l)


theorem geom_sum₂_self {α : Type*} [CommRing α] (x : α) (n : ℕ) :
    ∑ i ∈ range n, x ^ i * x ^ (n - 1 - i) = n * x ^ (n - 1)

{α : Type u_1}
[CommRing α]
(x : α)
(n : ℕ)

∑ i ∈ Finset.range n, x ^ i * x ^ (n - 1 - i) = ↑n * x ^ (n - 1)


nonrec theorem singularPart_smul (s : SignedMeasure α) (μ : Measure α) (r : ℝ) :
    (r • s).singularPart μ = r • s.singularPart μ

{α : Type u_1}
{m : MeasurableSpace α}
(s : MeasureTheory.SignedMeasure α)
(μ : MeasureTheory.Measure α)
(r : ℝ)


theorem descPochhammer_smeval_eq_descFactorial (n k : ℕ) :
    (descPochhammer ℤ k).smeval (n : R) = n.descFactorial k

{R : Type u_1}
[NonAssocRing R]
[Pow R ℕ]
[NatPowAssoc R]
(n k : ℕ)

(descPochhammer ℤ k).smeval ↑n = ↑(n.descFactorial k)


theorem impl_length (d : {r : List δ // 0 < r.length}) (w : d.1.length = xs.length + 1) :
    (impl C xs y d).1.length = xs.length + 1

{α : Type u_1}
{β : Type u_2}
{δ : Type u_3}
[AddZeroClass δ]
[Min δ]
{C : Levenshtein.Cost α β δ}
(xs : List α)
(y : β)
(d : { r // 0 < r.length })
(w : d.val.length = xs.length + 1)

(Levenshtein.impl C xs y d).val.length = xs.length + 1


theorem fourierIntegral_continuousMultilinearMap_apply
    {f : V → (ContinuousMultilinearMap ℝ M E)} {m : (i : ι) → M i} {w : W} (he : Continuous e)
    (hf : Integrable f μ) :
    fourierIntegral e μ L.toLinearMap₂ f w m =
      fourierIntegral e μ L.toLinearMap₂ (fun x ↦ f x m) w

{f : V → ContinuousMultilinearMap ℝ M E}

(VectorFourier.fourierIntegral e μ L.toLinearMap₂ f w) m =
  VectorFourier.fourierIntegral e μ L.toLinearMap₂ (fun x => (f x) m) w


theorem closedBall_finset_sup_eq_iInter (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ}
    (hr : 0 ≤ r) : closedBall (s.sup p) x r = ⋂ i ∈ s, closedBall (p i) x r

{𝕜 : Type u_3}
{E : Type u_7}
{ι : Type u_12}
[SeminormedRing 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
(p : ι → Seminorm 𝕜 E)
(s : Finset ι)
(x : E)
{r : ℝ}
(hr : 0 ≤ r)

(s.sup p).closedBall x r = ⋂ i ∈ s, (p i).closedBall x r


theorem Prefunctor.costar_conj_star (u : U) :
    φ.costar u = Quiver.starEquivCostar (φ.obj u) ∘ φ.star u ∘ (Quiver.starEquivCostar u).symm

{U : Type u_1}
[Quiver U]
{V : Type u_2}
[Quiver V]
(φ : U ⥤q V)
[Quiver.HasInvolutiveReverse U]
[Quiver.HasInvolutiveReverse V]
[φ.MapReverse]
(u : U)

φ.costar u = ⇑(Quiver.starEquivCostar (φ.obj u)) ∘ φ.star u ∘ ⇑(Quiver.starEquivCostar u).symm


@[to_additive (attr := simp)]
theorem coe_of (R : Type u) [Mul R] : (MagmaCat.of R : Type u) = R


@[simp]
nonrec theorem prev_reverse_eq_next' (s : Cycle α) (hs : Nodup s.reverse) (x : α)
    (hx : x ∈ s.reverse) :
    s.reverse.prev hs x hx = s.next (nodup_reverse_iff.mp hs) x (mem_reverse_iff.mp hx)

{α : Type u_1}
[DecidableEq α]
(s : Cycle α)
(hs : s.reverse.Nodup)
(x : α)
(hx : x ∈ s.reverse)


theorem count_reducible (hp : ¬Irreducible p) : count p = 0

[(p : Associates α) → Decidable (Irreducible p)]


theorem Integrable.bdd_mul {F : Type*} [NormedDivisionRing F] {f g : α → F} (hint : Integrable g μ)
    (hm : AEStronglyMeasurable f μ) (hfbdd : ∃ C, ∀ x, ‖f x‖ ≤ C) :
    Integrable (fun x => f x * g x) μ

(hm : MeasureTheory.AEStronglyMeasurable f μ)

MeasureTheory.Integrable (fun x => f x * g x) μ


@[simp] theorem maximum?_replicate_of_pos [Max α] {n : Nat} {a : α} (w : max a a = a) (h : 0 < n) :
    (replicate n a).maximum? = some a

{α : Type u_1}
[Max α]
{n : Nat}
{a : α}
(w : max a a = a)
(h : 0 < n)


private theorem newton_seq_norm_eq (n : ℕ) :
    ‖newton_seq (n + 1) - newton_seq n‖ =
    ‖F.eval (newton_seq n)‖ / ‖F.derivative.eval (newton_seq n)‖

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

‖newton_seq_gen hnorm (n + 1) - newton_seq_gen hnorm n‖ =
  ‖Polynomial.eval (newton_seq_gen hnorm n) F‖ / ‖Polynomial.eval (newton_seq_gen hnorm n) (Polynomial.derivative F)‖


theorem ContDiffAt.sinh {n} (hf : ContDiffAt ℝ n f x) :
    ContDiffAt ℝ n (fun x => Real.sinh (f x)) x

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{f : E → ℝ}
{x : E}
{n : ℕ∞}
(hf : ContDiffAt ℝ n f x)


theorem isLittleO_log_rpow_nhds_zero {r : ℝ} (hr : r < 0) : log =o[𝓝[>] 0] fun x => x ^ r


lemma rpow_one_add' (hx : 0 ≤ x) (h : 1 + y ≠ 0) : x ^ (1 + y) = x * x ^ y


theorem of_not_lt_right [LinearOrder α] (h : ¬(a:α) < b) (eq : b = b') : b' ≤ a

{α : Type u_1}
{a b b' : α}
[LinearOrder α]
(h : ¬a < b)
(eq : b = b')


@[simp]
theorem ofDual_himp (a b : αᵒᵈ) : ofDual (a ⇨ b) = ofDual b \ ofDual a

{α : Type u_2}
[CoheytingAlgebra α]
(a b : αᵒᵈ)

OrderDual.ofDual (a ⇨ b) = OrderDual.ofDual b \ OrderDual.ofDual a


@[simp]
lemma homMk₄_app_one : (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 1 = app₁

{f g : CategoryTheory.ComposableArrows C 4}

(w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯))

(w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯))

(w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃ = CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 ⋯ ⋯))

(w₃ :
  CategoryTheory.CategoryStruct.comp (f.map' 3 4 ⋯ ⋯) app₄ = CategoryTheory.CategoryStruct.comp app₃ (g.map' 3 4 ⋯ ⋯))

(CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 1 = app₁


/-- The preimage of a sequentially closed set under a sequentially continuous map is sequentially
closed. -/
theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf : SeqContinuous f) :
    IsSeqClosed (f ⁻¹' s)

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


@[to_additive]
lemma mem_units_iff_val_mem (H : Subgroup G) (x : Gˣ) : x ∈ H.units ↔ (x : G) ∈ H

{G : Type u_2}
[AddGroup G]
(H : AddSubgroup G)
(x : AddUnits G)


theorem add_sub_cancel (x y : BitVec w) : x + y - y = x


/-- The forgetful braided functor from a full braided subcategory into the original category
("forgetting" the condition).
-/
@[simps!]
def fullBraidedSubcategoryInclusion : BraidedFunctor (FullSubcategory P) C

(self : CategoryTheory.FullSubcategory P)

(CategoryTheory.MonoidalCategory.fullBraidedSubcategoryInclusion P).obj self = self.obj


theorem Nontrivial.infsep_anti (hs : s.Nontrivial) (hst : s ⊆ t) : t.infsep ≤ s.infsep

{α : Type u_1}
[PseudoMetricSpace α]
{s t : Set α}
(hs : s.Nontrivial)
(hst : s ⊆ t)


theorem Restriction.strictRestriction_of_ne (h : N ≤r M) (hne : N ≠ M) : N <r M

{α : Type u_1}
{M N : Matroid α}
(h : N.Restriction M)
(hne : N ≠ M)


theorem Memℒp.eLpNorm_indicator_le (hp_one : 1 ≤ p) (hp_top : p ≠ ∞) (hf : Memℒp f p μ) {ε : ℝ}
    (hε : 0 < ε) :
    ∃ (δ : ℝ) (hδ : 0 < δ), ∀ s, MeasurableSet s → μ s ≤ ENNReal.ofReal δ →
      eLpNorm (s.indicator f) p μ ≤ ENNReal.ofReal ε

{α : Type u_1}
{β : Type u_2}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup β]
{p : ℝ≥0∞}
{f : α → β}
(hp_one : 1 ≤ p)
(hp_top : p ≠ ⊤)
(hf : MeasureTheory.Memℒp f p μ)
{ε : ℝ}
(hε : 0 < ε)

∃ δ,
  ∃ (_ : 0 < δ),
    ∀ (s : Set α),
      MeasurableSet s → μ s ≤ ENNReal.ofReal δ → MeasureTheory.eLpNorm (s.indicator f) p μ ≤ ENNReal.ofReal ε


theorem exists_coprime (m n : Nat) :
    ∃ m' n', Coprime m' n' ∧ m = m' * gcd m n ∧ n = n' * gcd m n

∃ m' n', m'.Coprime n' ∧ m = m' * m.gcd n ∧ n = n' * m.gcd n


theorem smul [NormedField 𝕜] [NormedSpace 𝕜 E] {f : ℝ → E} {a b : ℝ} {μ : Measure ℝ}
    (h : IntervalIntegrable f μ a b) (r : 𝕜) : IntervalIntegrable (r • f) μ a b

{𝕜 : Type u_2}
{E : Type u_3}
[NormedAddCommGroup E]
[NormedField 𝕜]
[NormedSpace 𝕜 E]
{f : ℝ → E}
{a b : ℝ}
{μ : MeasureTheory.Measure ℝ}
(h : IntervalIntegrable f μ a b)
(r : 𝕜)


@[simp]
theorem cancel_right {g₁ g₂ : β →CO γ} {f : α →CO β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
{g₁ g₂ : β →CO γ}
{f : α →CO β}
(hf : Function.Surjective ⇑f)