theorem tendsto_floor_right' (n : ℤ) : Tendsto (fun x => floor x : α → α) (𝓝[≥] n) (𝓝 n)

{α : Type u_1}
[LinearOrderedRing α]
[FloorRing α]
[TopologicalSpace α]
[OrderClosedTopology α]
(n : ℤ)

Filter.Tendsto (fun x => ↑⌊x⌋) (𝓝[≥] ↑n) (𝓝 ↑n)


/-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X

{G : Type v}
{X : Type w}
[PseudoEMetricSpace X]
[Group G]
[MulAction G X]
[IsometricSMul G X]
(c : G)

(IsometryEquiv.constSMul c).toEquiv = MulAction.toPerm c


theorem setLIntegral_dirac {a : α} (f : α → ℝ≥0∞) (s : Set α) [MeasurableSingletonClass α]
    [Decidable (a ∈ s)] : ∫⁻ x in s, f x ∂Measure.dirac a = if a ∈ s then f a else 0

{α : Type u_1}
[MeasurableSpace α]
{a : α}
(f : α → ℝ≥0∞)
(s : Set α)
[MeasurableSingletonClass α]
[Decidable (a ∈ s)]

∫⁻ (x : α) in s, f x ∂MeasureTheory.Measure.dirac a = if a ∈ s then f a else 0


/-- A product of types can be split as the binary product of one of the types and the product
  of all the remaining types. -/
@[simps]
def piSplitAt {α : Type*} [DecidableEq α] (i : α) (β : α → Type*) :
    (∀ j, β j) ≃ β i × ∀ j : { j // j ≠ i }, β j

{α : Type u_1}
[DecidableEq α]
(i : α)
(β : α → Type u_2)
(f : (j : α) → β j)

(Equiv.piSplitAt i β) f = (f i, fun j => f ↑j)


/-- Lebesgue integral against the composition-product of two kernels. -/
theorem lintegral_compProd₀ (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] (a : α) {f : β × γ → ℝ≥0∞} (hf : AEMeasurable f ((κ ⊗ₖ η) a)) :
    ∫⁻ z, f z ∂(κ ⊗ₖ η) a = ∫⁻ x, ∫⁻ y, f (x, y) ∂η (a, x) ∂κ a

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

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

(hf : AEMeasurable f ((κ.compProd η) a))

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


lemma isSheaf_coherent_of_hasPullbacks_comp [Preregular C] [FinitaryExtensive C]
    [h : ∀ {Y X : C} (f : Y ⟶ X) [EffectiveEpi f], HasPullback f f] [PreservesFiniteLimits s]
    (hF : IsSheaf (coherentTopology C) F) : IsSheaf (coherentTopology C) (F ⋙ s)

[h : ∀ {Y X : C} (f : Y ⟶ X) [inst : CategoryTheory.EffectiveEpi f], CategoryTheory.Limits.HasPullback f f]

(hF : CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F)

CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) (F.comp s)


theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X)

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{D : Type u'}
[CategoryTheory.Category.{v', u'} D]
[CategoryTheory.Limits.HasZeroObject D]
{F : C ⥤ D}
(hF : CategoryTheory.Limits.IsZero F)
(X : C)


theorem Disjoint.inf_right' (h : Disjoint a b) : Disjoint a (c ⊓ b)

{α : Type u_1}
[SemilatticeInf α]
[OrderBot α]
{a b : α}
(c : α)
(h : Disjoint a b)


theorem smul_Ico : r • Ico a b = Ico (r • a) (r • b)

{K : Type u_2}
[LinearOrderedField K]
{a b r : K}
(hr : 0 < r)

r • Set.Ico a b = Set.Ico (r • a) (r • b)


lemma exact₁ : (ShortComplex.mk _ _ (δ_comp T hT n₀ n₁ h)).Exact

(T : CategoryTheory.Pretriangulated.Triangle (DerivedCategory C))

(hT : T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)

(CategoryTheory.ShortComplex.mk (DerivedCategory.HomologySequence.δ T n₀ n₁ h)
    ((DerivedCategory.homologyFunctor C n₁).map T.mor₁) ⋯).Exact


/-- A version of `exists_ne_zero_mem_ideal_lt` for the ring of integers of `K`. -/
theorem exists_ne_zero_mem_ringOfIntegers_lt (h : minkowskiBound K ↑1 < volume (convexBodyLT K f)) :
    ∃ a : 𝓞 K, a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w

{f : NumberField.InfinitePlace K → NNReal}

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

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


theorem increment_isEquipartition : (increment hP G ε).IsEquipartition

{α : Type u_1}
[Fintype α]
[DecidableEq α]
{P : Finpartition Finset.univ}
(hP : P.IsEquipartition)
(G : SimpleGraph α)
[DecidableRel G.Adj]
(ε : ℝ)

(SzemerediRegularity.increment hP G ε).IsEquipartition


theorem nodup_iff_count_eq_one [DecidableEq α] : Nodup l ↔ ∀ a ∈ l, count a l = 1

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


theorem fourierCoeff_toLp (n : ℤ) :
    fourierCoeff (toLp (E := ℂ) 2 haarAddCircle ℂ f) n = fourierCoeff f n

{T : ℝ}
[hT : Fact (0 < T)]
(f : C(AddCircle T, ℂ))
(n : ℤ)

fourierCoeff (↑↑((ContinuousMap.toLp 2 AddCircle.haarAddCircle ℂ) f)) n = fourierCoeff (⇑f) n


/-- If a topology `t'` is coarser than `t`, then any set `s` that is bounded with respect to
`t` is bounded with respect to `t'`. -/
theorem IsVonNBounded.of_topologicalSpace_le {t t' : TopologicalSpace E} (h : t ≤ t') {s : Set E}
    (hs : @IsVonNBounded 𝕜 E _ _ _ t s) : @IsVonNBounded 𝕜 E _ _ _ t' s

{𝕜 : Type u_1}
{E : Type u_3}
[SeminormedRing 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
{t t' : TopologicalSpace E}
(h : t ≤ t')
{s : Set E}
(hs : Bornology.IsVonNBounded 𝕜 s)


@[simp]
theorem coe_prodEquivOfClosedCompl_symm (h : IsCompl p q) (hp : IsClosed (p : Set E))
    (hq : IsClosed (q : Set E)) :
    ⇑(p.prodEquivOfClosedCompl q h hp hq).symm = (p.prodEquivOfIsCompl q h).symm

{𝕜 : Type u_1}
{E : Type u_2}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[CompleteSpace E]
{p q : Subspace 𝕜 E}
(h : IsCompl p q)
(hp : IsClosed ↑p)
(hq : IsClosed ↑q)

⇑(Submodule.prodEquivOfClosedCompl p q h hp hq).symm = ⇑(Submodule.prodEquivOfIsCompl p q h).symm


theorem embedding_coeFn [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    Embedding (X := UniformConvergenceCLM σ F 𝔖) (Y := E →ᵤ[𝔖] F)
      (UniformOnFun.ofFun 𝔖 ∘ DFunLike.coe)

{𝕜₁ : Type u_1}
{𝕜₂ : Type u_2}
[NormedField 𝕜₁]
[NormedField 𝕜₂]
(σ : 𝕜₁ →+* 𝕜₂)
{E : Type u_3}
(F : Type u_4)
[AddCommGroup E]
[Module 𝕜₁ E]
[TopologicalSpace E]
[AddCommGroup F]
[Module 𝕜₂ F]
[UniformSpace F]
[UniformAddGroup F]
(𝔖 : Set (Set E))

Embedding (⇑(UniformOnFun.ofFun 𝔖) ∘ DFunLike.coe)


lemma cfc_neg : cfc (fun x ↦ - (f x)) a = - (cfc f a)

{R : Type u_1}
{A : Type u_2}
{p : A → Prop}
[CommRing R]
[StarRing R]
[MetricSpace R]
[TopologicalRing R]
[ContinuousStar R]
[TopologicalSpace A]
[Ring A]
[StarRing A]
[Algebra R A]
[ContinuousFunctionalCalculus R p]
(f : R → R)
(a : A)


@[simp]
theorem Ioc_union_Icc_eq_Ioc (h₁ : a < b) (h₂ : b ≤ c) : Ioc a b ∪ Icc b c = Ioc a c

{α : Type u_1}
[LinearOrder α]
{a b c : α}
(h₁ : a < b)
(h₂ : b ≤ c)


theorem mk_subtype_le_of_subset {α : Type u} {p q : α → Prop} (h : ∀ ⦃x⦄, p x → q x) :
    #(Subtype p) ≤ #(Subtype q)

{α : Type u}
{p q : α → Prop}
(h : ∀ ⦃x : α⦄, p x → q x)

Cardinal.mk (Subtype p) ≤ Cardinal.mk (Subtype q)


/-- If `s ⊂ t`, then `s < t` in the colex order. Note the converse does not hold, as inclusion does
not form a linear order. -/
lemma toColex_strictMono : StrictMono (toColex : Finset α → Colex α)


/-- Core data defining a locally trivial bundle with fiber `F` over a topological
space `B`. Note that "bundle" is used in its mathematical sense. This is the (computer science)
bundled version, i.e., all the relevant data is contained in the following structure. A family of
local trivializations is indexed by a type `ι`, on open subsets `baseSet i` for each `i : ι`.
Trivialization changes from `i` to `j` are given by continuous maps `coordChange i j` from
`baseSet i ∩ baseSet j` to the set of homeomorphisms of `F`, but we express them as maps
`B → F → F` and require continuity on `(baseSet i ∩ baseSet j) × F` to avoid the topology on the
space of continuous maps on `F`. -/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure FiberBundleCore (ι : Type*) (B : Type*) [TopologicalSpace B] (F : Type*)
    [TopologicalSpace F] where
  baseSet : ι → Set B
  isOpen_baseSet : ∀ i, IsOpen (baseSet i)
  indexAt : B → ι
  mem_baseSet_at : ∀ x, x ∈ baseSet (indexAt x)
  coordChange : ι → ι → B → F → F
  coordChange_self : ∀ i, ∀ x ∈ baseSet i, ∀ v, coordChange i i x v = v
  continuousOn_coordChange : ∀ i j,
    ContinuousOn (fun p : B × F => coordChange i j p.1 p.2) ((baseSet i ∩ baseSet j) ×ˢ univ)
  coordChange_comp : ∀ i j k, ∀ x ∈ baseSet i ∩ baseSet j ∩ baseSet k, ∀ v,
    (coordChange j k x) (coordChange i j x v) = coordChange i k x v

{ι : Type u_5}
{B : Type u_6}
[TopologicalSpace B]
{F : Type u_7}
[TopologicalSpace F]
(self : FiberBundleCore ι B F)
(x : B)


/-- The composition of `Quotient.mk'` and a function with dense range has dense range. -/
theorem DenseRange.quotient [Setoid X] [TopologicalSpace X] {f : Y → X} (hf : DenseRange f) :
    DenseRange (Quotient.mk' ∘ f)

{X : Type u}
{Y : Type v}
[Setoid X]
[TopologicalSpace X]
{f : Y → X}
(hf : DenseRange f)


@[simp, norm_cast]
theorem coe_sum {ι : Type*} (t : Finset ι) (f : ι → M₁ →SL[σ₁₂] M₂) :
    ↑(∑ d ∈ t, f d) = (∑ d ∈ t, f d : M₁ →ₛₗ[σ₁₂] M₂)

{R₁ : Type u_1}
{R₂ : Type u_2}
[Semiring R₁]
[Semiring R₂]
{σ₁₂ : R₁ →+* R₂}
{M₁ : Type u_4}
[TopologicalSpace M₁]
[AddCommMonoid M₁]
{M₂ : Type u_6}
[TopologicalSpace M₂]
[AddCommMonoid M₂]
[Module R₁ M₁]
[Module R₂ M₂]
[ContinuousAdd M₂]
{ι : Type u_9}
(t : Finset ι)
(f : ι → M₁ →SL[σ₁₂] M₂)


@[simp]
theorem baseChange_add : (f + g).baseChange A = f.baseChange A + g.baseChange A

{R : Type u_1}
{A : Type u_2}
{M : Type u_4}
{N : Type u_5}
[CommSemiring R]
[Semiring A]
[Algebra R A]
[AddCommMonoid M]
[AddCommMonoid N]
[Module R M]
[Module R N]
(f g : M →ₗ[R] N)

LinearMap.baseChange A (f + g) = LinearMap.baseChange A f + LinearMap.baseChange A g


theorem AddMonoidHom.mul_apply (x y : R) : AddMonoidHom.mul x y = x * y

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


theorem range_coe : range ofNNReal = {∞}ᶜ


@[simp]
theorem sup_mul_left_self : I ⊔ J * I = I

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


@[to_additive]
lemma IsCyclic.exists_ofOrder_eq_natCard [h : IsCyclic α] : ∃ g : α, orderOf g = Nat.card α


theorem mul_omega_opow_opow {a b : Ordinal} (a0 : 0 < a) (h : a < (omega^omega^b)) :
    a * (omega^omega^b) = (omega^omega^b)

(h : a < Ordinal.omega ^ Ordinal.omega ^ b)

a * Ordinal.omega ^ Ordinal.omega ^ b = Ordinal.omega ^ Ordinal.omega ^ b


theorem hasseDeriv_coeff (n : ℕ) :
    (hasseDeriv k f).coeff n = (n + k).choose k * f.coeff (n + k)

{R : Type u_1}
[Semiring R]
(k : ℕ)
(f : Polynomial R)
(n : ℕ)

((Polynomial.hasseDeriv k) f).coeff n = ↑((n + k).choose k) * f.coeff (n + k)


@[simp]
theorem range_inr_union_range_inl : range (Sum.inr : β → α ⊕ β) ∪ range Sum.inl = univ

Set.range Sum.inr ∪ Set.range Sum.inl = Set.univ


/-- A uniform limit on a set of functions which are continuous on this set is itself continuous
on this set. -/
protected theorem TendstoUniformlyOn.continuousOn (h : TendstoUniformlyOn F f p s)
    (hc : ∀ᶠ n in p, ContinuousOn (F n) s) [NeBot p] : ContinuousOn f s

{F : ι → α → β}

(hc : ∀ᶠ (n : ι) in p, ContinuousOn (F n) s)


theorem eq_zero_of_dvd_of_degree_lt {p q : R[X]} (h₁ : p ∣ q) (h₂ : degree q < degree p) :
    q = 0

{R : Type u}
[Semiring R]
[NoZeroDivisors R]
{p q : R[X]}
(h₁ : p ∣ q)
(h₂ : q.degree < p.degree)


@[simp]
theorem dvd_abs (a b : α) : a ∣ |b| ↔ a ∣ b

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


@[to_additive] -- Porting note: simp removed, simpNF says LHS simplifies to itself
theorem ofHom_apply {X Y : Type u} [Mul X] [Mul Y] (f : X →ₙ* Y) (x : X) : ofHom f x = f x

{X Y : Type u}
[Add X]
[Add Y]
(f : AddHom X Y)
(x : X)


theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b


theorem map_unop_pow (n : ℕ) (M : Submodule R Aᵐᵒᵖ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M ^ n) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M ^ n

{R : Type u}
[CommSemiring R]
{A : Type v}
[Semiring A]
[Algebra R A]
(n : ℕ)
(M : Submodule R Aᵐᵒᵖ)

Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) (M ^ n) = Submodule.map (↑(MulOpposite.opLinearEquiv R).symm) M ^ n


@[simp]
theorem coe_erase (l : List α) (a : α) : erase (l : Multiset α) a = l.erase a

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


@[to_additive]
theorem even_mul_odd {f : ℕ → M} (he : HasProd (fun k ↦ f (2 * k)) m)
    (ho : HasProd (fun k ↦ f (2 * k + 1)) m') : HasProd f (m * m')

(ho : HasSum (fun k => f (2 * k + 1)) m')


theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a

{α : Type u_1}
[PartialOrder α]
[SuccOrder α]
{a b : α}

a ≤ b ∧ b ≤ Order.succ a ↔ b = a ∨ b = Order.succ a


@[to_additive]
theorem exists_finiteIndex_of_leftCoset_cover_aux [DecidableEq (Subgroup G)]
    (j : ι) (hj : j ∈ s) (hcovers' : ⋃ i ∈ s.filter (H · = H j), g i • (H i : Set G) ≠ Set.univ) :
    ∃ i ∈ s, H i ≠ H j ∧ (H i).FiniteIndex

(hcovers : ⋃ i ∈ s, g i • ↑(H i) = Set.univ)

(hcovers' : ⋃ i ∈ Finset.filter (fun x => H x = H j) s, g i • ↑(H i) ≠ Set.univ)


@[simp]
theorem antivaryOn_univ : AntivaryOn f g univ ↔ Antivary f g

{ι : Type u_1}
{α : Type u_3}
{β : Type u_4}
[Preorder α]
[Preorder β]
{f : ι → α}
{g : ι → β}


@[to_additive]
theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
    |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂)

{E : Type u_3}
[SeminormedAddCommGroup E]
(a₁ a₂ b₁ b₂ : E)

|dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ + a₂) (b₁ + b₂)


theorem exists_finset_of_mem_adjoin {S : Set E} {x : E} (hx : x ∈ adjoin F S) :
    ∃ T : Finset E, (T : Set E) ⊆ S ∧ x ∈ adjoin F (T : Set E)

{F : Type u_1}
[Field F]
{E : Type u_2}
[Field E]
[Algebra F E]
{S : Set E}
{x : E}
(hx : x ∈ IntermediateField.adjoin F S)

∃ T, ↑T ⊆ S ∧ x ∈ IntermediateField.adjoin F ↑T


/-- Horizontal composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def hComp (T₁ : C₁ ⥤ C₂) (T₂ : C₂ ⥤ C₃) (V₁ : C₁ ⥤ C₄) (V₂ : C₂ ⥤ C₅) (V₃ : C₃ ⥤ C₆)
    (B₁ : C₄ ⥤ C₅) (B₂ : C₅ ⥤ C₆) [CatCommSq T₁ V₁ V₂ B₁] [CatCommSq T₂ V₂ V₃ B₂] :
    CatCommSq (T₁ ⋙ T₂) V₁ V₃ (B₁ ⋙ B₂)

CategoryTheory.CatCommSq.iso'.hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.CatCommSq.iso T₂ V₂ V₃ B₂).hom.app (T₁.obj X))
    (B₂.map ((CategoryTheory.CatCommSq.iso T₁ V₁ V₂ B₁).hom.app X))


@[to_additive]
theorem prod_involution {s : Finset α} {f : α → β} :
    ∀ (g : ∀ a ∈ s, α) (_ : ∀ a ha, f a * f (g a ha) = 1) (_ : ∀ a ha, f a ≠ 1 → g a ha ≠ a)
      (g_mem : ∀ a ha, g a ha ∈ s) (_ : ∀ a ha, g (g a ha) (g_mem a ha) = a),
      ∏ x ∈ s, f x = 1

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

(∀ (a : α) (ha : a ∈ s), f a * f (g a ha) = 1) →
  (∀ (a : α) (ha : a ∈ s), f a ≠ 1 → g a ha ≠ a) →
    ∀ (g_mem : ∀ (a : α) (ha : a ∈ s), g a ha ∈ s), (∀ (a : α) (ha : a ∈ s), g (g a ha) ⋯ = a) → ∏ x ∈ s, f x = 1


theorem wOppSide_lineMap_right {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : t ≤ 0) : s.WOppSide y (lineMap x y t)

{R : Type u_1}
{V : Type u_2}
{P : Type u_4}
[StrictOrderedCommRing R]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
{s : AffineSubspace R P}
{x : P}
(y : P)
(h : x ∈ s)
{t : R}
(ht : t ≤ 0)

s.WOppSide y ((AffineMap.lineMap x y) t)


theorem IsBigOWith.const_mul_right' {g : α → R} {u : Rˣ} {c' : ℝ} (hc' : 0 ≤ c')
    (h : IsBigOWith c' l f g) : IsBigOWith (c' * ‖(↑u⁻¹ : R)‖) l f fun x => ↑u * g x

{α : Type u_1}
{E : Type u_3}
{R : Type u_13}
[Norm E]
[SeminormedRing R]
{f : α → E}
{l : Filter α}
{g : α → R}
{u : Rˣ}
{c' : ℝ}
(hc' : 0 ≤ c')
(h : Asymptotics.IsBigOWith c' l f g)

Asymptotics.IsBigOWith (c' * ‖↑u⁻¹‖) l f fun x => ↑u * g x


@[simp]
theorem totallyBounded_empty : TotallyBounded (∅ : Set α)

{α : Type u}
[uniformSpace : UniformSpace α]


theorem UniformSpace.isOpen_ball (x : α) {V : Set (α × α)} (hV : IsOpen V) : IsOpen (ball x V)

{α : Type ua}
[UniformSpace α]
(x : α)
{V : Set (α × α)}
(hV : IsOpen V)


lemma equiv_of_Z_eq_zero {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hQ : W.Nonsingular Q)
    (hPz : P z = 0) (hQz : Q z = 0) : P ≈ Q

{F : Type v}
[Field F]
{W : WeierstrassCurve.Jacobian F}
{P Q : Fin 3 → F}
(hP : W.Nonsingular P)
(hQ : W.Nonsingular Q)
(hPz : P z = 0)
(hQz : Q z = 0)


@[to_additive (attr := nontriviality) norm_of_subsingleton]
theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0

{E : Type u_6}
[SeminormedGroup E]
[Subsingleton E]
(a : E)


theorem AnalyticAt.exists_mem_nhds_analyticOn {f : E → F} {x : E} (h : AnalyticAt 𝕜 f x) :
    ∃ s ∈ 𝓝 x, AnalyticOn 𝕜 f s

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


theorem eq_bot_mono (h : a ≤ b) (h₂ : b = ⊥) : a = ⊥

{α : Type u}
[PartialOrder α]
[OrderBot α]
{a b : α}
(h : a ≤ b)
(h₂ : b = ⊥)


@[simp]
theorem map_obj (x : X) (U) (q) : (map f x).obj ⟨U, q⟩ = ⟨(Opens.map f).obj U, q⟩

{X Y : TopCat}
(f : X ⟶ Y)
(x : ↑X)
(U : TopologicalSpace.Opens ↑Y)
(q : f x ∈ U)

(TopologicalSpace.OpenNhds.map f x).obj { obj := U, property := q } =
  { obj := (TopologicalSpace.Opens.map f).obj U, property := q }


/-- Every filter is a CardinalInterFilter with c = aleph0 -/
theorem _root_.Filter.cardinalInterFilter_aleph0 (l : Filter α) : CardinalInterFilter l aleph0


theorem tangentMapWithin_comp_at (p : TangentBundle I M)
    (hg : MDifferentiableWithinAt I' I'' g u (f p.1)) (hf : MDifferentiableWithinAt I I' f s p.1)
    (h : s ⊆ f ⁻¹' u) (hps : UniqueMDiffWithinAt I s p.1) :
    tangentMapWithin I I'' (g ∘ f) s p =
      tangentMapWithin I' I'' g u (tangentMapWithin I I' f s p)

[I''s : SmoothManifoldWithCorners I'' M'']

(hg : MDifferentiableWithinAt I' I'' g u (f p.proj))

(hf : MDifferentiableWithinAt I I' f s p.proj)


/-- The **corners theorem** for `ℕ`.

The maximum density of a corner-free set in `{1, ..., n} × {1, ..., n}` goes to zero as `n` tends to
infinity. -/
theorem corners_theorem_nat (hε : 0 < ε) (hn : cornersTheoremBound (ε / 9) ≤ n)
    (A : Finset (ℕ × ℕ)) (hAn : A ⊆ range n ×ˢ range n) (hAε : ε * n ^ 2 ≤ A.card) :
    ¬ IsCornerFree (A : Set (ℕ × ℕ))

(hAn : A ⊆ Finset.range n ×ˢ Finset.range n)


theorem restrict_congr_set (h : s =ᵐ[μ] t) : μ.restrict s = μ.restrict t

{α : Type u_2}
{m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{s t : Set α}
(h : s =ᵐ[μ] t)


/-- `direction_of_nonempty` gives the same submodule as `direction`. -/
theorem directionOfNonempty_eq_direction {s : AffineSubspace k P} (h : (s : Set P).Nonempty) :
    directionOfNonempty h = s.direction

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

AffineSubspace.directionOfNonempty h = s.direction


lemma odd_add' : Odd (m + n) ↔ (Odd n ↔ Even m)


/-- The identity comonad. -/
@[simps!]
def id : Comonad C

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

(CategoryTheory.Comonad.id C).ε.app X = CategoryTheory.CategoryStruct.id X


theorem sin_eq_neg_one_iff {x : ℝ} : sin x = -1 ↔ ∃ k : ℤ, -(π / 2) + k * (2 * π) = x

Real.sin x = -1 ↔ ∃ k, -(Real.pi / 2) + ↑k * (2 * Real.pi) = x


/-- Functorially precompose a cocone for `F` by a natural transformation `G ⟶ F` to give a cocone
for `G`. -/
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G

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

((CategoryTheory.Limits.Cocones.precompose α).obj c).ι = α ≫ c.ι


@[simp]
theorem map_top (f : A →ₙₐ[R] B) : (⊤ : NonUnitalSubalgebra R A).map f = NonUnitalAlgHom.range f

{R : Type u}
{A : Type v}
{B : Type w}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]
[NonUnitalNonAssocSemiring B]
[Module R B]
(f : A →ₙₐ[R] B)

NonUnitalSubalgebra.map f ⊤ = NonUnitalAlgHom.range f


/-- The map `(x, y) ↦ (mk x, mk y)` is a quotient map. -/
theorem quotientMap_prodMap_mk : QuotientMap (Prod.map mk mk : X × Y → _)

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

QuotientMap (Prod.map SeparationQuotient.mk SeparationQuotient.mk)


@[simp] theorem smul_nil {i : Int} : i * ([] : IntList) = []


@[to_additive]
theorem finprod_pow (hf : (mulSupport f).Finite) (n : ℕ) : (∏ᶠ i, f i) ^ n = ∏ᶠ i, f i ^ n

{α : Type u_1}
{M : Type u_5}
[AddCommMonoid M]
{f : α → M}
(hf : (Function.support f).Finite)
(n : ℕ)

n • ∑ᶠ (i : α), f i = ∑ᶠ (i : α), n • f i


lemma Pi.single_apply_smul {ι : Type*} [DecidableEq ι] (x : M) (i j : ι) :
    (Pi.single i 1 : ι → R) j • x = (Pi.single i x : ι → M) j

{R : Type u_1}
{M : Type u_3}
[MonoidWithZero R]
[Zero M]
[MulActionWithZero R M]
{ι : Type u_5}
[DecidableEq ι]
(x : M)
(i j : ι)


@[simp]
theorem coe_add (f g : SlashInvariantForm Γ k) : ⇑(f + g) = f + g

{Γ : Subgroup SL(2, ℤ)}
{k : ℤ}
(f g : SlashInvariantForm Γ k)


@[to_additive]
lemma mem_orbit_of_mem_orbit_submonoid {S : Submonoid M} {a b : α} (h : a ∈ orbit S b) :
    a ∈ orbit M b

{M : Type u}
[Monoid M]
{α : Type v}
[MulAction M α]
{S : Submonoid M}
{a b : α}
(h : a ∈ MulAction.orbit (↥S) b)


/-- The product of a function `g` defined only on a set `s` is equal to
the product of a function `f` defined everywhere,
as long as `f` and `g` agree on `s`, and `f = 1` off `s`. -/
@[to_additive "The sum of a function `g` defined only on a set `s` is equal to
the sum of a function `f` defined everywhere,
as long as `f` and `g` agree on `s`, and `f = 0` off `s`."]
theorem prod_congr_set {α : Type*} [CommMonoid α] {β : Type*} [Fintype β] (s : Set β)
    [DecidablePred (· ∈ s)] (f : β → α) (g : s → α) (w : ∀ (x : β) (h : x ∈ s), f x = g ⟨x, h⟩)
    (w' : ∀ x : β, x ∉ s → f x = 1) : Finset.univ.prod f = Finset.univ.prod g


@[simp]
theorem quotQuotEquivComm_quotQuotMk (x : R) :
    quotQuotEquivComm I J (quotQuotMk I J x) = quotQuotMk J I x

{R : Type u}
[CommRing R]
(I J : Ideal R)
(x : R)

(DoubleQuot.quotQuotEquivComm I J) ((DoubleQuot.quotQuotMk I J) x) = (DoubleQuot.quotQuotMk J I) x


theorem BinaryFan.IsLimit.hom_ext {W X Y : C} {s : BinaryFan X Y} (h : IsLimit s) {f g : W ⟶ s.pt}
    (h₁ : f ≫ s.fst = g ≫ s.fst) (h₂ : f ≫ s.snd = g ≫ s.snd) : f = g

{s : CategoryTheory.Limits.BinaryFan X Y}


theorem disjSups_left_comm : s ○ (t ○ u) = t ○ (s ○ u)

{α : Type u_2}
[DecidableEq α]
[DistribLattice α]
[OrderBot α]
[DecidableRel Disjoint]
(s t u : Finset α)

s.disjSups (t.disjSups u) = t.disjSups (s.disjSups u)


/-- The reification of a negative literal `¬⟦¬a⟧_v ≡ a`. -/
theorem Literal.reify_neg {a : Prop} {n : ℕ} (h : v n ↔ a) : (Literal.neg n).reify v a

{v : Sat.Valuation}
{a : Prop}
{n : ℕ}
(h : v n ↔ a)

Sat.Literal.reify v (Sat.Literal.neg n) a


@[simp] lemma liftRelAux_inl_inr {a : α} {cb} :
    LiftRelAux R C (Sum.inl a) (Sum.inr cb) = ∃ b, b ∈ cb ∧ R a b

{C : Computation α → Computation β → Prop}

Computation.LiftRelAux R C (Sum.inl a) (Sum.inr cb) = ∃ b, b ∈ cb ∧ R a b


theorem UInt16.toNat_sub (x y : UInt16) :
    (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size


theorem dropWhile_replicate (p : α → Bool) :
    (replicate n a).dropWhile p = if p a then [] else replicate n a

{α : Type u_1}
{n : Nat}
{a : α}
(p : α → Bool)

List.dropWhile p (List.replicate n a) = if p a = true then [] else List.replicate n a


theorem colimit_sound {j j' : J} {x : F.obj j} {x' : F.obj j'} (f : j ⟶ j')
    (w : F.map f x = x') : colimit.ι F j x = colimit.ι F j' x'

{J : Type v}
[CategoryTheory.Category.{w, v} J]
{F : J ⥤ Type u}
[CategoryTheory.Limits.HasColimit F]
{j j' : J}
{x : F.obj j}
{x' : F.obj j'}
(f : j ⟶ j')
(w : F.map f x = x')

CategoryTheory.Limits.colimit.ι F j x = CategoryTheory.Limits.colimit.ι F j' x'


lemma pred_nat_succ (n : ℕ) : pred (Nat.succ n) = n


/-- Definition of `≤` for congruence relations. -/
@[to_additive "Definition of `≤` for additive congruence relations."]
theorem le_def {c d : Con M} : c ≤ d ↔ ∀ {x y}, c x y → d x y


theorem HasBasis.to_image_id' (h : l.HasBasis p s) : l.HasBasis (fun t ↦ ∃ i, p i ∧ s i = t) id

{α : Type u_1}
{ι : Sort u_4}
{l : Filter α}
{p : ι → Prop}
{s : ι → Set α}
(h : l.HasBasis p s)

l.HasBasis (fun t => ∃ i, p i ∧ s i = t) id


lemma CompleteSpace.fst_of_prod [UniformSpace β] [CompleteSpace (α × β)] [h : Nonempty β] :
    CompleteSpace α

{α : Type u}
{β : Type v}
[uniformSpace : UniformSpace α]
[UniformSpace β]
[CompleteSpace (α × β)]
[h : Nonempty β]


@[reassoc (attr := simp)]
theorem cokernel.condition : f ≫ cokernel.π f = 0

f ≫ CategoryTheory.Limits.cokernel.π f = 0


theorem div_nonneg_iff : 0 ≤ a / b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

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


theorem StrictMono.div_const {β : Type*} [Preorder β] {f : β → α} (hf : StrictMono f) {c : α}
    (hc : 0 < c) : StrictMono fun x => f x / c

{α : Type u_2}
[LinearOrderedSemifield α]
{β : Type u_4}
[Preorder β]
{f : β → α}
(hf : StrictMono f)
{c : α}
(hc : 0 < c)


lemma not_pos_pow_dvd : ∀ {a n : ℕ} (_ : 1 < a) (_ : 1 < n), ¬ a ^ n ∣ a


/-- The canonical inclusion of rings `R → TrivSqZeroExt R M`. -/
@[simps apply]
def inlHom [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M] : R →+* tsze R M

(R : Type u)
(M : Type v)
[Semiring R]
[AddCommMonoid M]
[Module R M]
[Module Rᵐᵒᵖ M]
(r : R)

(TrivSqZeroExt.inlHom R M) r = TrivSqZeroExt.inl r


theorem IsBaseChange.algHom_ext' [Module R Q] [IsScalarTower R S Q] (g₁ g₂ : N →ₗ[S] Q)
    (e : (g₁.restrictScalars R).comp f = (g₂.restrictScalars R).comp f) : g₁ = g₂

{R : Type u_1}
{M : Type v₁}
{N : Type v₂}
{S : Type v₃}
[AddCommMonoid M]
[AddCommMonoid N]
[CommSemiring R]
[CommSemiring S]
[Algebra R S]
[Module R M]
[Module R N]
[Module S N]
[IsScalarTower R S N]
{f : M →ₗ[R] N}
(h : IsBaseChange S f)
{Q : Type u_3}
[AddCommMonoid Q]
[Module S Q]
[Module R Q]
[IsScalarTower R S Q]
(g₁ g₂ : N →ₗ[S] Q)
(e : ↑R g₁ ∘ₗ f = ↑R g₂ ∘ₗ f)


theorem exists_isIdempotentElem_mul_eq_zero_of_ker_isNilpotent_aux
    (h : ∀ x ∈ RingHom.ker f, IsNilpotent x)
    (e₁ : S) (he : e₁ ∈ f.range) (he₁ : IsIdempotentElem e₁)
    (e₂ : R) (he₂ : IsIdempotentElem e₂) (he₁e₂ : e₁ * f e₂ = 0) :
    ∃ e' : R, IsIdempotentElem e' ∧ f e' = e₁ ∧ e' * e₂ = 0

∃ e', IsIdempotentElem e' ∧ f e' = e₁ ∧ e' * e₂ = 0


theorem CommRingCat.ringHom_comp_eq_comp {R S T : Type _} [CommRing R] [CommRing S] [CommRing T]
    (f : R →+* S) (g : S →+* T) : g.comp f = CommRingCat.ofHom f ≫ CommRingCat.ofHom g

{R S T : Type u_1}
[CommRing R]
[CommRing S]
[CommRing T]
(f : R →+* S)
(g : S →+* T)


theorem cons_swap (a b : α) (s : Sym α n) : a ::ₛ b ::ₛ s = b ::ₛ a ::ₛ s

{α : Type u_1}
{n : ℕ}
(a b : α)
(s : Sym α n)


theorem le_ωSup_of_le {c : Chain α} {x : α} (i : ℕ) (h : x ≤ c i) : x ≤ ωSup c

{α : Type u}
[OmegaCompletePartialOrder α]
{c : OmegaCompletePartialOrder.Chain α}
{x : α}
(i : ℕ)
(h : x ≤ c i)


theorem all_balanceR {P l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H :
      (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    All P (@balanceR α l x r) ↔ All P l ∧ P x ∧ All P r

(H :
  (∃ l', Ordnode.Raised l.size l' ∧ Ordnode.BalancedSz l' r.size) ∨
    ∃ r', Ordnode.Raised r' r.size ∧ Ordnode.BalancedSz l.size r')

Ordnode.All P (l.balanceR x r) ↔ Ordnode.All P l ∧ P x ∧ Ordnode.All P r


@[to_additive (attr := simp)]
theorem coprodAssoc_apply_inr (x : P) : coprodAssoc M N P (inr x) = inr (inr x)

{M : Type u_1}
{N : Type u_2}
{P : Type u_3}
[Monoid M]
[Monoid N]
[Monoid P]
(x : P)

(Monoid.MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inr x) = Monoid.Coprod.inr (Monoid.Coprod.inr x)


theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
    (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : ⋃ x, Ioo (f x) (g x) = Ioo a b

{α : Type u_1}
{β : Type u_2}
[SemilatticeSup α]
[LinearOrder β]
{f g : α → β}
{a b : β}
(hf : Antitone f)
(hg : Monotone g)
(ha : IsGLB (Set.range f) a)
(hb : IsLUB (Set.range g) b)


theorem integrable_of_forall_fin_meas_le [SigmaFinite μ] (C : ℝ≥0∞) (hC : C < ∞) {f : α → E}
    (hf_meas : AEStronglyMeasurable f μ)
    (hf : ∀ s : Set α, MeasurableSet[m] s → μ s ≠ ∞ → (∫⁻ x in s, ‖f x‖₊ ∂μ) ≤ C) :
    Integrable f μ

(hf_meas : MeasureTheory.AEStronglyMeasurable f μ)

(hf : ∀ (s : Set α), MeasurableSet s → μ s ≠ ⊤ → ∫⁻ (x : α) in s, ↑‖f x‖₊ ∂μ ≤ C)


theorem edgeSet_replaceVertex_of_not_adj (hn : ¬G.Adj s t) : (G.replaceVertex s t).edgeSet =
    G.edgeSet \ G.incidenceSet t ∪ (s(·, t)) '' (G.neighborSet s)

{V : Type u_1}
[DecidableEq V]
(G : SimpleGraph V)
{s t : V}
(hn : ¬G.Adj s t)

(G.replaceVertex s t).edgeSet = G.edgeSet \ G.incidenceSet t ∪ (fun x => s(x, t)) '' G.neighborSet s


/-- The type of clopen upper sets of a topological space. -/
structure ClopenUpperSet (α : Type*) [TopologicalSpace α] [LE α] extends Clopens α where
  upper' : IsUpperSet carrier

{α : Type u_3}
[TopologicalSpace α]
[LE α]
(self : ClopenUpperSet α)


/-- Composing a functor which `HasSheafCompose`, yields a functor between sheaf categories. -/
@[simps]
def sheafCompose : Sheaf J A ⥤ Sheaf J B

(J : CategoryTheory.GrothendieckTopology C)

((CategoryTheory.sheafCompose J F).obj G).val = G.val.comp F


/-- Two left Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def leftKanExtensionUnique
    (F'' : D ⥤ H) (α' : F ⟶ L ⋙ F'') [F''.IsLeftKanExtension α'] : F' ≅ F''

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

(F'.leftKanExtensionUnique α F'' α').inv = F''.descOfIsLeftKanExtension α' F' α


@[simp]
lemma δ_ofHom_comp {n : ℤ} (f : F ⟶ G) (z : Cochain G K n) (m : ℤ) :
    δ n m ((Cochain.ofHom f).comp z (zero_add n)) =
      (Cochain.ofHom f).comp (δ n m z) (zero_add m)

(z : CochainComplex.HomComplex.Cochain G K n)

CochainComplex.HomComplex.δ n m ((CochainComplex.HomComplex.Cochain.ofHom f).comp z ⋯) =
  (CochainComplex.HomComplex.Cochain.ofHom f).comp (CochainComplex.HomComplex.δ n m z) ⋯


@[to_additive]
theorem Multiset.prod_eq_prod_toEnumFinset [CommMonoid α] (m : Multiset α) :
    m.prod = ∏ x ∈ m.toEnumFinset, x.1

{α : Type u_1}
[DecidableEq α]
[AddCommMonoid α]
(m : Multiset α)


@[reassoc (attr := simp)] lemma φ₁_L₂_f : S.φ₁ ≫ S.L₂.f = S.φ₂

(S : CategoryTheory.ShortComplex.SnakeInput C)

CategoryTheory.CategoryStruct.comp S.φ₁ S.L₂.f = S.φ₂


@[functor_norm]
theorem map_seq (f : β → γ) (x : F (α → β)) (y : F α) :
    f <$> (x <*> y) = (f ∘ ·) <$> x <*> y

{α β γ : Type u}
{F : Type u → Type v}
[Applicative F]
[LawfulApplicative F]
(f : β → γ)
(x : F (α → β))
(y : F α)

(f <$> Seq.seq x fun x => y) = Seq.seq ((fun x => f ∘ x) <$> x) fun x => y


theorem contMDiffWithinAt_snd {s : Set (M × N)} {p : M × N} :
    ContMDiffWithinAt (I.prod J) J n Prod.snd s p

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{F : Type u_11}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type u_12}
[TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G}
{N : Type u_13}
[TopologicalSpace N]
[ChartedSpace G N]
{n : ℕ∞}
{s : Set (M × N)}
{p : M × N}


lemma isUpperSet_orderDual [Preorder α] [TopologicalSpace α] :
    Topology.IsUpperSet αᵒᵈ ↔ Topology.IsLowerSet α

{α : Type u_1}
[Preorder α]
[TopologicalSpace α]


/-- `Function.const α b` as a bundled continuous function of `b`. -/
@[simps (config := .asFn)]
def constPi : C(β, α → β)

(α : Type u_1)
{β : Type u_2}
[TopologicalSpace β]

⇑(ContinuousMap.constPi α) = fun b => Function.const α b


/-- The category of sheaves taking values in Type is the same as the category of set-valued sheaves.
-/
@[simps]
def sheafEquivSheafOfTypes : Sheaf J (Type w) ≌ SheafOfTypes J

(CategoryTheory.sheafEquivSheafOfTypes J).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun X =>
      CategoryTheory.Iso.refl
        (({ obj := fun S => { val := S.val, cond := ⋯ }, map := fun {X Y} f => { val := f.val }, map_id := ⋯,
                  map_comp := ⋯ }.comp
              { obj := fun S => { val := S.val, cond := ⋯ }, map := fun {X Y} f => { val := f.val }, map_id := ⋯,
                map_comp := ⋯ }).obj
          X))
    ⋯


@[simp, norm_cast]
theorem intCast_imI (z : ℤ) : (z : ℍ[R]).imI = 0


theorem bddLat_dual_comp_forget_to_lat :
    BddLat.dual ⋙ forget₂ BddLat Lat = forget₂ BddLat Lat ⋙ Lat.dual

BddLat.dual ⋙ CategoryTheory.forget₂ BddLat Lat = CategoryTheory.forget₂ BddLat Lat ⋙ Lat.dual


/-- `mongePointVSubFaceCentroidWeightsWithCircumcenter` is the
result of subtracting `centroidWeightsWithCircumcenter` from
`mongePointWeightsWithCircumcenter`. -/
theorem mongePointVSubFaceCentroidWeightsWithCircumcenter_eq_sub {n : ℕ} {i₁ i₂ : Fin (n + 3)}
    (h : i₁ ≠ i₂) :
    mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ =
      mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ

Affine.Simplex.mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ =
  Affine.Simplex.mongePointWeightsWithCircumcenter n - Affine.Simplex.centroidWeightsWithCircumcenter {i₁, i₂}ᶜ


theorem modEq_zero_iff_dvd : a ≡ 0 [ZMOD n] ↔ n ∣ a


@[simp]
theorem restrict_eq_restrict_iff : restrict s f₁ = restrict s f₂ ↔ EqOn f₁ f₂ s

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{f₁ f₂ : α → β}

s.restrict f₁ = s.restrict f₂ ↔ Set.EqOn f₁ f₂ s


theorem exists_max_image [LinearOrder β] (s : Set α) (f : α → β) (h1 : s.Finite) :
    s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f b ≤ f a

{α : Type u}
{β : Type v}
[LinearOrder β]
(s : Set α)
(f : α → β)
(h1 : s.Finite)


theorem finrank_euclideanSpace_fin {n : ℕ} :
    FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 (Fin n)) = n


theorem dist_of_mem_subset_sphere {p : P} {ps : Set P} {s : Sphere P} (hp : p ∈ ps)
    (hps : ps ⊆ (s : Set P)) : dist p s.center = s.radius

(hps : ps ⊆ Metric.sphere s.center s.radius)


theorem comm {a b c : ℤ} : Fermat42 a b c ↔ Fermat42 b a c


theorem gc_map_comap : GaloisConnection (map f) (comap f)

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

GaloisConnection (LieIdeal.map f) (LieIdeal.comap f)


@[simp]
theorem det_diagonal {d : n → R} : det (diagonal d) = ∏ i, d i

{n : Type u_2}
[DecidableEq n]
[Fintype n]
{R : Type v}
[CommRing R]
{d : n → R}


theorem of_d_eq_zero' : (⟨0, 0, 0, 0⟩ : Cubic R).toPoly = 0


theorem normed_le_div_measure_closedBall_rOut [IsAddHaarMeasure μ] (K : ℝ) (h : f.rOut ≤ K * f.rIn)
    (x : E) :
    f.normed μ x ≤ K ^ finrank ℝ E / (μ (closedBall c f.rOut)).toReal

f.normed μ x ≤ K ^ FiniteDimensional.finrank ℝ E / (μ (Metric.closedBall c f.rOut)).toReal


protected theorem «exists» {q : p → Prop} : (∃ x, q x) ↔ ∃ (x : B) (h : x ∈ p), q ⟨x, ‹_›⟩

{A : Type u_1}
{B : Type u_2}
[i : SetLike A B]
{p : A}
{q : ↥p → Prop}

(∃ x, q x) ↔ ∃ x, ∃ (h : x ∈ p), q ⟨x, h⟩


@[simp, norm_cast]
theorem coe_zsmul [∀ i, AddGroup (β i)] (b : ℤ) (v : Π₀ i, β i) : ⇑(b • v) = b • ⇑v

{ι : Type u}
{β : ι → Type v}
[(i : ι) → AddGroup (β i)]
(b : ℤ)
(v : Π₀ (i : ι), β i)


@[simp]
theorem inv_coe_unit {n : ℕ} (u : (ZMod n)ˣ) : (u : ZMod n)⁻¹ = (u⁻¹ : (ZMod n)ˣ)

(↑u)⁻¹ = ↑u⁻¹


@[simp]
theorem colimit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E)
    -- H G (colimit F) ⟶ H (colimit (F ⋙ G)) ⟶ colimit ((F ⋙ G) ⋙ H) equals
    -- H G (colimit F) ⟶ colimit (F ⋙ (G ⋙ H))
    [h : HasColimit ((F ⋙ G) ⋙ H)] : haveI : HasColimit (F ⋙ G ⋙ H) := h
    colimit.post (F ⋙ G) H ≫ H.map (colimit.post F G) = colimit.post F (G ⋙ H)

[CategoryTheory.Limits.HasColimit (F ⋙ G)]

[h : CategoryTheory.Limits.HasColimit ((F ⋙ G) ⋙ H)]

CategoryTheory.Limits.colimit.post (F ⋙ G) H ≫ H.map (CategoryTheory.Limits.colimit.post F G) =
  CategoryTheory.Limits.colimit.post F (G ⋙ H)


lemma minpolyDiv_spec :
    minpolyDiv R x * (X - C x) = (minpoly R x).map (algebraMap R S)

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

minpolyDiv R x * (Polynomial.X - Polynomial.C x) = Polynomial.map (algebraMap R S) (minpoly R x)


protected theorem gc : GaloisConnection (adjoin R : Set A → NonUnitalSubalgebra R A) (↑)

{R : Type u}
{A : Type v}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]

GaloisConnection (NonUnitalAlgebra.adjoin R) SetLike.coe


theorem one_lt_rpow {x z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z


/-- `x ^ k = o(exp(b * x))` as `x → ∞` for any integer `k` and positive `b`. -/
theorem isLittleO_zpow_exp_pos_mul_atTop (k : ℤ) {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => x ^ k) =o[atTop] fun x => exp (b * x)

(fun x => x ^ k) =o[Filter.atTop] fun x => rexp (b * x)


/-- A seminormed ring is a ring endowed with a seminorm which satisfies the inequality
`‖x y‖ ≤ ‖x‖ ‖y‖`. -/
class SeminormedRing (α : Type*) extends Norm α, Ring α, PseudoMetricSpace α where
  /-- The distance is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = norm (x - y)
  /-- The norm is submultiplicative. -/
  norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b

{α : Type u_5}
[self : SeminormedRing α]
(a b : α)

‖a * b‖ ≤ ‖a‖ * ‖b‖


@[simp]
theorem map_integerMultiple {ι : Type*} (s : Finset ι) (g : ι → M') (i : s) :
    f (integerMultiple S f s g i) = commonDenom S f s g • g i

{R : Type u_1}
[CommSemiring R]
(S : Submonoid R)
{M : Type u_2}
[AddCommMonoid M]
[Module R M]
{M' : Type u_3}
[AddCommMonoid M']
[Module R M']
(f : M →ₗ[R] M')
[IsLocalizedModule S f]
{ι : Type u_4}
(s : Finset ι)
(g : ι → M')
(i : { x // x ∈ s })

f (IsLocalizedModule.integerMultiple S f s g i) = IsLocalizedModule.commonDenom S f s g • g ↑i


theorem pairwise_le_range (n : ℕ) : Pairwise (· ≤ ·) (range n)

List.Pairwise (fun x x_1 => x ≤ x_1) (List.range n)


theorem reverse_bijective : Bijective (@reverse α)


theorem sumInl_injective : (LHom.sumInl : L →ᴸ L.sum L').Injective

{L : FirstOrder.Language}
{L' : FirstOrder.Language}


@[to_additive (attr := simp) sum_divisors_prime_pow]
theorem prod_divisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) :
    (∏ x ∈ (p ^ k).divisors, f x) = ∏ x ∈ range (k + 1), f (p ^ x)

{α : Type u_1}
[CommMonoid α]
{k p : ℕ}
{f : ℕ → α}
(h : Nat.Prime p)

∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x)


/-- If a left-invariant measure gives finite mass to a set with nonempty interior, then
it gives finite mass to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives finite
mass to any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant' {U : Set G}
    (hU : (interior U).Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞

{G : Type u_2}
[MeasurableSpace G]
[TopologicalSpace G]
[BorelSpace G]
{μ : MeasureTheory.Measure G}
[AddGroup G]
[TopologicalAddGroup G]
[μ.IsAddLeftInvariant]
{U : Set G}
(hU : (interior U).Nonempty)
(h : μ U ≠ ⊤)
{K : Set G}
(hK : IsCompact K)


/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1

(g : (CategoryTheory.MonoidalCategory.tensorObj (Action.leftRegular G) { V := X.V, ρ := 1 }).V)

(Action.leftRegularTensorIso G X).inv.hom g = (g.1, X.ρ g.1 g.2)


@[to_additive]
theorem eq_mul_of_div_eq' (h : a / b = c) : a = b * c

{G : Type u_3}
[CommGroup G]
{a b c : G}
(h : a / b = c)


@[to_additive (attr := simp)]
theorem mul_val_inv (h : IsUnit a) : a * ↑h.unit⁻¹ = 1

{M : Type u_1}
[AddMonoid M]
{a : M}
(h : IsAddUnit a)


theorem IsPushout.of_map [ReflectsColimit (span f g) F] (e : f ≫ h = g ≫ i)
    (H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)) : IsPushout f g h i

[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.span f g) F]

(H : CategoryTheory.IsPushout (F.map f) (F.map g) (F.map h) (F.map i))


theorem dvd_of_mem_divisors {m : ℕ} (h : n ∈ divisors m) : n ∣ m


theorem bmex_monotone {o o' : Ordinal.{u}}
    {f : ∀ a < o, Ordinal.{max u v}} {g : ∀ a < o', Ordinal.{max u v}}
    (h : brange o f ⊆ brange o' g) : bmex.{_, v} o f ≤ bmex.{_, v} o' g

{f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}}

{g : (a : Ordinal.{u}) → a < o' → Ordinal.{max u v}}


/-- If `X` has subobject lattice `{⊥, ⊤}`, then `X` is simple. -/
theorem simple_of_isSimpleOrder_subobject (X : C) [IsSimpleOrder (Subobject X)] : Simple X


/-- See also `Subtype.prop` -/
theorem Subtype.mem {α : Type*} {s : Set α} (p : s) : (p : α) ∈ s


theorem aeval_eq_sum_range [Algebra R S] {p : R[X]} (x : S) :
    aeval x p = ∑ i ∈ Finset.range (p.natDegree + 1), p.coeff i • x ^ i

{R : Type u}
{S : Type v}
[CommSemiring R]
[Semiring S]
[Algebra R S]
{p : R[X]}
(x : S)

(Polynomial.aeval x) p = ∑ i ∈ Finset.range (p.natDegree + 1), p.coeff i • x ^ i


@[simp]
theorem realize_symmetric : M ⊨ r.symmetric ↔ Symmetric fun x y : M => RelMap r ![x, y]

{L : FirstOrder.Language}
{M : Type w}
[L.Structure M]
{r : L.Relations 2}

M ⊨ r.symmetric ↔ Symmetric fun x y => FirstOrder.Language.Structure.RelMap r ![x, y]


@[refl, simp]
lemma subset_refl [IsRefl α (· ⊆ ·)] (a : α) : a ⊆ a

{α : Type u}
[HasSubset α]
[IsRefl α fun x x_1 => x ⊆ x_1]
(a : α)


/-- Root of a quadratic when its discriminant equals zero -/
theorem quadratic_eq_zero_iff_of_discrim_eq_zero (ha : a ≠ 0) (h : discrim a b c = 0) (x : K) :
    a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)

{K : Type u_1}
[Field K]
[NeZero 2]
{a b c : K}
(ha : a ≠ 0)
(h : discrim a b c = 0)
(x : K)


theorem norm_integral_le_integral_norm (f : α → G) : ‖∫ a, f a ∂μ‖ ≤ ∫ a, ‖f a‖ ∂μ

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

‖∫ (a : α), f a ∂μ‖ ≤ ∫ (a : α), ‖f a‖ ∂μ


protected theorem Subsingleton.antivaryOn [Subsingleton ι] (f : ι → α) (g : ι → β) (s : Set ι) :
    AntivaryOn f g s

{ι : Type u_1}
{α : Type u_3}
{β : Type u_4}
[Preorder α]
[Preorder β]
[Subsingleton ι]
(f : ι → α)
(g : ι → β)
(s : Set ι)


/-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of a subgroup `s` of a seminormed group `E`, its
norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖

{E : Type u_6}
[SeminormedGroup E]
{s : Subgroup E}
(x : ↥s)


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

{α : Type u_3}
{β : Type u_4}
{γ : Type u_5}
[Lattice α]
[Lattice β]
[Lattice γ]
(g : LatticeHom β γ)
(f : LatticeHom α β)


theorem zeroLocus_iSup_homogeneousIdeal {γ : Sort*} (I : γ → HomogeneousIdeal 𝒜) :
    zeroLocus _ ((⨆ i, I i : HomogeneousIdeal 𝒜) : Set A) = ⋂ i, zeroLocus 𝒜 (I i)

{R : Type u_1}
{A : Type u_2}
[CommSemiring R]
[CommRing A]
[Algebra R A]
(𝒜 : ℕ → Submodule R A)
[GradedAlgebra 𝒜]
{γ : Sort u_3}
(I : γ → HomogeneousIdeal 𝒜)

ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i)


theorem starClosure_le {S₁ : NonUnitalSubalgebra R A} {S₂ : NonUnitalStarSubalgebra R A}
    (h : S₁ ≤ S₂.toNonUnitalSubalgebra) : S₁.starClosure ≤ S₂

{R : Type u}
{A : Type v}
[CommSemiring R]
[StarRing R]
[NonUnitalSemiring A]
[StarRing A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]
[StarModule R A]
{S₁ : NonUnitalSubalgebra R A}
{S₂ : NonUnitalStarSubalgebra R A}
(h : S₁ ≤ S₂.toNonUnitalSubalgebra)


theorem isRegular_succ {c : Cardinal.{u}} (h : ℵ₀ ≤ c) : IsRegular (succ c)


lemma Antivary.pow_right₀ (hg : 0 ≤ g) (hfg : Antivary f g) (n : ℕ) : Antivary f (g ^ n)

{ι : Type u_1}
{α : Type u_2}
{β : Type u_3}
[LinearOrderedSemiring α]
[LinearOrderedSemiring β]
{f : ι → α}
{g : ι → β}
(hg : 0 ≤ g)
(hfg : Antivary f g)
(n : ℕ)


theorem apply_mem_spectrum [Nontrivial 𝕜] (φ : characterSpace 𝕜 A) (a : A) : φ a ∈ spectrum 𝕜 a

{𝕜 : Type u_1}
{A : Type u_2}
[CommRing 𝕜]
[NoZeroDivisors 𝕜]
[TopologicalSpace 𝕜]
[ContinuousAdd 𝕜]
[ContinuousConstSMul 𝕜 𝕜]
[TopologicalSpace A]
[Ring A]
[Algebra 𝕜 A]
[Nontrivial 𝕜]
(φ : ↑(WeakDual.characterSpace 𝕜 A))
(a : A)


@[simp]
theorem one_im : (1 : ℤ√d).im = 0


theorem isOpenImmersion_iff_stalk {f : X ⟶ Y} : IsOpenImmersion f ↔
    OpenEmbedding f.1.base ∧ ∀ x, IsIso (f.stalkMap x)

{X Y : AlgebraicGeometry.Scheme}
{f : X ⟶ Y}

AlgebraicGeometry.IsOpenImmersion f ↔
  OpenEmbedding ⇑f.val.base ∧
    ∀ (x : ↑↑X.toPresheafedSpace), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x)


/-- *Dirichlet's approximation theorem:*
For any real number `ξ` and positive natural `n`, there is a natural number `k`,
with `0 < k ≤ n` such that `|k*ξ - round(k*ξ)| ≤ 1/(n+1)`.
-/
theorem exists_nat_abs_mul_sub_round_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ k : ℕ, 0 < k ∧ k ≤ n ∧ |↑k * ξ - round (↑k * ξ)| ≤ 1 / (n + 1)

∃ k, 0 < k ∧ k ≤ n ∧ |↑k * ξ - ↑(round (↑k * ξ))| ≤ 1 / (↑n + 1)


theorem mul_div_le (m n : Nat) : n * (m / n) ≤ m


theorem card_parts_le_card : P.parts.card ≤ s.card

{α : Type u_1}
[DecidableEq α]
{s : Finset α}
(P : Finpartition s)


/-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C

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

(CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).left.obj n =
  CategoryTheory.Limits.widePullback f.right (fun x => f.left) fun x => f.hom


theorem ContinuousOn.prod_map {f : α → γ} {g : β → δ} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hg : ContinuousOn g t) : ContinuousOn (Prod.map f g) (s ×ˢ t)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
[TopologicalSpace δ]
{f : α → γ}
{g : β → δ}
{s : Set α}
{t : Set β}
(hf : ContinuousOn f s)
(hg : ContinuousOn g t)


/-- A comonoid object in the category of `R`-modules has a natural comultiplication
and counit. -/
@[simps]
instance ofComonObjCoalgebraStruct (X : Comon_ (ModuleCat R)) :
    CoalgebraStruct R X.X

{R : Type u}
[CommRing R]
(X : Comon_ (ModuleCat R))


lemma lintegral_condKernel_mem {s : Set (β × Ω)} (hs : MeasurableSet s) :
    ∫⁻ x, ρ.condKernel x {y | (x, y) ∈ s} ∂ρ.fst = ρ s

{β : Type u_2}
{Ω : Type u_3}
{mβ : MeasurableSpace β}
[MeasurableSpace Ω]
[StandardBorelSpace Ω]
[Nonempty Ω]
{ρ : MeasureTheory.Measure (β × Ω)}
[MeasureTheory.IsFiniteMeasure ρ]
{s : Set (β × Ω)}
(hs : MeasurableSet s)

∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ρ s


@[ext]
theorem ext {f g : A →⋆ₙₐ[R] B} (h : ∀ x, f x = g x) : f = g

{R : Type u_1}
{A : Type u_2}
{B : Type u_3}
[Monoid R]
[NonUnitalNonAssocSemiring A]
[DistribMulAction R A]
[Star A]
[NonUnitalNonAssocSemiring B]
[DistribMulAction R B]
[Star B]
{f g : A →⋆ₙₐ[R] B}
(h : ∀ (x : A), f x = g x)


@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b)

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

[CovariantClass α α (Function.swap HAdd.hAdd) LE.le]


@[simp]
theorem mem_insert {a a' : α} {b' : β a'} {s : Finmap β} : a ∈ insert a' b' s ↔ a = a' ∨ a ∈ s

{α : Type u}
{β : α → Type v}
[DecidableEq α]
{a a' : α}
{b' : β a'}
{s : Finmap β}

a ∈ Finmap.insert a' b' s ↔ a = a' ∨ a ∈ s


@[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M

Subsingleton (AddSubmonoid M) ↔ Subsingleton M


@[simp]
theorem iInf_Prop_eq {p : ι → Prop} : ⨅ i, p i = ∀ i, p i


@[simp]
lemma cyclesMap'_id (h : S.LeftHomologyData) :
    cyclesMap' (𝟙 S) h h = 𝟙 _

CategoryTheory.ShortComplex.cyclesMap' (CategoryTheory.CategoryStruct.id S) h h = CategoryTheory.CategoryStruct.id h.K


@[trans]
theorem BlankExtends.trans {Γ} [Inhabited Γ] {l₁ l₂ l₃ : List Γ} :
    BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃

{Γ : Type u_1}
[Inhabited Γ]
{l₁ l₂ l₃ : List Γ}

Turing.BlankExtends l₁ l₂ → Turing.BlankExtends l₂ l₃ → Turing.BlankExtends l₁ l₃


@[simp]
theorem leadingCoeff_map [Semiring S] [Nontrivial S] (f : R →+* S) :
    leadingCoeff (p.map f) = f (leadingCoeff p)

{R : Type u}
{S : Type v}
[DivisionRing R]
{p : R[X]}
[Semiring S]
[Nontrivial S]
(f : R →+* S)

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


theorem inr_injective : Function.Injective (inr : β → α ⊕ β)


@[simp]
theorem mem_toNonUnitalSubalgebra {p : Submodule R A} {h_mul} {x} :
    x ∈ p.toNonUnitalSubalgebra h_mul ↔ x ∈ p

{h_mul : ∀ (x y : A), x ∈ p → y ∈ p → x * y ∈ p}


@[to_additive]
theorem period_eq_one_iff {m : M} {a : α} : period m a = 1 ↔ m • a = a

{α : Type v}
{M : Type u}
[Monoid M]
[MulAction M α]
{m : M}
{a : α}


theorem getElem_fin_eq_data_get (a : Array α) (i : Fin _) : a[i] = a.data.get i

{α : Type u_1}
(a : Array α)
(i : Fin a.data.length)


protected theorem comp_map (g' : α → β) (h : β → γ) :
    ∀ x : Comp F G α, Comp.map (h ∘ g') x = Comp.map h (Comp.map g' x)

{F : Type u → Type w}
{G : Type v → Type u}
[Functor F]
[Functor G]
[LawfulFunctor F]
[LawfulFunctor G]
{α β γ : Type v}
(g' : α → β)
(h : β → γ)
(x : Functor.Comp F G α)

Functor.Comp.map (h ∘ g') x = Functor.Comp.map h (Functor.Comp.map g' x)


@[simp]
theorem prodMonoidal_leftUnitor_inv_fst (X : C₁ × C₂) :
    ((λ_ X).inv : X ⟶ 𝟙_ _ ⊗ X).1 = (λ_ X.1).inv

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

(CategoryTheory.MonoidalCategory.leftUnitor X).inv.1 = (CategoryTheory.MonoidalCategory.leftUnitor X.1).inv


/-- A ring isomorphism preserves multiplication. -/
protected theorem map_mul (e : R ≃+* S) (x y : R) : e (x * y) = e x * e y

{R : Type u_4}
{S : Type u_5}
[Mul R]
[Mul S]
[Add R]
[Add S]
(e : R ≃+* S)
(x y : R)


@[to_additive (attr := simp)]
theorem lift_of (x : α) : lift f (of x) = f x

{α : Type u}
[Mul α]
{β : Type v}
[Semigroup β]
(f : α →ₙ* β)
(x : α)

(Magma.AssocQuotient.lift f) (Magma.AssocQuotient.of x) = f x


@[to_additive (attr := simp)]
theorem preimage_mul_right_closedBall [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ) :
    (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r

{G : Type v}
[Group G]
[PseudoMetricSpace G]
[IsometricSMul Gᵐᵒᵖ G]
(a b : G)
(r : ℝ)

(fun x => x * a) ⁻¹' Metric.closedBall b r = Metric.closedBall (b / a) r


@[simp]
protected theorem BlockTriangular.submatrix {f : n → m} (h : M.BlockTriangular b) :
    (M.submatrix f f).BlockTriangular (b ∘ f)

{α : Type u_1}
{m : Type u_3}
{n : Type u_4}
{R : Type v}
[CommRing R]
{M : Matrix m m R}
{b : m → α}
[LT α]
{f : n → m}
(h : M.BlockTriangular b)


@[simp] theorem self_eq_append_right {x y : List α} : x = x ++ y ↔ y = []


theorem chainHeight_insert_of_forall_gt (a : α) (hx : ∀ b ∈ s, a < b) :
    (insert a s).chainHeight = s.chainHeight + 1

{α : Type u_1}
{s : Set α}
[Preorder α]
(a : α)
(hx : ∀ b ∈ s, a < b)


@[to_additive]
theorem noncommProd_mul_single [Fintype ι] [DecidableEq ι] (x : ∀ i, M i) :
    (univ.noncommProd (fun i => Pi.mulSingle i (x i)) fun i _ j _ _ =>
        Pi.mulSingle_apply_commute x i j) = x

{ι : Type u_2}
{M : ι → Type u_6}
[(i : ι) → AddMonoid (M i)]
[Fintype ι]
[DecidableEq ι]
(x : (i : ι) → M i)

Finset.univ.noncommSum (fun i => Pi.single i (x i)) ⋯ = x


lemma map_apply (ν : ProbabilityMeasure Ω) {f : Ω → Ω'} (f_aemble : AEMeasurable f ν)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    (ν.map f_aemble) A = ν (f ⁻¹' A)

(ν : MeasureTheory.ProbabilityMeasure Ω)


theorem isAffineOpen_top (X : Scheme) [IsAffine X] : IsAffineOpen (⊤ : X.Opens)

(X : AlgebraicGeometry.Scheme)
[AlgebraicGeometry.IsAffine X]


theorem iInf_singleton (a : α) (s : α → β) : ⨅ x ∈ ({a} : Finset α), s x = s a

{α : Type u_2}
{β : Type u_3}
[CompleteLattice β]
(a : α)
(s : α → β)


theorem KaehlerDifferential.D_tensorProductTo (x : KaehlerDifferential.ideal R S) :
    (KaehlerDifferential.D R S).tensorProductTo x =
      (KaehlerDifferential.ideal R S).toCotangent x

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
(x : ↥(KaehlerDifferential.ideal R S))

(KaehlerDifferential.D R S).tensorProductTo ↑x = (KaehlerDifferential.ideal R S).toCotangent x


theorem HasLineDerivAt.tendsto_slope_zero_right [PartialOrder 𝕜] (h : HasLineDerivAt 𝕜 f f' x v) :
    Tendsto (fun (t : 𝕜) ↦ t⁻¹ • (f (x + t • v) - f x)) (𝓝[>] 0) (𝓝 f')

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{F : Type u_2}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{E : Type u_3}
[AddCommGroup E]
[Module 𝕜 E]
{f : E → F}
{f' : F}
{x v : E}
[PartialOrder 𝕜]
(h : HasLineDerivAt 𝕜 f f' x v)

Filter.Tendsto (fun t => t⁻¹ • (f (x + t • v) - f x)) (𝓝[>] 0) (𝓝 f')


protected theorem add_mul (n m k : Nat) : (n + m) * k = n * k + m * k


theorem constantsOnMap_isExpansionOn {f : α → β} {fα : α → M} {fβ : β → M} (h : fβ ∘ f = fα) :
    @LHom.IsExpansionOn _ _ (LHom.constantsOnMap f) M (constantsOn.structure fα)
      (constantsOn.structure fβ)

{M : Type w}
{α : Type u'}
{β : Type v'}
{f : α → β}
{fα : α → M}
{fβ : β → M}
(h : fβ ∘ f = fα)


/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_lt_mul'`. -/
@[to_additive Right.add_pos' "Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos'`."]
theorem Right.one_lt_mul' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 < a)
    (hb : 1 < b) :
    1 < a * b

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


theorem Groupoid.isIsomorphic_iff_nonempty_hom {C : Type u} [Groupoid.{v} C] {X Y : C} :
    IsIsomorphic X Y ↔ Nonempty (X ⟶ Y)

{C : Type u}
[CategoryTheory.Groupoid C]
{X Y : C}

CategoryTheory.IsIsomorphic X Y ↔ Nonempty (X ⟶ Y)


nonrec theorem HasDerivAtFilter.const_smul (c : R) (hf : HasDerivAtFilter f f' x L) :
    HasDerivAtFilter (fun y => c • f y) (c • f') x L

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{F : Type v}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : 𝕜 → F}
{f' : F}
{x : 𝕜}
{L : Filter 𝕜}
{R : Type u_2}
[Semiring R]
[Module R F]
[SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F]
(c : R)
(hf : HasDerivAtFilter f f' x L)


lemma inl_mem_sumLexLift {c₁ : γ₁} :
    inl c₁ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
        ∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₁ ∈ g₁ a₁ b₂

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

Sum.inl c₁ ∈ Finset.sumLexLift f₁ f₂ g₁ g₂ a b ↔
  (∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨ ∃ a₁ b₂, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ c₁ ∈ g₁ a₁ b₂


@[simp]
theorem coe_iicInfHom : (iicInfHom : α → LowerSet α) = Iic


/-- Two subfields are equal if they have the same elements. -/
@[ext]
theorem ext {S T : Subfield K} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T

{K : Type u}
[DivisionRing K]
{S T : Subfield K}
(h : ∀ (x : K), x ∈ S ↔ x ∈ T)


theorem IsClosedMap.lift'_closure_map_eq
    (f_closed : IsClosedMap f) (f_cont : Continuous f) (F : Filter X) :
    (map f F).lift' closure = map f (F.lift' closure)

{X : Type u_1}
{Y : Type u_2}
{f : X → Y}
[TopologicalSpace X]
[TopologicalSpace Y]
(f_closed : IsClosedMap f)
(f_cont : Continuous f)
(F : Filter X)

(Filter.map f F).lift' closure = Filter.map f (F.lift' closure)


theorem gauss_lemma_aux (p : ℕ) [hp : Fact p.Prime] {a : ℤ}
    (hap : (a : ZMod p) ≠ 0) : (↑a ^ (p / 2) : ZMod p) =
    ((-1) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card :)

(p : ℕ)
[hp : Fact (Nat.Prime p)]
{a : ℤ}
(hap : ↑a ≠ 0)

↑a ^ (p / 2) = ↑((-1) ^ (Finset.filter (fun x => p / 2 < (↑a * ↑x).val) (Finset.Ico 1 (p / 2).succ)).card)


theorem sup_eq_sSup_image [CompleteLattice β] (s : Finset α) (f : α → β) :
    s.sup f = sSup (f '' s)

{α : Type u_2}
{β : Type u_3}
[CompleteLattice β]
(s : Finset α)
(f : α → β)


theorem fderiv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    fderiv 𝕜 (fun y => c y * d y) x = c x • fderiv 𝕜 d x + d x • fderiv 𝕜 c x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{x : E}
{𝔸' : Type u_7}
[NormedCommRing 𝔸']
[NormedAlgebra 𝕜 𝔸']
{c d : E → 𝔸'}
(hc : DifferentiableAt 𝕜 c x)
(hd : DifferentiableAt 𝕜 d x)


theorem cosh_sq' : cosh x ^ 2 = 1 + sinh x ^ 2


@[ext]
lemma hom_ext {C D : HomologicalComplex V c} (f g : C ⟶ D)
    (h : ∀ i, f.f i = g.f i) : f = g


@[simp] theorem eval_nil : (lc : LinearCombo).eval .nil = lc.const


theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·)

{α : Type u_2}
[Preorder α]
[TopologicalSpace α]
[BoundedLENhdsClass α]
(a : α)

Filter.IsCobounded (fun x x_1 => x ≥ x_1) (𝓝 a)


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

{α : Type u_2}
[Field α]
[TopologicalSpace α]
[TopologicalDivisionRing α]
(s : Subfield α)
{t : Subfield α}
(h : s ≤ t)
(ht : IsClosed ↑t)


theorem NeBot.coprodᵢ [∀ i, Nonempty (α i)] {i : ι} (h : NeBot (f i)) : NeBot (Filter.coprodᵢ f)

{ι : Type u_1}
{α : ι → Type u_2}
{f : (i : ι) → Filter (α i)}
[∀ (i : ι), Nonempty (α i)]
{i : ι}
(h : (f i).NeBot)


@[simp]
theorem Ioo_eq_zero_of_le (h : b ≤ a) : Ioo a b = 0

{α : Type u_1}
[Preorder α]
[LocallyFiniteOrder α]
{a b : α}
(h : b ≤ a)


theorem nhds_eq_uniformity' {x : α} : 𝓝 x = (𝓤 α).lift' fun s => { y | (y, x) ∈ s }

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


theorem aemeasurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) (μ : Measure (E × E)) :
    AEMeasurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) μ

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
[LocallyCompactSpace 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[MeasurableSpace E]
[OpensMeasurableSpace E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[CompleteSpace F]
{f : E → F}
[SecondCountableTopology E]
[MeasurableSpace F]
[BorelSpace F]
(hf : Continuous f)
(μ : MeasureTheory.Measure (E × E))

AEMeasurable (fun p => lineDeriv 𝕜 f p.1 p.2) μ


/-- Given two points in an affine subspace, the angles between those two points at two other
points on the same side of that subspace have the same sign. -/
theorem _root_.AffineSubspace.SSameSide.oangle_sign_eq {s : AffineSubspace ℝ P} {p₁ p₂ p₃ p₄ : P}
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃p₄ : s.SSameSide p₃ p₄) :
    (∡ p₁ p₄ p₂).sign = (∡ p₁ p₃ p₂).sign

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


theorem getElem_of_mem : ∀ {a} {l : List α}, a ∈ l → ∃ (n : Nat) (h : n < l.length), l[n]'h = a


/-- This is the Fitting decomposition of the Lie module `M`. -/
lemma isCompl_weightSpace_zero_posFittingComp :
    IsCompl (weightSpace M 0) (posFittingComp R L M)

(R : Type u_2)
(L : Type u_3)
(M : Type u_4)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[LieAlgebra.IsNilpotent R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
[IsNoetherian R M]
[IsArtinian R M]

IsCompl (LieModule.weightSpace M 0) (LieModule.posFittingComp R L M)


lemma _root_.LinearEquiv.isWeaklyRegular_congr' (e : M ≃ₛₗ[σ] M₂) (rs : List R) :
    IsWeaklyRegular M rs ↔ IsWeaklyRegular M₂ (rs.map σ)

{R : Type u_1}
{S : Type u_2}
{M : Type u_3}
{M₂ : Type u_4}
[CommRing R]
[CommRing S]
[AddCommGroup M]
[AddCommGroup M₂]
[Module R M]
[Module S M₂]
{σ : R →+* S}
{σ' : S →+* R}
[RingHomInvPair σ σ']
[RingHomInvPair σ' σ]
(e : M ≃ₛₗ[σ] M₂)
(rs : List R)

RingTheory.Sequence.IsWeaklyRegular M rs ↔ RingTheory.Sequence.IsWeaklyRegular M₂ (List.map (⇑σ) rs)


theorem IsPrimePow.one_lt {n : ℕ} (h : IsPrimePow n) : 1 < n


@[to_additive]
theorem IsWF.mul (hs : s.IsWF) (ht : t.IsWF) : IsWF (s * t)

{α : Type u_1}
{s t : Set α}
[LinearOrderedCancelAddCommMonoid α]
(hs : s.IsWF)
(ht : t.IsWF)


@[simp]
lemma traceForm_lieSubalgebra_mk_right (L' : LieSubalgebra R L) {x : L'} {y : L} (hy : y ∈ L') :
    traceForm R L' M x ⟨y, hy⟩ = traceForm R L M x y

(R : Type u_1)
(L : Type u_3)
(M : Type u_4)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
(L' : LieSubalgebra R L)
{x : ↥L'}
{y : L}
(hy : y ∈ L')

((LieModule.traceForm R (↥L') M) x) ⟨y, hy⟩ = ((LieModule.traceForm R L M) ↑x) y


theorem indep_iSup_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s μ) (hf : ∀ t, p t → tᶜ ∈ f)
    (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a)) (hns_univ : ∀ n, ∃ a, n ∈ ns a) :
    Indep (⨆ n, s n) (limsup s f) μ

(h_indep : ProbabilityTheory.iIndep s μ)

(hns : Directed (fun x x_1 => x ≤ x_1) ns)

ProbabilityTheory.Indep (⨆ n, s n) (Filter.limsup s f) μ


theorem le_of_nhds_le_nhds (h : ∀ x, @nhds α t₁ x ≤ @nhds α t₂ x) : t₁ ≤ t₂

{α : Type u_1}
{t₁ t₂ : TopologicalSpace α}
(h : ∀ (x : α), 𝓝 x ≤ 𝓝 x)


theorem LeftInverse.rightInvOn_range {g : β → α} (h : LeftInverse f g) :
    RightInvOn f g (range g)

{α : Type u_1}
{β : Type u_2}
{f : α → β}
{g : β → α}
(h : Function.LeftInverse f g)


lemma preNormEDS'_odd (m : ℕ) : preNormEDS' b c d (2 * (m + 2) + 1) =
    preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * (if Even m then b else 1) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * (if Even m then 1 else b)

{R : Type u}
[CommRing R]
(b c d : R)
(m : ℕ)

preNormEDS' b c d (2 * (m + 2) + 1) =
  (preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
    preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b


theorem mul_add_left_right : IsRelPrime x (x * z + y)

{R : Type u_1}
[CommRing R]
{x y : R}
(h : IsRelPrime x y)
(z : R)


theorem length_sub_le : (s - t).length ≤ s.length + t.length

{α : Type u_2}
[OrderedAddCommGroup α]
(s t : Interval α)


@[to_additive]
theorem range_eq_top_of_epi [Epi f] : f.range = ⊤

{A B : CommGrp}
(f : A ⟶ B)
[CategoryTheory.Epi f]


@[simp]
theorem intrinsicClosure_nonempty : (intrinsicClosure 𝕜 s).Nonempty ↔ s.Nonempty

{𝕜 : Type u_1}
{V : Type u_2}
{P : Type u_5}
[Ring 𝕜]
[AddCommGroup V]
[Module 𝕜 V]
[TopologicalSpace P]
[AddTorsor V P]
{s : Set P}


theorem isInteger_mul {a b : S} (ha : IsInteger R a) (hb : IsInteger R b) : IsInteger R (a * b)

{R : Type u_1}
[CommSemiring R]
{S : Type u_2}
[CommSemiring S]
[Algebra R S]
{a b : S}
(ha : IsLocalization.IsInteger R a)
(hb : IsLocalization.IsInteger R b)


/-- The functor `C ⥤ Triangle C` which sends `X` to `contractibleTriangle X`. -/
@[simps]
def contractibleTriangleFunctor [HasZeroObject C] [HasZeroMorphisms C] : C ⥤ Triangle C

∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.Pretriangulated.contractibleTriangleFunctor C).map f).hom₃ = 0


@[simp]
theorem baseChange_zero : baseChange A (0 : M →ₗ[R] N) = 0

{R : Type u_1}
{A : Type u_2}
{M : Type u_4}
{N : Type u_5}
[CommSemiring R]
[Semiring A]
[Algebra R A]
[AddCommMonoid M]
[AddCommMonoid N]
[Module R M]
[Module R N]


theorem support_zpow_le (σ : Perm α) (n : ℤ) : (σ ^ n).support ≤ σ.support

{α : Type u_1}
[DecidableEq α]
[Fintype α]
(σ : Equiv.Perm α)
(n : ℤ)


theorem arccos_cos {x : ℝ} (hx₁ : 0 ≤ x) (hx₂ : x ≤ π) : arccos (cos x) = x


@[simp]
theorem mapPair_left : (mapPair f g).app ⟨left⟩ = f

{F G : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C}

(f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left })

(g : F.obj { as := CategoryTheory.Limits.WalkingPair.right } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.right })

(CategoryTheory.Limits.mapPair f g).app { as := CategoryTheory.Limits.WalkingPair.left } = f


theorem derivedSeries_of_derivedLength_succ (I : LieIdeal R L) (k : ℕ) :
    derivedLengthOfIdeal R L I = k + 1 ↔
      IsLieAbelian (derivedSeriesOfIdeal R L k I) ∧ derivedSeriesOfIdeal R L k I ≠ ⊥

(R : Type u)
(L : Type v)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(I : LieIdeal R L)
(k : ℕ)

LieAlgebra.derivedLengthOfIdeal R L I = k + 1 ↔
  IsLieAbelian ↥↑(LieAlgebra.derivedSeriesOfIdeal R L k I) ∧ LieAlgebra.derivedSeriesOfIdeal R L k I ≠ ⊥


/-- Every bitvector of length 0 is equal to `nil`, i.e., there is only one empty bitvector -/
theorem eq_nil (x : BitVec 0) : x = nil


@[to_additive]
lemma mem_units_of_val_mem_inv_val_mem (S : Submonoid M) {x : Mˣ} (h₁ : (x : M) ∈ S)
    (h₂ : ((x⁻¹ : Mˣ) : M) ∈ S) : x ∈ S.units

{M : Type u_1}
[AddMonoid M]
(S : AddSubmonoid M)
{x : AddUnits M}
(h₁ : ↑x ∈ S)
(h₂ : ↑(-x) ∈ S)


theorem toLp_norm_le [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E] :
    ‖(toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)‖ ≤ measureUnivNNReal μ ^ p.toReal⁻¹

{α : Type u_1}
{E : Type u_2}
{m0 : MeasurableSpace α}
{p : ℝ≥0∞}
(μ : MeasureTheory.Measure α)
[NormedAddCommGroup E]
[TopologicalSpace α]
[BorelSpace α]
[SecondCountableTopologyEither α E]
[MeasureTheory.IsFiniteMeasure μ]
{𝕜 : Type u_5}
[Fact (1 ≤ p)]
[NontriviallyNormedField 𝕜]
[NormedSpace 𝕜 E]

‖BoundedContinuousFunction.toLp p μ 𝕜‖ ≤ ↑(MeasureTheory.measureUnivNNReal μ) ^ p.toReal⁻¹


theorem preimage_inter_range {f : α → β} {s : Set β} : f ⁻¹' (s ∩ range f) = f ⁻¹' s

{α : Type u_1}
{β : Type u_2}
{f : α → β}
{s : Set β}


lemma IsNonZero.neg (h : α.IsNonZero) : (-α).IsNonZero

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


protected theorem le_trans : ∀ {x y z : Bool}, x ≤ y → y ≤ z → x ≤ z


@[simp]
theorem range_subtype (s : NonUnitalSubring R) : (NonUnitalSubringClass.subtype s).range = s

{R : Type u}
[NonUnitalNonAssocRing R]
(s : NonUnitalSubring R)


@[to_additive (attr := simp)]
lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x


theorem nonempty_of_not_subset (h : ¬s ⊆ t) : (s \ t).Nonempty


/-- **Fundamental theorem of calculus, part 2**. This version assumes that `f` is continuous on the
interval and is differentiable off a countable set `s`.

See also

* `intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le` for a version that only assumes right
differentiability of `f`;

* `MeasureTheory.integral_eq_of_hasDerivWithinAt_off_countable` for a version that works both
  for `a ≤ b` and `b ≤ a` at the expense of using unordered intervals instead of `Set.Icc`. -/
theorem integral_eq_of_hasDerivWithinAt_off_countable_of_le (f f' : ℝ → E) {a b : ℝ}
    (hle : a ≤ b) {s : Set ℝ} (hs : s.Countable) (Hc : ContinuousOn f (Icc a b))
    (Hd : ∀ x ∈ Ioo a b \ s, HasDerivAt f (f' x) x) (Hi : IntervalIntegrable f' volume a b) :
    ∫ x in a..b, f' x = f b - f a

(Hd : ∀ x ∈ Set.Ioo a b \ s, HasDerivAt f (f' x) x)

(Hi : IntervalIntegrable f' MeasureTheory.volume a b)


theorem toLex_mono : Monotone (@toLex (α ⊕ β))

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


private theorem aux {α β : Type*} [TopologicalSpace α] [TopologicalSpace β] (φ : α ≃ₜ β)
    (s : Set β) : (interior s).Nonempty ↔ (interior (φ ⁻¹' s)).Nonempty

{α : Type u_6}
{β : Type u_7}
[TopologicalSpace α]
[TopologicalSpace β]
(φ : α ≃ₜ β)
(s : Set β)

(interior s).Nonempty ↔ (interior (⇑φ ⁻¹' s)).Nonempty


/-- See `Equiv.Perm.inv_subtypePerm`-/
theorem subtypePerm_inv (f : Perm α) (hf) :
    f⁻¹.subtypePerm hf = (f.subtypePerm <| inv_aux.2 hf : Perm { x // p x })⁻¹

{α : Type u}
{p : α → Prop}
(f : Equiv.Perm α)
(hf : ∀ (x : α), p x ↔ p (f⁻¹ x))

f⁻¹.subtypePerm hf = (f.subtypePerm ⋯)⁻¹


theorem eval_basis_not_at_node (hi : i ∈ s) (hxi : x ≠ v i) :
    eval x (Lagrange.basis s v i) = eval x (nodal s v) * (nodalWeight s v i * (x - v i)⁻¹)

{F : Type u_1}
[Field F]
{ι : Type u_2}
[DecidableEq ι]
{s : Finset ι}
{v : ι → F}
{i : ι}
{x : F}
(hi : i ∈ s)
(hxi : x ≠ v i)

Polynomial.eval x (Lagrange.basis s v i) =
  Polynomial.eval x (Lagrange.nodal s v) * (Lagrange.nodalWeight s v i * (x - v i)⁻¹)


@[simp] theorem append_eq (x : BitVec w) (y : BitVec v)   : BitVec.append x y = x ++ y

{w v : Nat}
(x : BitVec w)
(y : BitVec v)


theorem _root_.Antitone.tendsto_setIntegral (hsm : ∀ i, MeasurableSet (s i)) (h_anti : Antitone s)
    (hfi : IntegrableOn f (s 0) μ) :
    Tendsto (fun i => ∫ a in s i, f a ∂μ) atTop (𝓝 (∫ a in ⋂ n, s n, f a ∂μ))

(hfi : MeasureTheory.IntegrableOn f (s 0) μ)

Filter.Tendsto (fun i => ∫ (a : α) in s i, f a ∂μ) Filter.atTop (nhds (∫ (a : α) in ⋂ n, s n, f a ∂μ))


theorem kroneckerMap_reindex (f : α → β → γ) (el : l ≃ l') (em : m ≃ m') (en : n ≃ n') (ep : p ≃ p')
    (M : Matrix l m α) (N : Matrix n p β) :
    kroneckerMap f (reindex el em M) (reindex en ep N) =
      reindex (el.prodCongr en) (em.prodCongr ep) (kroneckerMap f M N)

{α : Type u_2}
{β : Type u_4}
{γ : Type u_6}
{l : Type u_8}
{m : Type u_9}
{n : Type u_10}
{p : Type u_11}
{l' : Type u_14}
{m' : Type u_15}
{n' : Type u_16}
{p' : Type u_17}
(f : α → β → γ)
(el : l ≃ l')
(em : m ≃ m')
(en : n ≃ n')
(ep : p ≃ p')
(M : Matrix l m α)
(N : Matrix n p β)

Matrix.kroneckerMap f ((Matrix.reindex el em) M) ((Matrix.reindex en ep) N) =
  (Matrix.reindex (el.prodCongr en) (em.prodCongr ep)) (Matrix.kroneckerMap f M N)


theorem subset_comp_self {s : Set (α × α)} (h : idRel ⊆ s) : s ⊆ s ○ s

{α : Type ua}
{s : Set (α × α)}
(h : idRel ⊆ s)


@[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}
[Zero M]
{s : Set α}
(f : β → α)
{g : α → M}
{x : β}

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


/-- The order of the `↔` has been chosen so that `rw [btw_cyclic]` cycles to the right while
`rw [← btw_cyclic]` cycles to the left (thus following the prepended arrow). -/
theorem btw_cyclic {a b c : α} : btw a b c ↔ btw c a b

{α : Type u_1}
[CircularPreorder α]
{a b c : α}


@[to_additive (attr := simp)]
theorem edist_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a b c : M) :
    edist (a * b) (a * c) = edist b c

{M : Type u}
[Add M]
[PseudoEMetricSpace M]
[IsometricVAdd M M]
(a b c : M)


@[simp]
theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m

{p : ℕ+ → Prop}
[DecidablePred p]
(h : ∃ n, p n)
(n : ℕ+)


theorem HasSeparableContraction.dvd_degree' : ∃ m : ℕ, hf.degree * q ^ m = f.natDegree

(hf : Polynomial.HasSeparableContraction q f)


@[reassoc (attr := simp, elementwise)]
lemma π_moduleCatCyclesIso_hom :
    S.homologyπ ≫ S.moduleCatHomologyIso.hom =
      S.moduleCatCyclesIso.hom ≫ S.moduleCatHomologyπ

(S : CategoryTheory.ShortComplex (ModuleCat R))

CategoryTheory.CategoryStruct.comp S.homologyπ S.moduleCatHomologyIso.hom =
  CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.hom S.moduleCatHomologyπ


@[simp]
theorem rTensorBot_symm_apply (a : A) : A.rTensorBot.symm a = a ⊗ₜ[R] 1

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


@[simp]
theorem neg_mem_center [NonUnitalNonAssocRing M] {a : M} (ha : a ∈ Set.center M) :
    -a ∈ Set.center M

{M : Type u_1}
[NonUnitalNonAssocRing M]
{a : M}
(ha : a ∈ Set.center M)


theorem map_prod_of_subset_primeFactors [CommSemiring R] {f : ArithmeticFunction R}
    (h_mult : ArithmeticFunction.IsMultiplicative f) (l : ℕ)
    (t : Finset ℕ) (ht : t ⊆ l.primeFactors) :
    f (∏ a ∈ t, a) = ∏ a ∈ t, f a

{R : Type u_1}
[CommSemiring R]
{f : ArithmeticFunction R}
(h_mult : f.IsMultiplicative)
(l : ℕ)
(t : Finset ℕ)
(ht : t ⊆ l.primeFactors)


/-- A function `f` continuous on a compact set `K` is integrable on this set with respect to any
locally finite measure. -/
theorem ContinuousOn.integrableOn_compact'
    (hK : IsCompact K) (h'K : MeasurableSet K) (hf : ContinuousOn f K) :
    IntegrableOn f K μ


@[to_additive]
theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
    (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g

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


/-- If `r` is a negative constant, `fun x ↦ f x / r` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
lemma tendsto_div_const_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ Tendsto f l atTop

{α : Type u_3}
{β : Type u_4}
[LinearOrderedField α]
{l : Filter β}
{f : β → α}
{r : α}
(hr : r < 0)

Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop


theorem Ico_subset_Icc_union_Ico : Ico a c ⊆ Icc a b ∪ Ico b c

{α : Type u_1}
[LinearOrder α]
{a b c : α}


protected theorem IsVonNBounded.add (hs : IsVonNBounded 𝕜 s) (ht : IsVonNBounded 𝕜 t) :
    IsVonNBounded 𝕜 (s + t)

{𝕜 : Type u_1}
{E : Type u_3}
[SeminormedRing 𝕜]
[AddZeroClass E]
[TopologicalSpace E]
[ContinuousAdd E]
[DistribSMul 𝕜 E]
{s t : Set E}
(hs : Bornology.IsVonNBounded 𝕜 s)
(ht : Bornology.IsVonNBounded 𝕜 t)


lemma measurable_compl : Measurable ((·ᶜ) : Set α → Set α)


/-- The definition of `cyclotomic n R` commutes with any ring homomorphism. -/
@[simp]
theorem map_cyclotomic (n : ℕ) {R S : Type*} [Ring R] [Ring S] (f : R →+* S) :
    map f (cyclotomic n R) = cyclotomic n S

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

Polynomial.map f (Polynomial.cyclotomic n R) = Polynomial.cyclotomic n S


theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0

{α : Type u_1}
(p : α → Bool)
(a : α)
(l : List α)

List.countP p (a :: l) = List.countP p l + if p a = true then 1 else 0


@[simp]
theorem mem_unop {x : R} {S : Subring Rᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S

{R : Type u_2}
[Ring R]
{x : R}
{S : Subring Rᵐᵒᵖ}


@[simp] lemma exp_one_pow (n : ℕ) : exp 1 ^ n = exp n


@[simp]
theorem coe_mulHom_mk (f : α → β) (h₁ h₂ h₃) :
    ((⟨⟨f, h₁⟩, h₂, h₃⟩ : α →ₙ+* β) : α →ₙ* β) = ⟨f, h₁⟩

(h₁ : ∀ (x y : α), f (x * y) = f x * f y)

(h₂ : { toFun := f, map_mul' := h₁ }.toFun 0 = 0)

(h₃ :
  ∀ (x y : α),
    { toFun := f, map_mul' := h₁ }.toFun (x + y) =
      { toFun := f, map_mul' := h₁ }.toFun x + { toFun := f, map_mul' := h₁ }.toFun y)

↑{ toFun := f, map_mul' := h₁, map_zero' := h₂, map_add' := h₃ } = { toFun := f, map_mul' := h₁ }


@[reassoc]
lemma D₂_totalShift₁XIso_hom (n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + x = n₀') (h₁ : n₁ + x = n₁') :
    ((shiftFunctor₁ C x).obj K).D₂ (up ℤ) n₀ n₁ ≫ (K.totalShift₁XIso x n₁ n₁' h₁).hom =
      x.negOnePow • ((K.totalShift₁XIso x n₀ n₀' h₀).hom ≫ K.D₂ (up ℤ) n₀' n₁')

(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ))

((HomologicalComplex₂.shiftFunctor₁ C x).obj K).D₂ (ComplexShape.up ℤ) n₀ n₁ ≫ (K.totalShift₁XIso x n₁ n₁' h₁).hom =
  x.negOnePow • (K.totalShift₁XIso x n₀ n₀' h₀).hom ≫ K.D₂ (ComplexShape.up ℤ) n₀' n₁'


/-- The map `E ↦ Gal(L/E)` is inclusion-reversing -/
theorem IntermediateField.fixingSubgroup.antimono {K L : Type*} [Field K] [Field L] [Algebra K L]
    {E1 E2 : IntermediateField K L} (h12 : E1 ≤ E2) : E2.fixingSubgroup ≤ E1.fixingSubgroup

{K : Type u_1}
{L : Type u_2}
[Field K]
[Field L]
[Algebra K L]
{E1 E2 : IntermediateField K L}
(h12 : E1 ≤ E2)


theorem Ioi_subset_Ici_self : Ioi a ⊆ Ici a

{α : Type u_2}
[Preorder α]
[LocallyFiniteOrderTop α]
{a : α}


theorem tendsto_iff_rtendsto (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ RTendsto (Function.graph f) l₁ l₂

{α : Type u}
{β : Type v}
(l₁ : Filter α)
(l₂ : Filter β)
(f : α → β)

Filter.Tendsto f l₁ l₂ ↔ Filter.RTendsto (Function.graph f) l₁ l₂


@[to_additive]
theorem isComplement'_def : IsComplement' H K ↔ IsComplement (H : Set G) (K : Set G)

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

H.IsComplement' K ↔ AddSubgroup.IsComplement ↑H ↑K


theorem continuousWithinAt_prod_of_discrete_right [DiscreteTopology β]
    {f : α × β → γ} {s : Set (α × β)} {x : α × β} :
    ContinuousWithinAt f s x ↔ ContinuousWithinAt (f ⟨·, x.2⟩) {a | (a, x.2) ∈ s} x.1

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
[DiscreteTopology β]
{f : α × β → γ}
{s : Set (α × β)}
{x : α × β}

ContinuousWithinAt f s x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1


@[simp (high)]
theorem IsPrime.vanishingIdeal_zeroLocus (P : Ideal (MvPolynomial σ k)) [h : P.IsPrime] :
    vanishingIdeal (zeroLocus P) = P

{k : Type u_1}
[Field k]
{σ : Type u_2}
[IsAlgClosed k]
[Finite σ]
(P : Ideal (MvPolynomial σ k))
[h : P.IsPrime]

MvPolynomial.vanishingIdeal (MvPolynomial.zeroLocus P) = P


{G : Type u_1}
{G' : Type u_2}
{P : Type u_3}
{P' : Type u_4}
[AddGroup G]
[AddGroup G']
[AddTorsor G P]
[AddTorsor G' P']
(v : G)
(v' : G')
(p : P)
(p' : P')


@[to_additive]
theorem gc_map_comap (f : F) : GaloisConnection (map f) (comap f)

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

GaloisConnection (AddSubmonoid.map f) (AddSubmonoid.comap f)


theorem not_mem_iff {r : R} {a : A} : r ∉ σ a ↔ IsUnit (↑ₐ r - a)

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

r ∉ spectrum R a ↔ IsUnit ((algebraMap R A) r - a)


@[simp]
theorem Basis.restrictScalars_apply (i : ι) : (b.restrictScalars R i : M) = b i

{ι : Type u_1}
(R : Type u_3)
{M : Type u_6}
{S : Type u_10}
[CommRing R]
[Ring S]
[Nontrivial S]
[AddCommGroup M]
[Algebra R S]
[Module S M]
[Module R M]
[IsScalarTower R S M]
[NoZeroSMulDivisors R S]
(b : Basis ι S M)
(i : ι)


@[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : S) : M) = 1

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


theorem smoothWithinAt_univ : SmoothWithinAt I I' f univ x ↔ SmoothAt I I' f x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{E' : Type u_5}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_6}
[TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7}
[TopologicalSpace M']
[ChartedSpace H' M']
{f : M → M'}
{x : M}

SmoothWithinAt I I' f Set.univ x ↔ SmoothAt I I' f x


theorem essSup_comp_le_essSup_map_measure (hf : AEMeasurable f μ) :
    essSup (g ∘ f) μ ≤ essSup g (Measure.map f μ)

{α : Type u_1}
{β : Type u_2}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
[CompleteLattice β]
{γ : Type u_3}
{mγ : MeasurableSpace γ}
{f : α → γ}
{g : γ → β}
(hf : AEMeasurable f μ)

essSup (g ∘ f) μ ≤ essSup g (MeasureTheory.Measure.map f μ)


protected theorem adapted (hf : Martingale f ℱ μ) : Adapted ℱ f

{Ω : Type u_1}
{E : Type u_2}
{ι : Type u_3}
[Preorder ι]
{m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[CompleteSpace E]
{f : ι → Ω → E}
{ℱ : MeasureTheory.Filtration ι m0}
(hf : MeasureTheory.Martingale f ℱ μ)


theorem fold_op_rel_iff_and {r : β → β → Prop} (hr : ∀ {x y z}, r x (op y z) ↔ r x y ∧ r x z)
    {c : β} : r c (s.fold op b f) ↔ r c b ∧ ∀ x ∈ s, r c (f x)

{op : β → β → β}

(hr : ∀ {x y z : β}, r x (op y z) ↔ r x y ∧ r x z)

r c (Finset.fold op b f s) ↔ r c b ∧ ∀ x ∈ s, r c (f x)


/-- `Fin.castAdd` as an `Embedding`, `castAddEmb m i` embeds `i : Fin n` in `Fin (n+m)`.
See also `Fin.natAddEmb` and `Fin.addNatEmb`. -/
@[simps! apply]
def castAddEmb (m) : Fin n ↪ Fin (n + m)


@[ext]
theorem ext {x y : Class.{u}} : (∀ z : ZFSet.{u}, x z ↔ y z) → x = y


lemma quotient_obj_mem_subcategoryAcyclic_iff_exactAt (K : CochainComplex C ℤ) :
    (subcategoryAcyclic C).P ((quotient _ _).obj K) ↔ ∀ (n : ℤ), K.ExactAt n

{C : Type u}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.Abelian C]
(K : CochainComplex C ℤ)

(HomotopyCategory.subcategoryAcyclic C).P ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj K) ↔
  ∀ (n : ℤ), HomologicalComplex.ExactAt K n


theorem adj_of_mem_incidenceSet (h : a ≠ b) (ha : e ∈ G.incidenceSet a)
    (hb : e ∈ G.incidenceSet b) : G.Adj a b

{V : Type u}
(G : SimpleGraph V)
{a b : V}
{e : Sym2 V}
(h : a ≠ b)
(ha : e ∈ G.incidenceSet a)
(hb : e ∈ G.incidenceSet b)


@[simp] theorem comul_eq_diag (A : Comon_ C) : A.comul = diag A.X

A.comul = CategoryTheory.Limits.diag A.X


theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b


@[continuity]
theorem trans_continuous_family {ι : Type*} [TopologicalSpace ι]
    {a b c : ι → X} (γ₁ : ∀ t : ι, Path (a t) (b t)) (h₁ : Continuous ↿γ₁)
    (γ₂ : ∀ t : ι, Path (b t) (c t)) (h₂ : Continuous ↿γ₂) :
    Continuous ↿fun t => (γ₁ t).trans (γ₂ t)

{X : Type u_1}
[TopologicalSpace X]
{ι : Type u_4}
[TopologicalSpace ι]
{a b c : ι → X}
(γ₁ : (t : ι) → Path (a t) (b t))
(h₁ : Continuous ↿γ₁)
(γ₂ : (t : ι) → Path (b t) (c t))
(h₂ : Continuous ↿γ₂)


theorem mul_sub_algebraMap_commutes [Ring A] [Algebra R A] (x : A) (r : R) :
    x * (x - algebraMap R A r) = (x - algebraMap R A r) * x

{R : Type u}
{A : Type w}
[CommSemiring R]
[Ring A]
[Algebra R A]
(x : A)
(r : R)

x * (x - (algebraMap R A) r) = (x - (algebraMap R A) r) * x


theorem fromRel_irreflexive {sym : Symmetric r} :
    Irreflexive r ↔ ∀ {z}, z ∈ fromRel sym → ¬IsDiag z

{α : Type u_1}
{r : α → α → Prop}
{sym : Symmetric r}

Irreflexive r ↔ ∀ {z : Sym2 α}, z ∈ Sym2.fromRel sym → ¬z.IsDiag


@[simp] theorem replace_replicate_self [LawfulBEq α] {a : α} (h : 0 < n) :
    (replicate n a).replace a b = b :: replicate (n - 1) a

{α : Type u_1}
[BEq α]
{n : Nat}
{b : α}
[LawfulBEq α]
{a : α}
(h : 0 < n)

(List.replicate n a).replace a b = b :: List.replicate (n - 1) a


theorem mulVec_vecMul [Fintype n] [Fintype o] (A : Matrix m n α) (B : Matrix o n α) (x : o → α) :
    A *ᵥ (x ᵥ* B) = (A * Bᵀ) *ᵥ x

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


lemma map_equiv_traceDual [NoZeroSMulDivisors A B] (I : Submodule B (FractionRing B)) :
    (traceDual A (FractionRing A) I).map (FractionRing.algEquiv B L) =
      traceDual A K (I.map (FractionRing.algEquiv B L))

(A : Type u_1)
(K : Type u_2)
{L : Type u}
{B : Type u_3}
[CommRing A]
[Field K]
[CommRing B]
[Field L]
[Algebra A K]
[Algebra B L]
[Algebra A B]
[Algebra K L]
[Algebra A L]
[IsScalarTower A K L]
[IsScalarTower A B L]
[IsDomain A]
[IsFractionRing A K]
[IsFractionRing B L]
[IsDomain B]
[NoZeroSMulDivisors A B]
(I : Submodule B (FractionRing B))

Submodule.map (FractionRing.algEquiv B L) (Submodule.traceDual A (FractionRing A) I) =
  Submodule.traceDual A K (Submodule.map (FractionRing.algEquiv B L) I)


@[simp] lemma coe_equivNatSum_apply_apply (s : Sym α n) (a : α) :
    (equivNatSum α n s : α →₀ ℕ) a = (s : Multiset α).count a

(α : Type u_1)
[DecidableEq α]
(n : ℕ)
(s : Sym α n)
(a : α)

↑((Sym.equivNatSum α n) s) a = Multiset.count a ↑s


lemma div_ofReal (z : ℂ) (x : ℝ) : z / x = ⟨z.re / x, z.im / x⟩

z / ↑x = { re := z.re / x, im := z.im / x }


/-- If a group satisfies the universal property of a free group with respect to a given type, then
it is free. Here, the universal property is expressed as in `IsFreeGroup.lift` and its
properties. -/
lemma ofLift {G : Type u} [Group G] (X : Type u) (of : X → G)
    (lift : ∀ {H : Type u} [Group H], (X → H) ≃ (G →* H))
    (lift_of : ∀ {H : Type u} [Group H], ∀ (f : X → H) (a), lift f (of a) = f a) :
    IsFreeGroup G

(lift : {H : Type u} → [inst : Group H] → (X → H) ≃ (G →* H))

(lift_of : ∀ {H : Type u} [inst : Group H] (f : X → H) (a : X), (lift f) (of a) = f a)


lemma LSeriesSummable.abscissaOfAbsConv_le {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    abscissaOfAbsConv f ≤ s.re


@[to_additive (attr := to_additive) (reorder := 6 7) smul_comp]
theorem pow_comp [Pow γ α] (x : β → γ) (a : α) (y : I → β) : (x ^ a) ∘ y = x ∘ y ^ a

{I : Type u}
{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[SMul α γ]
(a : α)
(x : β → γ)
(y : I → β)


theorem nhds_nhdsAdjoint_same (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) a = pure a ⊔ f


lemma toKaehler_surjective : Function.Surjective P.toKaehler

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
{P : Algebra.Generators R S}


theorem core_inter (s t : Set β) : r.core (s ∩ t) = r.core s ∩ r.core t

{α : Type u_1}
{β : Type u_2}
(r : Rel α β)
(s t : Set β)


theorem Sublist.antisymm (s₁ : l₁ <+ l₂) (s₂ : l₂ <+ l₁) : l₁ = l₂

{α : Type u}
{l₁ l₂ : List α}
(s₁ : l₁.Sublist l₂)
(s₂ : l₂.Sublist l₁)


@[ext] lemma ext ⦃f g : α →*₀ β⦄ (h : ∀ x, f x = g x) : f = g

{α : Type u_2}
{β : Type u_3}
[MulZeroOneClass α]
[MulZeroOneClass β]
⦃f g : α →*₀ β⦄
(h : ∀ (x : α), f x = g x)


theorem map_eq_zero_iff {x : M} : e x = 0 ↔ x = 0

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


lemma c_relation : 1728 * W.Δ = W.c₄ ^ 3 - W.c₆ ^ 2

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


/-- The preimage of a set `s` under a linear equiv `f` has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. -/
@[simp]
theorem addHaar_preimage_linearEquiv (f : E ≃ₗ[ℝ] E) (s : Set E) :
    μ (f ⁻¹' s) = ENNReal.ofReal |LinearMap.det (f.symm : E →ₗ[ℝ] E)| * μ s

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[MeasurableSpace E]
[BorelSpace E]
[FiniteDimensional ℝ E]
(μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure]
(f : E ≃ₗ[ℝ] E)
(s : Set E)

μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑f.symm| * μ s


lemma CFC.eq_one_of_spectrum_subset_one (h_spec : spectrum R a ⊆ {1}) (ha : p a := by cfc_tac) :
    a = 1

{R : Type u_1}
{A : Type u_2}
{p : A → Prop}
[CommSemiring R]
[StarRing R]
[MetricSpace R]
[TopologicalSemiring R]
[ContinuousStar R]
[TopologicalSpace A]
[Ring A]
[StarRing A]
[Algebra R A]
[ContinuousFunctionalCalculus R p]
(a : A)
(h_spec : spectrum R a ⊆ {1})
(ha : p a := by cfc_tac)


theorem AEEqFun.eLpNorm_compMeasurePreserving {ν : MeasureTheory.Measure β} (g : β →ₘ[ν] E)
    (hf : MeasurePreserving f μ ν) :
    eLpNorm (g.compMeasurePreserving f hf) p μ = eLpNorm g p ν

(hf : MeasureTheory.MeasurePreserving f μ ν)

MeasureTheory.eLpNorm (↑(g.compMeasurePreserving f hf)) p μ = MeasureTheory.eLpNorm (↑g) p ν


theorem stoppedValue_sub_eq_sum [AddCommGroup β] (hle : τ ≤ π) :
    stoppedValue u π - stoppedValue u τ = fun ω =>
      (∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω

{Ω : Type u_1}
{β : Type u_2}
{u : ℕ → Ω → β}
{τ π : Ω → ℕ}
[AddCommGroup β]
(hle : τ ≤ π)

MeasureTheory.stoppedValue u π - MeasureTheory.stoppedValue u τ = fun ω =>
  (∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω


theorem iIndep.indep {m : ι → MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α}
    (h_indep : iIndep m κ μ) {i j : ι} (hij : i ≠ j) : Indep (m i) (m j) κ μ

(h_indep : ProbabilityTheory.Kernel.iIndep m κ μ)

ProbabilityTheory.Kernel.Indep (m i) (m j) κ μ


theorem comp_toLinearMap_symm_eq (f : M₂ →ₛₗ[σ₂₃] M₃) (g : M₁ →ₛₗ[σ₁₃] M₃) :
    g.comp e₁₂.symm.toLinearMap = f ↔ g = f.comp e₁₂.toLinearMap

{R₁ : Type u_2}
{R₂ : Type u_3}
{R₃ : Type u_4}
{M₁ : Type u_9}
{M₂ : Type u_10}
{M₃ : Type u_11}
[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₃}
{σ₂₁ : R₂ →+* R₁}
[RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
{re₁₂ : RingHomInvPair σ₁₂ σ₂₁}
{re₂₁ : RingHomInvPair σ₂₁ σ₁₂}
{e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂}
[RingHomCompTriple σ₂₁ σ₁₃ σ₂₃]
(f : M₂ →ₛₗ[σ₂₃] M₃)
(g : M₁ →ₛₗ[σ₁₃] M₃)


/-- Reinterpret `G ≃+ H` as `Multiplicative G ≃* Multiplicative H`. -/
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H)

{G : Type u_1}
{H : Type u_2}
[AddZeroClass G]
[AddZeroClass H]
(f : G ≃+ H)
(a : Multiplicative H)

(AddEquiv.toMultiplicative f).symm a = (AddMonoidHom.toMultiplicative f.symm.toAddMonoidHom) a


theorem head!_le_of_lt [Preorder α] [Inhabited α] (l l' : List α) (h : l' < l) (hl' : l' ≠ []) :
    l'.head! ≤ l.head!

{α : Type u}
[Preorder α]
[Inhabited α]
(l l' : List α)
(h : l' < l)
(hl' : l' ≠ [])


@[simp]
theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅

{α : Type u_2}
[DecidableEq α]
[Fintype α]


theorem BlankExtends.above_of_le {Γ} [Inhabited Γ] {l l₁ l₂ : List Γ} :
    BlankExtends l₁ l → BlankExtends l₂ l → l₁.length ≤ l₂.length → BlankExtends l₁ l₂

{Γ : Type u_1}
[Inhabited Γ]
{l l₁ l₂ : List Γ}

Turing.BlankExtends l₁ l → Turing.BlankExtends l₂ l → l₁.length ≤ l₂.length → Turing.BlankExtends l₁ l₂


theorem IndepFun.comp {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    {mγ : MeasurableSpace γ} {mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'}
    (hfg : IndepFun f g κ μ) (hφ : Measurable φ) (hψ : Measurable ψ) :
    IndepFun (φ ∘ f) (ψ ∘ g) κ μ

(hfg : ProbabilityTheory.Kernel.IndepFun f g κ μ)

ProbabilityTheory.Kernel.IndepFun (φ ∘ f) (ψ ∘ g) κ μ


/-- `Nat.cast : ℕ → α` as an `OrderEmbedding` -/
@[simps! (config := .asFn)]
def castOrderEmbedding : ℕ ↪o α

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


theorem dvd_count_pow [Nontrivial α] [DecidableEq (Associates α)] {a : Associates α} (ha : a ≠ 0)
    {p : Associates α} (hp : Irreducible p) (k : ℕ) : k ∣ count p (a ^ k).factors

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


@[simp]
theorem comp_assoc (f : SupHom γ δ) (g : SupHom β γ) (h : SupHom α β) :
    (f.comp g).comp h = f.comp (g.comp h)

{α : Type u_3}
{β : Type u_4}
{γ : Type u_5}
{δ : Type u_6}
[Sup α]
[Sup β]
[Sup γ]
[Sup δ]
(f : SupHom γ δ)
(g : SupHom β γ)
(h : SupHom α β)


@[simp]
theorem _root_.CategoryTheory.zero_map [HasZeroObject D] [HasZeroMorphisms D] {X Y : C}
    (f : X ⟶ Y) : (0 : C ⥤ D).map f = 0

(CategoryTheory.Functor.toPrefunctor 0).map f = 0


@[simp]
lemma comap_id' (κ : Kernel α β) : comap κ (fun a ↦ a) measurable_id = κ

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


theorem symm [IsSymm α r] {a b : α} : a ≺ b → b ≺ a

{α : Sort u}
{r : α → α → Prop}
[IsSymm α r]
{a b : α}


theorem even.lift_ι (f : EvenHom Q A) (m₁ m₂ : M) :
    even.lift Q f ((even.ι Q).bilin m₁ m₂) = f.bilin m₁ m₂

{R : Type uR}
{M : Type uM}
[CommRing R]
[AddCommGroup M]
[Module R M]
(Q : QuadraticForm R M)
{A : Type uA}
[Ring A]
[Algebra R A]
(f : CliffordAlgebra.EvenHom Q A)
(m₁ m₂ : M)

((CliffordAlgebra.even.lift Q) f) (((CliffordAlgebra.even.ι Q).bilin m₁) m₂) = (f.bilin m₁) m₂


@[simp] lemma op_inv_braiding (X Y : C) : (β_ X Y).inv.op = (β_ (op Y) (op X)).inv

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

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


theorem Finite.ofBijective [Finite α] {f : α → β} (h : Bijective f) : Finite β

{α : Sort u_1}
{β : Sort u_2}
[Finite α]
{f : α → β}
(h : Function.Bijective f)


lemma closedEmbedding_starAlgHom {a : A} {φ : C(spectrum S a, S) →⋆ₐ[S] A}
    (hφ : ClosedEmbedding φ) {f : C(S, R)} (h : SpectrumRestricts a f)
    (halg : UniformEmbedding (algebraMap R S)) [CompactSpace (spectrum S a)] :
    ClosedEmbedding (h.starAlgHom φ)

(halg : UniformEmbedding ⇑(algebraMap R S))

ClosedEmbedding ⇑(SpectrumRestricts.starAlgHom φ h)


theorem diam_range : Metric.diam (range f) = Metric.diam (univ : Set E)

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

Metric.diam (Set.range ⇑f) = Metric.diam Set.univ


/-- If `f x ≤ g x` in a neighbourhood of `x`, then for `y` sufficiently close to `x` we have
`f x ≤ g x` in a neighbourhood of `y`. -/
theorem Filter.EventuallyLE.eventuallyLE_nhds [LE α] {f g : X → α} (h : f ≤ᶠ[𝓝 x] g) :
    ∀ᶠ y in 𝓝 x, f ≤ᶠ[𝓝 y] g

{X : Type u}
{α : Type u_1}
{x : X}
[TopologicalSpace X]
[LE α]
{f g : X → α}
(h : f ≤ᶠ[𝓝 x] g)


theorem apply_order_ne_zero (hp : p ≠ 0) : p p.order ≠ 0

{𝕜 : Type u}
{E : Type v}
{F : Type w}
[Ring 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[TopologicalSpace E]
[TopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E]
[AddCommGroup F]
[Module 𝕜 F]
[TopologicalSpace F]
[TopologicalAddGroup F]
[ContinuousConstSMul 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F}
(hp : p ≠ 0)


theorem prod_const' (ι : Type u) (a : Cardinal.{u}) : (prod fun _ : ι => a) = a ^ #ι

(Cardinal.prod fun x => a) = a ^ Cardinal.mk ι


/-- A point in a metric space belongs to the (open) `δ`-thickening of a subset `E` if and only if
it is at distance less than `δ` from some point of `E`. -/
theorem mem_thickening_iff {E : Set X} {x : X} : x ∈ thickening δ E ↔ ∃ z ∈ E, dist x z < δ

{δ : ℝ}
{X : Type u}
[PseudoMetricSpace X]
{E : Set X}
{x : X}

x ∈ Metric.thickening δ E ↔ ∃ z ∈ E, dist x z < δ


theorem get_mk_zero : ∀ {l : List α} (h : 0 < l.length), l.get ⟨0, h⟩ = l.head (length_pos.mp h)

{α : Type u_1}
{l : List α}
(h : 0 < l.length)


theorem Finite.encard_lt_encard (ht : t.Finite) (h : s ⊂ t) : s.encard < t.encard

{α : Type u_1}
{s t : Set α}
(ht : t.Finite)
(h : s ⊂ t)


lemma measurableSet_partitionFiltration_of_mem (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) {s : Set α}
    (hs : s ∈ memPartition t n) :
    MeasurableSet[partitionFiltration ht n] s

{α : Type u_1}
[m : MeasurableSpace α]
{t : ℕ → Set α}
(ht : ∀ (n : ℕ), MeasurableSet (t n))
(n : ℕ)
{s : Set α}
(hs : s ∈ memPartition t n)


theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n

SetTheory.PGame.powHalf (n + 1) + SetTheory.PGame.powHalf (n + 1) ≈ SetTheory.PGame.powHalf n


theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a

{α : Type u_1}
{σ : Type u_3}
[PartialOrder α]
(f : σ → α)
(pt : σ)
(inf : σ → σ → σ)
(h₁ : ∀ (a b : σ), f (inf a b) ≤ f a)
(h₂ : ∀ (a b : σ), f (inf a b) ≤ f b)
(a : σ)

{ f := f, pt := pt, inf := inf, inf_le_left := h₁, inf_le_right := h₂ }.f a = f a


theorem eq_symm_apply {x y} : y = e.symm x ↔ e y = x

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


theorem lt_def : p < q ↔ (p : E → ℝ) < q

{E : Type u_4}
[AddGroup E]
{p q : NonarchAddGroupSeminorm E}


theorem normSq_exp (q : ℍ[ℝ]) : normSq (exp ℝ q) = exp ℝ q.re ^ 2

Quaternion.normSq (NormedSpace.exp ℝ q) = NormedSpace.exp ℝ q.re ^ 2


/-- The image of `R` in `S` is linearly disjoint with any other submodules. -/
theorem one_right : M.LinearDisjoint (1 : Submodule R S)

{R : Type u}
{S : Type v}
[CommSemiring R]
[Semiring S]
[Algebra R S]
(M : Submodule R S)


@[to_additive mem_closedBall_iff_norm']
theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r

{E : Type u_6}
[SeminormedGroup E]
{a b : E}
{r : ℝ}


@[to_additive (attr := simp)]
theorem empty_mul (s : Finset α) : ∅ * s = ∅

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


@[to_additive]
theorem mclosure_preimage_le (f : M →ₙ* N) (s : Set N) : closure (f ⁻¹' s) ≤ (closure s).comap f

{M : Type u_1}
{N : Type u_2}
[Add M]
[Add N]
(f : AddHom M N)
(s : Set N)

AddSubsemigroup.closure (⇑f ⁻¹' s) ≤ AddSubsemigroup.comap f (AddSubsemigroup.closure s)


/-- When `E` is a topological module over a topological ring `R`, the class `SeparatingDual R E`
registers that continuous linear forms on `E` separate points of `E`. -/
@[mk_iff separatingDual_def]
class SeparatingDual (R V : Type*) [Ring R] [AddCommGroup V] [TopologicalSpace V]
    [TopologicalSpace R] [Module R V] : Prop :=
  /-- Any nonzero vector can be mapped by a continuous linear map to a nonzero scalar. -/
  exists_ne_zero' : ∀ (x : V), x ≠ 0 → ∃ f : V →L[R] R, f x ≠ 0

{R : Type u_1}
{V : Type u_2}
[Ring R]
[AddCommGroup V]
[TopologicalSpace V]
[TopologicalSpace R]
[Module R V]
[self : SeparatingDual R V]
(x : V)


theorem induced_id [t : TopologicalSpace α] : t.induced id = t


@[to_additive]
theorem div_eq_of_eq_mul' {a b c : G} (h : a = b * c) : a / b = c

{G : Type u_3}
[CommGroup G]
{a b c : G}
(h : a = b * c)


theorem eq_of_not_mem_of_mem_insert : b ∈ insert a s → b ∉ s → b = a


theorem not_mem_neLocus {f g : Π₀ a, N a} {a : α} : a ∉ f.neLocus g ↔ f a = g a

{α : Type u_1}
{N : α → Type u_2}
[DecidableEq α]
[(a : α) → DecidableEq (N a)]
[(a : α) → Zero (N a)]
{f g : Π₀ (a : α), N a}
{a : α}


/-- The equivalence of functor categories induced by `op` and `unop`.
-/
@[simps]
def opUnopEquiv : (C ⥤ D)ᵒᵖ ≌ Cᵒᵖ ⥤ Dᵒᵖ

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

(CategoryTheory.Functor.opUnopEquiv C D).counitIso = CategoryTheory.NatIso.ofComponents (fun F => F.unopOpIso) ⋯


theorem isBounded_sup [IsTrans α r] [IsDirected α r] :
    IsBounded r f → IsBounded r g → IsBounded r (f ⊔ g)

{α : Type u_1}
{r : α → α → Prop}
{f g : Filter α}
[IsTrans α r]
[IsDirected α r]

Filter.IsBounded r f → Filter.IsBounded r g → Filter.IsBounded r (f ⊔ g)


theorem map.isMaximal (hf : Function.Bijective f) {I : Ideal R} (H : IsMaximal I) :
    IsMaximal (map f I)

{R : Type u}
{S : Type v}
{F : Type u_1}
[Ring R]
[Ring S]
[FunLike F R S]
[RingHomClass F R S]
(f : F)
(hf : Function.Bijective ⇑f)
{I : Ideal R}
(H : I.IsMaximal)


@[simp]
theorem compression_self (u : α) (s : Finset α) : 𝓒 u u s = s

{α : Type u_1}
[GeneralizedBooleanAlgebra α]
[DecidableRel Disjoint]
[DecidableRel fun x x_1 => x ≤ x_1]
[DecidableEq α]
(u : α)
(s : Finset α)


theorem inclusion_injective {S T : Subalgebra R A} (h : S ≤ T) : Function.Injective (inclusion h)

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


theorem elim_apply {f : γ → α → β} {x : α → β} {i : Option γ} {y : α} :
    i.elim x f y = i.elim (x y) fun j => f j y

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{f : γ → α → β}
{x : α → β}
{i : Option γ}
{y : α}


theorem smul_univ₀ {s : Set α} (hs : ¬s ⊆ 0) : s • (univ : Set β) = univ

{α : Type u_2}
{β : Type u_3}
[GroupWithZero α]
[MulAction α β]
{s : Set α}
(hs : ¬s ⊆ 0)


/-- Affine homeomorphism `(r • · +ᵥ c)` between a normed space and an add torsor over this space,
interpreted as a `PartialHomeomorph` between `Metric.ball 0 1` and `Metric.ball c r`. -/
@[simps!]
def unitBallBall (c : P) (r : ℝ) (hr : 0 < r) : PartialHomeomorph E P

{E : Type u_1}
[SeminormedAddCommGroup E]
[NormedSpace ℝ E]
{P : Type u_2}
[PseudoMetricSpace P]
[NormedAddTorsor E P]
(c : P)
(r : ℝ)
(hr : 0 < r)

(PartialHomeomorph.unitBallBall c r hr).source = Metric.ball 0 1


theorem sInf_le_iff : sInf s ≤ a ↔ ∀ b ∈ lowerBounds s, b ≤ a

{α : Type u_1}
[CompleteSemilatticeInf α]
{s : Set α}
{a : α}