/-- When both `S.f` and `S.g` are zero, the middle object `S.X₂` gives a homology data on S -/
@[simps]
noncomputable def ofZeros (hf : S.f = 0) (hg : S.g = 0) :
    S.HomologyData

(CategoryTheory.ShortComplex.HomologyData.ofZeros S hf hg).left =
  CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg


theorem mem_minimals_iff : x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, y ∈ s → r y x → x = y

{α : Type u_1}
{r : α → α → Prop}
{s : Set α}
{x : α}
[IsAntisymm α r]

x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y ∈ s → r y x → x = y


/-- A useful restatement using `segment`: `x` is an extreme point iff the only (closed) segments
that contain it are those with `x` as one of their endpoints. -/
theorem mem_extremePoints_iff_forall_segment : x ∈ A.extremePoints 𝕜 ↔
    x ∈ A ∧ ∀ᵉ (x₁ ∈ A) (x₂ ∈ A), x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x

{𝕜 : Type u_1}
{E : Type u_2}
[LinearOrderedRing 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[DenselyOrdered 𝕜]
[NoZeroSMulDivisors 𝕜 E]
{A : Set E}
{x : E}

x ∈ Set.extremePoints 𝕜 A ↔ x ∈ A ∧ ∀ x₁ ∈ A, ∀ x₂ ∈ A, x ∈ segment 𝕜 x₁ x₂ → x₁ = x ∨ x₂ = x


@[simp]
lemma ofTensorProductEquivOfFiniteNoetherian_symm_of [Module.Finite R M] (x : M) :
    (ofTensorProductEquivOfFiniteNoetherian I M).symm ((of I M) x) = 1 ⊗ₜ x

{R : Type u}
[CommRing R]
(I : Ideal R)
(M : Type u)
[AddCommGroup M]
[Module R M]
[IsNoetherianRing R]
[Module.Finite R M]
(x : M)

(AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I M).symm ((AdicCompletion.of I M) x) = 1 ⊗ₜ[R] x


/-- Euclid's lemma: if `a ∣ b * c` and `gcd a b = 1` then `a ∣ c`.
Compare with `IsCoprime.dvd_of_dvd_mul_right` and
`UniqueFactorizationMonoid.dvd_of_dvd_mul_right_of_no_prime_factors` -/
theorem dvd_of_dvd_mul_right_of_gcd_one {a b c : ℤ} (habc : a ∣ b * c) (hab : gcd a b = 1) :
    a ∣ c

{a b c : ℤ}
(habc : a ∣ b * c)
(hab : a.gcd b = 1)


@[simp]
theorem nontrivial_coe_nodup_iff {l : List α} (hl : l.Nodup) :
    Nontrivial (l : Cycle α) ↔ 2 ≤ l.length

{α : Type u_1}
{l : List α}
(hl : l.Nodup)


/-- The closure of a preconnected set is preconnected as well. -/
protected theorem IsPreconnected.closure {s : Set α} (H : IsPreconnected s) :
    IsPreconnected (closure s)

{α : Type u}
[TopologicalSpace α]
{s : Set α}
(H : IsPreconnected s)


@[simp] lemma isUnit_C_add_X_mul_iff :
    IsUnit (C r + X * P) ↔ IsUnit r ∧ IsNilpotent P

{R : Type u_1}
{r : R}
[CommRing R]
{P : Polynomial R}

IsUnit (Polynomial.C r + Polynomial.X * P) ↔ IsUnit r ∧ IsNilpotent P


@[simp]
theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a') :
    (F.sum G).map f = F.map f

{A : Type u₁}
[CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₁}
[CategoryTheory.Category.{v₁, u₁} B]
{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₁}
[CategoryTheory.Category.{v₁, u₁} D]
(F : CategoryTheory.Functor A B)
(G : CategoryTheory.Functor C D)
{a a' : A}
(f : Sum.inl a ⟶ Sum.inl a')


@[simp]
theorem toIocMod_add_toIocDiv_zsmul (a b : α) : toIocMod hp a b + toIocDiv hp a b • p = b

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


@[simp]
theorem of_nat_toZNum (n : ℕ) : Num.toZNum n = n


protected theorem seqRight_eq [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) : x *> y = const α id <$> x <*> y

{m : Type u_1 → Type u_2}
{ε α β : Type u_1}
[Monad m]
[LawfulMonad m]
(x : ExceptT ε m α)
(y : ExceptT ε m β)

(SeqRight.seqRight x fun x => y) = Seq.seq (Function.const α id <$> x) fun x => y


theorem EquitableOn.le_add_one (h : EquitableOn (s : Set α) f) (ha : a ∈ s) :
    f a ≤ (∑ i ∈ s, f i) / s.card + 1

{α : Type u_1}
{s : Finset α}
{f : α → ℕ}
{a : α}
(h : (↑s).EquitableOn f)
(ha : a ∈ s)


/-- On a topological group, `𝓝 : G → Filter G` can be promoted to a `MulHom`. -/
@[to_additive (attr := simps)
  "On an additive topological group, `𝓝 : G → Filter G` can be promoted to an `AddHom`."]
def nhdsMulHom : G →ₙ* Filter G

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


theorem smulc_apply [Zero β] [TopologicalSpace γ] [SMulZeroClass γ β] [ContinuousSMul γ β]
    {F : Type*} [FunLike F α γ] [ContinuousMapClass F α γ] (f : F) (g : C_c(α, β)) (x : α) :
    (f • g) x = f x • g x

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[TopologicalSpace α]
[TopologicalSpace β]
[Zero β]
[TopologicalSpace γ]
[SMulZeroClass γ β]
[ContinuousSMul γ β]
{F : Type u_5}
[FunLike F α γ]
[ContinuousMapClass F α γ]
(f : F)
(g : α →C_c β)
(x : α)


lemma dirac_unit_compProd_const (μ : Measure β) [IsFiniteMeasure μ] :
    Measure.dirac () ⊗ₘ Kernel.const Unit μ = μ.map (Prod.mk ())

{β : Type u_2}
{mβ : MeasurableSpace β}
(μ : MeasureTheory.Measure β)
[MeasureTheory.IsFiniteMeasure μ]

MeasureTheory.Measure.dirac () ⊗ₘ ProbabilityTheory.Kernel.const Unit μ = MeasureTheory.Measure.map (Prod.mk ()) μ


@[simp]
theorem conjTranspose_zpow [StarRing R] (A : M) : ∀ n : ℤ, (A ^ n)ᴴ = Aᴴ ^ n

{n' : Type u_1}
[DecidableEq n']
[Fintype n']
{R : Type u_2}
[CommRing R]
[StarRing R]
(A : Matrix n' n' R)
(n : ℤ)


/-- If `legendreSym p a = -1`, then the only solution of `x^2 - a*y^2 = 0` in `ℤ/pℤ`
is the trivial one. -/
theorem eq_zero_mod_of_eq_neg_one {p : ℕ} [Fact p.Prime] {a : ℤ} (h : legendreSym p a = -1)
    {x y : ZMod p} (hxy : x ^ 2 - a * y ^ 2 = 0) : x = 0 ∧ y = 0

{p : ℕ}
[Fact (Nat.Prime p)]
{a : ℤ}
(h : legendreSym p a = -1)
{x y : ZMod p}
(hxy : x ^ 2 - ↑a * y ^ 2 = 0)


/-- If a free module is of finite rank, then the cardinality of any basis is equal to its
`finrank`. -/
theorem _root_.Module.mk_finrank_eq_card_basis [Module.Finite R M]
    {ι : Type w} (h : Basis ι R M) : (finrank R M : Cardinal.{w}) = #ι

{R : Type u}
{M : Type v}
[Ring R]
[AddCommGroup M]
[Module R M]
[StrongRankCondition R]
[Module.Finite R M]
{ι : Type w}
(h : Basis ι R M)


theorem natDegree_lt_natDegree {p q : R[X]} (hp : p ≠ 0) (hpq : p.degree < q.degree) :
    p.natDegree < q.natDegree

{R : Type u}
[Semiring R]
{p q : R[X]}
(hp : p ≠ 0)
(hpq : p.degree < q.degree)


theorem map_reindex (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : ⨂[R] i, s i) :
    map (fun i ↦ f (e.symm i)) (reindex R s e x) = reindex R t e (map f x)

{ι : Type u_1}
{ι₂ : Type u_2}
{R : Type u_4}
[CommSemiring R]
{s : ι → Type u_7}
[(i : ι) → AddCommMonoid (s i)]
[(i : ι) → Module R (s i)]
{t : ι → Type u_11}
[(i : ι) → AddCommMonoid (t i)]
[(i : ι) → Module R (t i)]
(f : (i : ι) → s i →ₗ[R] t i)
(e : ι ≃ ι₂)
(x : PiTensorProduct R fun i => s i)

(PiTensorProduct.map fun i => f (e.symm i)) ((PiTensorProduct.reindex R s e) x) =
  (PiTensorProduct.reindex R t e) ((PiTensorProduct.map f) x)


theorem some_union_some [Union α] (a b : α) : some a ∪ some b = some (a ∪ b)

Part.some a ∪ Part.some b = Part.some (a ∪ b)


/-- If a set is disjoint of its translates by infinitely many bounded vectors, then it has measure
zero. -/
theorem addHaar_eq_zero_of_disjoint_translates {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] (μ : Measure E)
    [IsAddHaarMeasure μ] {s : Set E} (u : ℕ → E) (hu : IsBounded (range u))
    (hs : Pairwise (Disjoint on fun n => {u n} + s)) (h's : MeasurableSet s) : μ s = 0

(hu : Bornology.IsBounded (Set.range u))


theorem lt_mul_of_one_lt_left [MulPosStrictMono α] (hb : 0 < b) (h : 1 < a) : b < a * b

{α : Type u_1}
{a b : α}
[MulOneClass α]
[Zero α]
[Preorder α]
[MulPosStrictMono α]
(hb : 0 < b)
(h : 1 < a)


/-- (Implementation Detail) The glue data associated to a disjoint union. -/
@[simps! J V U f t]
noncomputable
def disjointGlueData : Scheme.GlueData

(i j : (AlgebraicGeometry.disjointGlueData' f).J)

(AlgebraicGeometry.disjointGlueData f).f i j = (AlgebraicGeometry.disjointGlueData' f).f' i j


@[simp]
theorem coeSort_finsetBasisIndex [IsNoetherian K V] :
    (finsetBasisIndex K V : Type _) = Basis.ofVectorSpaceIndex K V

(K : Type u)
(V : Type v)
[DivisionRing K]
[AddCommGroup V]
[Module K V]
[IsNoetherian K V]

{ x // x ∈ IsNoetherian.finsetBasisIndex K V } = ↑(Basis.ofVectorSpaceIndex K V)


theorem cancel_mono (f : X ⟶ Y) [Mono f] {g h : Z ⟶ X} : g ≫ f = h ≫ f ↔ g = h

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{X Y Z : C}
(f : X ⟶ Y)
[CategoryTheory.Mono f]
{g h : Z ⟶ X}

CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f ↔ g = h


theorem HasFiniteFPowerSeriesOnBall.cPolynomialAt (hf : HasFiniteFPowerSeriesOnBall f p x n r) :
    CPolynomialAt 𝕜 f x


/-- If the codomain of a closed embedding is a normal space, then so is the domain. -/
protected theorem ClosedEmbedding.normalSpace [TopologicalSpace Y] [NormalSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : NormalSpace X

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


/-- The norm on a real normed space is convex on any convex set. See also `Seminorm.convexOn`
and `convexOn_univ_norm`. -/
theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm

{E : Type u_2}
[SeminormedAddCommGroup E]
[NormedSpace ℝ E]
{s : Set E}
(hs : Convex ℝ s)


@[to_additive]
protected theorem eq_inv_of_mul_eq_one_left {a : α} (h : ↑u * a = 1) : a = ↑u⁻¹

{α : Type u}
[AddMonoid α]
{u : AddUnits α}
{a : α}
(h : ↑u + a = 0)


lemma add_sub_cancel_right {a : EReal} {b : Real} : a + b - b = a


/-- Multiplying the second vector passed to `oangle` by a positive real does not change the
angle. -/
@[simp]
theorem oangle_smul_right_of_pos (x y : V) {r : ℝ} (hr : 0 < r) :
    o.oangle x (r • y) = o.oangle x y

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


@[simp] lemma wcovBy_insert (x : α) (s : Set α) : s ⩿ insert x s


@[simp] theorem nhdsSet_Iio : 𝓝ˢ (Iio a) = 𝓟 (Iio a)

{α : Type u_1}
[LinearOrder α]
[TopologicalSpace α]
[OrderClosedTopology α]
{a : α}


/-- A pair of continuous (semi)linear equivalences generates a (semi)linear equivalence between the
spaces of continuous (semi)linear maps. -/
@[simps]
def arrowCongrSL (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G) :
    (E →SL[σ₁₄] H) ≃SL[σ₄₃] F →SL[σ₂₃] G

{𝕜 : Type u_1}
{𝕜₂ : Type u_2}
{𝕜₃ : Type u_3}
{𝕜₄ : Type u_4}
{E : Type u_5}
{F : Type u_6}
{G : Type u_7}
{H : Type u_8}
[AddCommGroup E]
[AddCommGroup F]
[AddCommGroup G]
[AddCommGroup H]
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜₂]
[NontriviallyNormedField 𝕜₃]
[NontriviallyNormedField 𝕜₄]
[Module 𝕜 E]
[Module 𝕜₂ F]
[Module 𝕜₃ G]
[Module 𝕜₄ H]
[TopologicalSpace E]
[TopologicalSpace F]
[TopologicalSpace G]
[TopologicalSpace H]
[TopologicalAddGroup G]
[TopologicalAddGroup H]
[ContinuousConstSMul 𝕜₃ G]
[ContinuousConstSMul 𝕜₄ H]
{σ₁₂ : 𝕜 →+* 𝕜₂}
{σ₂₁ : 𝕜₂ →+* 𝕜}
{σ₂₃ : 𝕜₂ →+* 𝕜₃}
{σ₁₃ : 𝕜 →+* 𝕜₃}
{σ₃₄ : 𝕜₃ →+* 𝕜₄}
{σ₄₃ : 𝕜₄ →+* 𝕜₃}
{σ₂₄ : 𝕜₂ →+* 𝕜₄}
{σ₁₄ : 𝕜 →+* 𝕜₄}
[RingHomInvPair σ₁₂ σ₂₁]
[RingHomInvPair σ₂₁ σ₁₂]
[RingHomInvPair σ₃₄ σ₄₃]
[RingHomInvPair σ₄₃ σ₃₄]
[RingHomCompTriple σ₂₁ σ₁₄ σ₂₄]
[RingHomCompTriple σ₂₄ σ₄₃ σ₂₃]
[RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
[RingHomCompTriple σ₁₃ σ₃₄ σ₁₄]
[RingHomCompTriple σ₂₃ σ₃₄ σ₂₄]
[RingHomCompTriple σ₁₂ σ₂₄ σ₁₄]
[RingHomIsometric σ₁₂]
[RingHomIsometric σ₂₁]
(e₁₂ : E ≃SL[σ₁₂] F)
(e₄₃ : H ≃SL[σ₄₃] G)
(L : E →SL[σ₁₄] H)

(e₁₂.arrowCongrSL e₄₃) L = (↑e₄₃).comp (L.comp ↑e₁₂.symm)


theorem eq_bot_of_minimal (h : ∀ b, ¬b < a) : a = ⊥

{α : Type u}
[PartialOrder α]
[OrderBot α]
{a : α}
(h : ∀ (b : α), ¬b < a)


/-- A nonarchimedean norm on an additive group `G` is a function `f : G → ℝ` that preserves zero, is
nonarchimedean and such that `f (-x) = f x` and `f x = 0 → x = 0` for all `x`. -/
structure NonarchAddGroupNorm (G : Type*) [AddGroup G] extends NonarchAddGroupSeminorm G where
  /-- If the image under the norm is zero, then the argument is zero. -/
  protected eq_zero_of_map_eq_zero' : ∀ x, toFun x = 0 → x = 0

{G : Type u_7}
[AddGroup G]
(self : NonarchAddGroupNorm G)
(x : G)


/-- If `X` is a real random variable with Gaussian law with mean `μ` and variance `v`, then `c * X`
has Gaussian law with mean `c * μ` and variance `c^2 * v`. -/
lemma gaussianReal_const_mul {X : Ω → ℝ} (hX : Measure.map X ℙ = gaussianReal μ v) (c : ℝ) :
    Measure.map (fun ω ↦ c * X ω) ℙ = gaussianReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v)

(hX : MeasureTheory.Measure.map X MeasureTheory.volume = ProbabilityTheory.gaussianReal μ v)

MeasureTheory.Measure.map (fun ω => c * X ω) MeasureTheory.volume =
  ProbabilityTheory.gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)


@[simp]
theorem coe_lcs_range_toEnd_eq (k : ℕ) :
    (lowerCentralSeries R (toEnd R L M).range M k : Submodule R M) =
      lowerCentralSeries R L M k

(R : Type u)
(L : Type v)
(M : Type w)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
(k : ℕ)

↑(LieModule.lowerCentralSeries R (↥(LieModule.toEnd R L M).range) M k) = ↑(LieModule.lowerCentralSeries R L M k)


@[simp]
theorem rpow_eq_zero_iff {x : ℝ≥0∞} {y : ℝ} : x ^ y = 0 ↔ x = 0 ∧ 0 < y ∨ x = ⊤ ∧ y < 0


/-- An iso `α ≃* β` can equivalently be viewed as an iso `αᵐᵒᵖ ≃* βᵐᵒᵖ`. -/
@[to_additive (attr := simps)
  "An iso `α ≃+ β` can equivalently be viewed as an iso `αᵃᵒᵖ ≃+ βᵃᵒᵖ`."]
def MulEquiv.op {α β} [Mul α] [Mul β] : α ≃* β ≃ (αᵐᵒᵖ ≃* βᵐᵒᵖ)

{α : Type u_2}
{β : Type u_3}
[Add α]
[Add β]
(f : αᵃᵒᵖ ≃+ βᵃᵒᵖ)

∀ (a : β), (AddEquiv.op.symm f).symm a = (AddOpposite.unop ∘ ⇑f.symm ∘ AddOpposite.op) a


theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s) :
    MeasurableSet[generateFrom s] t

{α : Type u_1}
{s : Set (Set α)}
{t : Set α}
(ht : t ∈ s)


@[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ) : c • closedBall x r = closedBall (c • x) r

{G : Type v}
{X : Type w}
[PseudoMetricSpace X]
[AddGroup G]
[AddAction G X]
[IsometricVAdd G X]
(c : G)
(x : X)
(r : ℝ)

c +ᵥ Metric.closedBall x r = Metric.closedBall (c +ᵥ x) r


@[simp]
lemma lt_smul_iff_one_lt_left [SMulPosStrictMono α β] [SMulPosReflectLT α β] (hb : 0 < b) :
    b < a • b ↔ 1 < a

{α : Type u_1}
{β : Type u_2}
{a : α}
{b : β}
[Monoid α]
[Zero β]
[MulAction α β]
[Preorder α]
[Preorder β]
[SMulPosStrictMono α β]
[SMulPosReflectLT α β]
(hb : 0 < b)


/-- Homotopy between morphisms of short complexes is compatible with composition. -/
@[simps!]
def comp (h : Homotopy φ₁ φ₂) {ψ₁ ψ₂ : S₂ ⟶ S₃} (h' : Homotopy ψ₁ ψ₂) :
    Homotopy (φ₁ ≫ ψ₁) (φ₂ ≫ ψ₂)

{S₁ S₂ S₃ : CategoryTheory.ShortComplex C}

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

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

{ψ₁ ψ₂ : S₂ ⟶ S₃}

(h' : CategoryTheory.ShortComplex.Homotopy ψ₁ ψ₂)

(h.comp h').h₁ = CategoryTheory.CategoryStruct.comp h.h₁ ψ₁.τ₁ + CategoryTheory.CategoryStruct.comp φ₂.τ₂ h'.h₁


/-- A nontrivial finite dimensional space has positive `finrank`. -/
theorem FiniteDimensional.finrank_pos [NoZeroSMulDivisors R M] [h : Nontrivial M] :
    0 < finrank R M

{R : Type u}
{M : Type v}
[Ring R]
[AddCommGroup M]
[Module R M]
[Nontrivial R]
[StrongRankCondition R]
[Module.Finite R M]
[NoZeroSMulDivisors R M]
[h : Nontrivial M]


@[simp]
theorem fix_inv {x : Q} : x ◃⁻¹ x = x


@[fun_prop]
nonrec theorem HasFDerivWithinAt.add (hf : HasFDerivWithinAt f f' s x)
    (hg : HasFDerivWithinAt g g' s x) : HasFDerivWithinAt (fun y => f y + g y) (f' + g') s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f g : E → F}
{f' g' : E →L[𝕜] F}
{x : E}
{s : Set E}
(hf : HasFDerivWithinAt f f' s x)
(hg : HasFDerivWithinAt g g' s x)


@[simp]
theorem coe_constVSub (p : P₁) : ⇑(constVSub k p) = (p -ᵥ ·)

(k : Type u_1)
{P₁ : Type u_2}
{V₁ : Type u_6}
[Ring k]
[AddCommGroup V₁]
[Module k V₁]
[AffineSpace V₁ P₁]
(p : P₁)

⇑(AffineEquiv.constVSub k p) = fun x => p -ᵥ x


@[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Subgroup G) :
    ⨆ i, p i = closure (⋃ i, (p i : Set G))

{G : Type u_1}
[AddGroup G]
{ι : Sort u_5}
(p : ι → AddSubgroup G)

⨆ i, p i = AddSubgroup.closure (⋃ i, ↑(p i))


lemma equiv_iff_eq : Nonempty (Fin m ≃ Fin n) ↔ m = n


theorem withDensity_limRatioMeas_eq : μ.withDensity (v.limRatioMeas hρ) = ρ

(hρ : ρ ≪ μ)


theorem abs_two_mul_re_lt_one_of_mem_fdo (h : z ∈ 𝒟ᵒ) : |2 * z.re| < 1


@[simp, mfld_simps]
theorem symm_comp_self : I.symm ∘ I = id

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)


@[simp] lemma powerset_univ : (univ : Finset α).powerset = univ


lemma tail_support_eq_support_tail (p : G.Walk u v) (hnp : ¬p.Nil) :
    (p.tail hnp).support = p.support.tail

{V : Type u}
{G : SimpleGraph V}
{u v : V}
(p : G.Walk u v)
(hnp : ¬p.Nil)


theorem min_of_le_pred {a : α} : a ≤ pred a → IsMin a

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


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

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

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

∫⁻ (bc : β × γ), f bc ∂(κ.compProd η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f (b, c) ∂η (a, b) ∂κ a


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

{R : Type u_1}
{M : Type u_2}
{N : Type u_3}
[CommRing R]
[AddCommGroup M]
[AddCommGroup N]
[Module R M]
[Module R N]
(a : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N)

ExteriorAlgebra.liftAlternatingEquiv a = ExteriorAlgebra.liftAlternating a


@[simp]
theorem bind_none (f : α → Part β) : none.bind f = none

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


@[to_additive]
theorem mul_one_eq_id : (· * (1 : M)) = id


theorem castSucc_lt_last (a : Fin n) : castSucc a < last n


@[aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_adjoin : s ⊆ adjoin R s

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


@[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul]
theorem toDual_pow [Pow α β] (a : α) (b : β) : toDual (a ^ b) = toDual a ^ b

{β : Type u_2}
{α : Type u_1}
[SMul β α]
(b : β)
(a : α)

OrderDual.toDual (b • a) = b • OrderDual.toDual a


theorem iSup_finset_image {f : γ → α} {g : α → β} {s : Finset γ} :
    ⨆ x ∈ s.image f, g x = ⨆ y ∈ s, g (f y)

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[CompleteLattice β]
[DecidableEq α]
{f : γ → α}
{g : α → β}
{s : Finset γ}

⨆ x ∈ Finset.image f s, g x = ⨆ y ∈ s, g (f y)


@[simp] theorem isLeft_swap (x : α ⊕ β) : x.swap.isLeft = x.isRight

{α : Type u_1}
{β : Type u_2}
(x : α ⊕ β)


theorem ofNat_max (a b : Nat) : ((max a b : Nat) : Int) = max (a : Int) (b : Int)


/-- If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined,
  there is a finite set `t` satisfying the desired properties. -/
@[to_additive addIndex_defined
"If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined, there is
a finite set `t` satisfying the desired properties."]
theorem index_defined {K V : Set G} (hK : IsCompact K) (hV : (interior V).Nonempty) :
    ∃ n : ℕ, n ∈ Finset.card '' { t : Finset G | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V }

{G : Type u_1}
[AddGroup G]
[TopologicalSpace G]
[TopologicalAddGroup G]
{K V : Set G}
(hK : IsCompact K)
(hV : (interior V).Nonempty)

∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g + h) ⁻¹' V}


theorem le_measurableSpace_of_const_le (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, i ≤ τ ω) :
    f i ≤ hτ.measurableSpace

{Ω : Type u_1}
{ι : Type u_3}
{m : MeasurableSpace Ω}
[Preorder ι]
{f : MeasureTheory.Filtration ι m}
{τ : Ω → ι}
(hτ : MeasureTheory.IsStoppingTime f τ)
{i : ι}
(hτ_le : ∀ (ω : Ω), i ≤ τ ω)


theorem lmapDomain_disjoint_ker (f : α → α') {s : Set α}
    (H : ∀ a ∈ s, ∀ b ∈ s, f a = f b → a = b) :
    Disjoint (supported M R s) (ker (lmapDomain M R f))

Disjoint (Finsupp.supported M R s) (LinearMap.ker (Finsupp.lmapDomain M R f))


/-- Random variables are independent iff their joint density is a product of marginal densities. -/
theorem indepFun_iff_pdf_prod_eq_pdf_mul_pdf
    [IsFiniteMeasure ℙ] [SigmaFinite μ] [SigmaFinite ν] [HasPDF (fun ω ↦ (X ω, Y ω)) ℙ (μ.prod ν)] :
    IndepFun X Y ℙ ↔
      pdf (fun ω ↦ (X ω, Y ω)) ℙ (μ.prod ν) =ᵐ[μ.prod ν] fun z ↦ pdf X ℙ μ z.1 * pdf Y ℙ ν z.2

[MeasureTheory.HasPDF (fun ω => (X ω, Y ω)) ℙ (μ.prod ν)]

ProbabilityTheory.IndepFun X Y ℙ ↔
  MeasureTheory.pdf (fun ω => (X ω, Y ω)) ℙ (μ.prod ν) =ᵐ[μ.prod ν] fun z =>
    MeasureTheory.pdf X ℙ μ z.1 * MeasureTheory.pdf Y ℙ ν z.2


theorem sphere_subset_box : sphere n d k ⊆ box n d


@[simp] theorem exists_or_eq_right' (y : α) (p : α → Prop) : ∃ x : α, p x ∨ y = x


lemma mem_coeffs_iff {p : MvPolynomial σ R} {c : R} :
    c ∈ p.coeffs ↔ ∃ n ∈ p.support, c = p.coeff n

{R : Type u}
{σ : Type u_1}
[CommSemiring R]
{p : MvPolynomial σ R}
{c : R}

c ∈ p.coeffs ↔ ∃ n ∈ p.support, c = MvPolynomial.coeff n p


theorem star_vecMul [Fintype m] [StarRing α] (M : Matrix m n α) (v : m → α) :
    star (v ᵥ* M) = Mᴴ *ᵥ star v

{m : Type u_2}
{n : Type u_3}
{α : Type v}
[NonUnitalSemiring α]
[Fintype m]
[StarRing α]
(M : Matrix m n α)
(v : m → α)


@[to_additive]
theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c

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


/-- The image of the filter `atTop` on `Ici a` under the coercion equals `atTop`. -/
@[simp]
theorem map_val_Ici_atTop [SemilatticeSup α] (a : α) : map ((↑) : Ici a → α) atTop = atTop

{α : Type u_3}
[SemilatticeSup α]
(a : α)

Filter.map Subtype.val Filter.atTop = Filter.atTop


/-- The arrow `A --dZero--> Fun(G, A)` is isomorphic to the differential
`(inhomogeneousCochains A).d 0 1` of the complex of inhomogeneous cochains of `A`. -/
@[simps! hom_left hom_right inv_left inv_right]
def dZeroArrowIso : Arrow.mk ((inhomogeneousCochains A).d 0 1) ≅
    Arrow.mk (ModuleCat.ofHom (dZero A))

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

(groupCohomology.dZeroArrowIso A).inv.left = ↑(groupCohomology.zeroCochainsLequiv A).symm


/-- A reformulation of the expansion of (1 + y)^d:
$$(d + 1) (1 + y)^d - (d + 1)y^d = \sum_{i = 0}^d {d + 1 \choose i} \cdot i \cdot y^{i - 1}.$$
-/
theorem eval_monomial_one_add_sub [CommRing S] (d : ℕ) (y : S) :
    eval (1 + y) (monomial d (d + 1 : S)) - eval y (monomial d (d + 1 : S)) =
      ∑ x_1 ∈ range (d + 1), ↑((d + 1).choose x_1) * (↑x_1 * y ^ (x_1 - 1))

{S : Type v}
[CommRing S]
(d : ℕ)
(y : S)

Polynomial.eval (1 + y) ((Polynomial.monomial d) (↑d + 1)) - Polynomial.eval y ((Polynomial.monomial d) (↑d + 1)) =
  ∑ x_1 ∈ Finset.range (d + 1), ↑((d + 1).choose x_1) * (↑x_1 * y ^ (x_1 - 1))


lemma OrthogonalIdempotents.mul_eq [DecidableEq I] (he : OrthogonalIdempotents e) (i j) :
    e i * e j = if i = j then e i else 0

{R : Type u_1}
[Ring R]
{I : Type u_3}
{e : I → R}
[DecidableEq I]
(he : OrthogonalIdempotents e)
(i j : I)


/-- If an intermediate field of `E / F` is both purely inseparable and separable, then it is equal
to `F`. -/
theorem IntermediateField.eq_bot_of_isPurelyInseparable_of_isSeparable (L : IntermediateField F E)
    [IsPurelyInseparable F L] [Algebra.IsSeparable F L] : L = ⊥

{F : Type u}
{E : Type v}
[Field F]
[Field E]
[Algebra F E]
(L : IntermediateField F E)
[IsPurelyInseparable F ↥L]
[Algebra.IsSeparable F ↥L]


theorem norm_eq_tsum_rpow (hp : 0 < p.toReal) (f : lp E p) :
    ‖f‖ = (∑' i, ‖f i‖ ^ p.toReal) ^ (1 / p.toReal)

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

‖f‖ = (∑' (i : α), ‖↑f i‖ ^ p.toReal) ^ (1 / p.toReal)


/-- If the relation given by $(f_i)_{i \in \iota}$ and $(x_i)_{i \in \iota}$ is trivial, then
$\sum_{i} f_i x_i$ is actually equal to $0$. -/
theorem sum_smul_eq_zero_of_isTrivialRelation (h : IsTrivialRelation f x) :
    ∑ i, f i • x i = 0

{R M : Type u}
[CommRing R]
[AddCommGroup M]
[Module R M]
{ι : Type u}
[Fintype ι]
{f : ι → R}
{x : ι → M}
(h : Module.IsTrivialRelation f x)


/-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
protected def divRight (a : G) : G ≃ G


theorem IsPrefix.ne_nil {x y : List α} (h : x <+: y) (hx : x ≠ []) : y ≠ []

{α : Type u_1}
{x y : List α}
(h : x <+: y)
(hx : x ≠ [])


theorem StronglyMeasurable.integral_kernel_prod_right ⦃f : α → β → E⦄
    (hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun x => ∫ y, f x y ∂κ x

⦃f : α → β → E⦄

(hf : MeasureTheory.StronglyMeasurable (Function.uncurry f))

MeasureTheory.StronglyMeasurable fun x => ∫ (y : β), f x y ∂κ x


private theorem newton_seq_dist_tendsto' :
    Tendsto (fun n => ‖newton_cau_seq hnorm n - a‖) atTop (𝓝 ‖soln - a‖)

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

Filter.Tendsto (fun n => ‖↑(newton_cau_seq hnorm) n - a‖) Filter.atTop (𝓝 ‖soln_gen hnorm - a‖)


theorem let_value_eq {α : Sort u} {β : Sort v} {a₁ a₂ : α} (b : α → β)
    (h : a₁ = a₂) : (let x : α := a₁; b x) = (let x : α := a₂; b x)

(let x := a₁;
  b x) =
  let x := a₂;
  b x


@[simp]
theorem modByMonic_one (p : R[X]) : p %ₘ 1 = 0


theorem pair_preimage_singleton (f : α →ₛ β) (g : α →ₛ γ) (b : β) (c : γ) :
    pair f g ⁻¹' {(b, c)} = f ⁻¹' {b} ∩ g ⁻¹' {c}

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[MeasurableSpace α]
(f : MeasureTheory.SimpleFunc α β)
(g : MeasureTheory.SimpleFunc α γ)
(b : β)
(c : γ)

↑(f.pair g) ⁻¹' {(b, c)} = ↑f ⁻¹' {b} ∩ ↑g ⁻¹' {c}


theorem union_add_distrib (s t u : Multiset α) : s ∪ t + u = s + u ∪ (t + u)

{α : Type u_1}
[DecidableEq α]
(s t u : Multiset α)


/-- Any matrix `A` can be expressed as the evaluation of `Matrix.mvPolynomialX`.

This is of particular use when `MvPolynomial (m × n) R` is an integral domain but `S` is
not, as if the `MvPolynomial.eval₂` can be pulled to the outside of a goal, it can be solved in
under cancellative assumptions. -/
theorem mvPolynomialX_map_eval₂ [CommSemiring R] [CommSemiring S] (f : R →+* S) (A : Matrix m n S) :
    (mvPolynomialX m n R).map (MvPolynomial.eval₂ f fun p : m × n => A p.1 p.2) = A

{m : Type u_1}
{n : Type u_2}
{R : Type u_3}
{S : Type u_4}
[CommSemiring R]
[CommSemiring S]
(f : R →+* S)
(A : Matrix m n S)

(Matrix.mvPolynomialX m n R).map (MvPolynomial.eval₂ f fun p => A p.1 p.2) = A


lemma intCast_div_eq_divInt (n d : ℤ) : (n : ℚ) / (d) = n /. d


theorem empty_promises (a : α) : empty α ~> a


theorem isGLB_lt_isLUB_of_ne (Ha : IsGLB s a) (Hb : IsLUB s b) {x y} (Hx : x ∈ s) (Hy : y ∈ s)
    (Hxy : x ≠ y) : a < b

{α : Type u}
[PartialOrder α]
{s : Set α}
{a b : α}
(Ha : IsGLB s a)
(Hb : IsLUB s b)
{x y : α}
(Hx : x ∈ s)
(Hy : y ∈ s)
(Hxy : x ≠ y)


@[simp]
theorem iInf_adj {f : ι → G.Subgraph} : (⨅ i, f i).Adj a b ↔ (∀ i, (f i).Adj a b) ∧ G.Adj a b

{ι : Sort u_1}
{V : Type u}
{G : SimpleGraph V}
{a b : V}
{f : ι → G.Subgraph}

(⨅ i, f i).Adj a b ↔ (∀ (i : ι), (f i).Adj a b) ∧ G.Adj a b


/-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F

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

[CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R]

(c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R)))

{c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))}

(CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.hom =
  (CategoryTheory.Limits.isLimitOfPreserves R t₂).lift (CategoryTheory.Comma.limitAuxiliaryCone F c₁)


theorem mem_of_mem_insert_of_ne : b ∈ insert a s → b ≠ a → b ∈ s


@[to_additive (attr := simp, norm_cast)]
protected theorem val_smul_of_tower (r : M) (x : s) : (↑(r • x) : α) = r • (x : α)

{S : Type u'}
{M : Type v}
{N : Type u_1}
{α : Type u_2}
[SetLike S α]
[SMul M N]
[SMul M α]
[Monoid N]
[MulAction N α]
[SMulMemClass S N α]
[IsScalarTower M N α]
(s : S)
(r : M)
(x : ↥s)


@[to_additive (attr := simp)] lemma oneLePart_div_leOnePart (a : α) : a⁺ᵐ / a⁻ᵐ = a

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


@[symm]
theorem adj_symm (h : G.Adj u v) : G.Adj v u

{V : Type u}
(G : SimpleGraph V)
{u v : V}
(h : G.Adj u v)


@[simp]
theorem coeff_mul_C (n : σ →₀ ℕ) (φ : MvPowerSeries σ R) (a : R) :
    coeff R n (φ * C σ R a) = coeff R n φ * a

{σ : Type u_1}
{R : Type u_2}
[Semiring R]
(n : σ →₀ ℕ)
(φ : MvPowerSeries σ R)
(a : R)

(MvPowerSeries.coeff R n) (φ * (MvPowerSeries.C σ R) a) = (MvPowerSeries.coeff R n) φ * a


theorem add_mul_self_eq (a b : α) : (a + b) * (a + b) = a * a + 2 * a * b + b * b


@[to_additive (attr := simp)]
theorem lift.mk : lift f (mk L) = List.prod (L.map fun x => cond x.2 (f x.1) (f x.1)⁻¹)

{α : Type u}
{L : List (α × Bool)}
{β : Type v}
[Group β]
{f : α → β}

(FreeGroup.lift f) (FreeGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else (f x.1)⁻¹) L).prod


lemma finiteCoproduct.hom_ext {B : Profinite.{max u w}} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g

(h :
  ∀ (a : α),
    CategoryTheory.CategoryStruct.comp (Profinite.finiteCoproduct.ι X a) f =
      CategoryTheory.CategoryStruct.comp (Profinite.finiteCoproduct.ι X a) g)


/-- Two congruence relations are equal iff their underlying binary relations are equal. -/
@[to_additive "Two additive congruence relations are equal iff their underlying binary relations
are equal."]
theorem coe_inj {c d : Con M} : ⇑c = ⇑d ↔ c = d


@[to_additive]
lemma prod_ite_eq_ite_exists (p : ι → Prop) [DecidablePred p] (h : ∀ i j, p i → p j → i = j)
    (a : α) : ∏ i, ite (p i) a 1 = ite (∃ i, p i) a 1

{ι : Type u_6}
{α : Type u_8}
[Fintype ι]
[CommMonoid α]
(p : ι → Prop)
[DecidablePred p]
(h : ∀ (i j : ι), p i → p j → i = j)
(a : α)

(∏ i : ι, if p i then a else 1) = if ∃ i, p i then a else 1


theorem aestronglyMeasurable_comp_snd_map_prod_mk_iff {Ω F} {_ : MeasurableSpace Ω}
    [TopologicalSpace F] {X : Ω → β} {μ : Measure Ω} (hX : Measurable X) {f : Ω → F} :
    AEStronglyMeasurable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω)) ↔
    AEStronglyMeasurable f μ

{β : Type u_2}
{mβ : MeasurableSpace β}
{Ω : Type u_5}
{F : Type u_6}

∀ {x : MeasurableSpace Ω} [inst : TopologicalSpace F] {X : Ω → β} {μ : MeasureTheory.Measure Ω},
  Measurable X →
    ∀ {f : Ω → F},
      MeasureTheory.AEStronglyMeasurable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (X ω, ω)) μ) ↔
        MeasureTheory.AEStronglyMeasurable f μ


@[simp]
theorem Icc_self (a : α) : Icc a a = {a}

{α : Type u_1}
[PartialOrder α]
[LocallyFiniteOrder α]
(a : α)


/-- Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f` is continuous
at `a`, then the derivative of `u ↦ ∫ x in u..b, f x` at `a` equals `-f a`. -/
theorem deriv_integral_left (hf : IntervalIntegrable f volume a b)
    (hmeas : StronglyMeasurableAtFilter f (𝓝 a)) (hb : ContinuousAt f a) :
    deriv (fun u => ∫ x in u..b, f x) a = -f a

(hf : IntervalIntegrable f MeasureTheory.volume a b)

(hmeas : StronglyMeasurableAtFilter f (𝓝 a) MeasureTheory.volume)

deriv (fun u => ∫ (x : ℝ) in u..b, f x) a = -f a


theorem prod_lipschitzWith_equiv_aux [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    LipschitzWith 1 (WithLp.equiv p (α × β))

(p : ℝ≥0∞)
(α : Type u_2)
(β : Type u_3)
[hp : Fact (1 ≤ p)]
[PseudoEMetricSpace α]
[PseudoEMetricSpace β]

LipschitzWith 1 ⇑(WithLp.equiv p (α × β))


@[to_additive]
theorem multiset_prod_singleton {M : Type*} [CommMonoid M] (s : Multiset M) :
    (s.map fun i ↦ ({i} : Set M)).prod = {s.prod}

{M : Type u_5}
[CommMonoid M]
(s : Multiset M)

(Multiset.map (fun i => {i}) s).prod = {s.prod}


lemma polyCharpoly_baseChange (A : Type*) [CommRing A] [Algebra R A] :
    polyCharpoly (tensorProduct _ _ _ _ ∘ₗ φ.baseChange A) (basis A b) =
      (polyCharpoly φ b).map (MvPolynomial.map (algebraMap R A))

{R : Type u_1}
{L : Type u_2}
{M : Type u_3}
{ι : Type u_5}
[CommRing R]
[AddCommGroup L]
[Module R L]
[AddCommGroup M]
[Module R M]
(φ : L →ₗ[R] Module.End R M)
[Fintype ι]
[DecidableEq ι]
[Module.Free R M]
[Module.Finite R M]
(b : Basis ι R L)
(A : Type u_8)
[CommRing A]
[Algebra R A]

(LinearMap.tensorProduct R A M M ∘ₗ LinearMap.baseChange A φ).polyCharpoly (Algebra.TensorProduct.basis A b) =
  Polynomial.map (MvPolynomial.map (algebraMap R A)) (φ.polyCharpoly b)


@[simp]
theorem boundary_length : c.boundary ⟨c.length, c.length_lt_card_boundaries⟩ = Fin.last n


theorem Ico_succ_succ : Ico a.succ b.succ = Ioc a b

Finset.Ico a.succ b.succ = Finset.Ioc a b


theorem singleton_sups_singleton : ({a} ⊻ {b} : Finset α) = {a ⊔ b}

{α : Type u_2}
[DecidableEq α]
[SemilatticeSup α]
{a b : α}


theorem curry_injective : Function.Injective (curry : (A ⨯ Y ⟶ X) → (Y ⟶ A ⟹ X))


theorem IsMaximal.mem_of_models (h : T.IsMaximal) {φ : L.Sentence} (hφ : T ⊨ᵇ φ) : φ ∈ T

{L : FirstOrder.Language}
{T : L.Theory}
(h : T.IsMaximal)
{φ : L.Sentence}
(hφ : T ⊨ᵇ φ)


protected theorem lt_inf {a b c : CauSeq α abs} (hb : a < b) (hc : a < c) : a < b ⊓ c

{α : Type u_1}
[LinearOrderedField α]
{a b c : CauSeq α abs}
(hb : a < b)
(hc : a < c)


/-- Functor translating a monoid object in a functor category
to a functor into the category of monoid objects.
-/
@[simps]
def functor : Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D

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

CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functor.obj A =
  CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.functorObj A


@[simp] protected theorem mul_one : ∀ (n : Nat), n * 1 = n


@[simp] theorem dual_id : SupBotHom.dual (SupBotHom.id α) = InfTopHom.id _

SupBotHom.dual (SupBotHom.id α) = InfTopHom.id αᵒᵈ


@[to_additive]
theorem rightRel_eq : @Setoid.r _ (rightRel s) = fun x y => y * x⁻¹ ∈ s

{α : Type u_1}
[AddGroup α]
(s : AddSubgroup α)


theorem distortion_of_const {c} (h₁ : π.boxes.Nonempty) (h₂ : ∀ J ∈ π, Box.distortion J = c) :
    π.distortion = c

{ι : Type u_1}
{I : BoxIntegral.Box ι}
(π : BoxIntegral.Prepartition I)
[Fintype ι]
{c : ℝ≥0}
(h₁ : π.boxes.Nonempty)
(h₂ : ∀ J ∈ π, J.distortion = c)


theorem condexpInd_disjoint_union (hs : MeasurableSet s) (ht : MeasurableSet t) (hμs : μ s ≠ ∞)
    (hμt : μ t ≠ ∞) (hst : s ∩ t = ∅) : (condexpInd G hm μ (s ∪ t) : G →L[ℝ] α →₁[μ] G) =
    condexpInd G hm μ s + condexpInd G hm μ t

{α : Type u_1}
{G : Type u_5}
[NormedAddCommGroup G]
{m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{s t : Set α}
[NormedSpace ℝ G]
{hm : m ≤ m0}
[MeasureTheory.SigmaFinite (μ.trim hm)]
(hs : MeasurableSet s)
(ht : MeasurableSet t)
(hμs : μ s ≠ ⊤)
(hμt : μ t ≠ ⊤)
(hst : s ∩ t = ∅)

MeasureTheory.condexpInd G hm μ (s ∪ t) = MeasureTheory.condexpInd G hm μ s + MeasureTheory.condexpInd G hm μ t


theorem sInter_nhds (l : Filter α) : ⋂₀ { s | s ∈ 𝓝 l } = Iic l


@[simp]
theorem circulant_apply [Sub n] (v : n → α) (i j) : circulant v i j = v (i - j)

{α : Type u_1}
{n : Type u_4}
[Sub n]
(v : n → α)
(i j : n)


/-- All values of a function `f ∈ stdSimplex 𝕜 ι` belong to `[0, 1]`. -/
theorem mem_Icc_of_mem_stdSimplex (hf : f ∈ stdSimplex R ι) (x) : f x ∈ Icc (0 : R) 1

{R : Type u_1}
{ι : Type u_5}
[LinearOrderedField R]
[Fintype ι]
{f : ι → R}
(hf : f ∈ stdSimplex R ι)
(x : ι)


/-- If `α : G ⟶ H` then
`whiskerLeft F α : (F ⋙ G) ⟶ (F ⋙ H)` has components `α.app (F.obj X)`.
-/
@[simps]
def whiskerLeft (F : C ⥤ D) {G H : D ⥤ E} (α : G ⟶ H) :
    F ⋙ G ⟶ F ⋙ H

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃}
[CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C D)
{G H : CategoryTheory.Functor D E}
(α : G ⟶ H)
(X : C)

(CategoryTheory.whiskerLeft F α).app X = α.app (F.obj X)


theorem not_mem_of_max_lt_coe {a : α} {s : Finset α} (h : s.max < a) : a ∉ s

{α : Type u_2}
[LinearOrder α]
{a : α}
{s : Finset α}
(h : s.max < ↑a)


/-- The power basis `1, x, ..., x ^ (d - 1)` for `K⟮x⟯`,
where `d` is the degree of the minimal polynomial of `x`. -/
@[simps]
noncomputable def adjoin.powerBasis {x : L} (hx : IsIntegral K x) : PowerBasis K K⟮x⟯

{K : Type u}
[Field K]
{L : Type u_3}
[Field L]
[Algebra K L]
{x : L}
(hx : IsIntegral K x)

(IntermediateField.adjoin.powerBasis hx).gen = IntermediateField.AdjoinSimple.gen K x


/-- For any element `x` of `M ⊗[R] N`, there exists a finite subset `{ (m_i, n_i) }`
of `M × N` such that each `m_i` is distinct (we represent it as an element of `M →₀ N`),
such that `x` is equal to the sum of `m_i ⊗ₜ[R] n_i`. -/
theorem exists_finsupp_left (x : M ⊗[R] N) :
    ∃ S : M →₀ N, x = S.sum fun m n ↦ m ⊗ₜ[R] n

{R : Type u_1}
{M : Type u_2}
{N : Type u_3}
[CommSemiring R]
[AddCommMonoid M]
[AddCommMonoid N]
[Module R M]
[Module R N]
(x : M ⊗[R] N)


@[to_additive]
theorem map_map (f : α →ₙ* β) (g : β →ₙ* γ) (x) : map g (map f x) = map (g.comp f) x

{α : Type u}
{β : Type v}
{γ : Type w}
[Mul α]
[Mul β]
[Mul γ]
(f : α →ₙ* β)
(g : β →ₙ* γ)
(x : WithOne α)

(WithOne.map g) ((WithOne.map f) x) = (WithOne.map (g.comp f)) x


@[simp]
theorem Multiset.mem_toEnumFinset (m : Multiset α) (p : α × ℕ) :
    p ∈ m.toEnumFinset ↔ p.2 < m.count p.1

{α : Type u_1}
[DecidableEq α]
(m : Multiset α)
(p : α × ℕ)

p ∈ m.toEnumFinset ↔ p.2 < Multiset.count p.1 m


theorem is_quotient_mk (m : M) : Quotient.mk'' m = (mk m : M ⧸ N)

{R : Type u}
{L : Type v}
{M : Type w}
[CommRing R]
[LieRing L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
{N : LieSubmodule R L M}
(m : M)

Quotient.mk'' m = LieSubmodule.Quotient.mk m


@[simp]
theorem add_dotProduct : (u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w

{m : Type u_2}
{α : Type v}
[Fintype m]
[NonUnitalNonAssocSemiring α]
(u v w : m → α)


protected theorem «forall» {α : Sort _} {f : Sym2 α → Prop} :
    (∀ x : Sym2 α, f x) ↔ ∀ x y, f s(x, y)

(∀ (x : Sym2 α), f x) ↔ ∀ (x y : α), f s(x, y)


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

{α : Type u_1}
{β : Type u_2}
{f : α → β}
[Preorder α]
[Preorder β]
{a b : α}
(h : StrictAntiOn f (Set.Icc a b))

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


theorem continuousAt_iff [PseudoMetricSpace β] {f : α → β} {a : α} :
    ContinuousAt f a ↔ ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, dist x a < δ → dist (f x) (f a) < ε

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


@[simp]
theorem foldrRecOn_cons {C : β → Sort*} (x : α) (l : List α) (op : α → β → β) (b) (hb : C b)
    (hl : ∀ b, C b → ∀ a ∈ x :: l, C (op a b)) :
    foldrRecOn (x :: l) op b hb hl =
      hl _ (foldrRecOn l op b hb fun b hb a ha => hl b hb a (mem_cons_of_mem _ ha)) x
        (mem_cons_self _ _)

(op : α → β → β)

(hl : (b : β) → C b → (a : α) → a ∈ x :: l → C (op a b))

(x :: l).foldrRecOn op b hb hl = hl (List.foldr op b l) (l.foldrRecOn op b hb fun b hb a ha => hl b hb a ⋯) x ⋯


@[simp]
theorem restrict_apply (f : R →+* S) {s : σR} (x : s) : f.domRestrict s x = f x

{R : Type u}
{S : Type v}
[NonAssocSemiring R]
[NonAssocSemiring S]
{σR : Type u_1}
[SetLike σR R]
[SubsemiringClass σR R]
(f : R →+* S)
{s : σR}
(x : ↥s)


theorem dist_def (f g : Lp E p μ) : dist f g = (eLpNorm (⇑f - ⇑g) p μ).toReal

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

dist f g = (MeasureTheory.eLpNorm (↑↑f - ↑↑g) p μ).toReal


@[norm_cast]
theorem coe_mul_rpow (x y : ℝ≥0) (z : ℝ) : ((x : ℝ≥0∞) * y) ^ z = (x : ℝ≥0∞) ^ z * (y : ℝ≥0∞) ^ z


@[simp]
theorem card_mk₂ (c f₁ f₂ : Type u) (r₁ r₂ : Type v) :
    (Language.mk₂ c f₁ f₂ r₁ r₂).card =
      Cardinal.lift.{v} #c + Cardinal.lift.{v} #f₁ + Cardinal.lift.{v} #f₂ +
          Cardinal.lift.{u} #r₁ + Cardinal.lift.{u} #r₂

(FirstOrder.Language.mk₂ c f₁ f₂ r₁ r₂).card =
  Cardinal.lift.{v, u} #c + Cardinal.lift.{v, u} #f₁ + Cardinal.lift.{v, u} #f₂ + Cardinal.lift.{u, v} #r₁ +
    Cardinal.lift.{u, v} #r₂


/-- In a topological vector space over a nontrivially normed field, any nonempty open set has
the same cardinality as the whole space. -/
theorem cardinal_eq_of_isOpen
    {E : Type*} (𝕜 : Type*) [NontriviallyNormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
    [TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul 𝕜 E] {s : Set E}
    (hs : IsOpen s) (h's : s.Nonempty) : #s = #E

{E : Type u_1}
(𝕜 : Type u_2)
[NontriviallyNormedField 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[TopologicalSpace E]
[ContinuousAdd E]
[ContinuousSMul 𝕜 E]
{s : Set E}
(hs : IsOpen s)
(h's : s.Nonempty)


lemma Preadditive.mono_iff_injective {X Y : C} (f : X ⟶ Y) :
    Mono f ↔ Function.Injective ((forget₂ C Ab).map f)

CategoryTheory.Mono f ↔ Function.Injective ⇑((CategoryTheory.forget₂ C Ab).map f)


lemma log_mul_eq_add_log_iff {x y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) :
    log (x * y) = log x + log y ↔ arg x + arg y ∈ Set.Ioc (-π) π

Complex.log (x * y) = Complex.log x + Complex.log y ↔ x.arg + y.arg ∈ Set.Ioc (-Real.pi) Real.pi


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

{L : FirstOrder.Language}
{M : Type w}
[L.Structure M]
{S T : L.Substructure M}
(h : ∀ (x : M), x ∈ S ↔ x ∈ T)


theorem isOpenMap_iff_nhds_le : IsOpenMap f ↔ ∀ x : X, 𝓝 (f x) ≤ (𝓝 x).map f

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

IsOpenMap f ↔ ∀ (x : X), 𝓝 (f x) ≤ Filter.map f (𝓝 x)


/-- The units of the monoid of non-zero divisors of `M₀` are equivalent to the units of `M₀`. -/
@[simps]
def unitsNonZeroDivisorsEquiv : M₀⁰ˣ ≃* M₀ˣ

∀ (a : (↥M₀⁰)ˣ), unitsNonZeroDivisorsEquiv a = (↑(Units.map M₀⁰.subtype)).toFun a


/-- The set in the definition of `Order.cof` is nonempty. -/
theorem cof_nonempty (r : α → α → Prop) [IsRefl α r] :
    { c | ∃ S : Set α, (∀ a, ∃ b ∈ S, r a b) ∧ #S = c }.Nonempty

{α : Type u_1}
(r : α → α → Prop)
[IsRefl α r]

{c | ∃ S, (∀ (a : α), ∃ b ∈ S, r a b) ∧ #↑S = c}.Nonempty


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

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

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


@[simp]
theorem sumAssoc_symm_apply_inr_inr {α β γ} (c) : (sumAssoc α β γ).symm (inr (inr c)) = inr c

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(c : γ)

(Equiv.sumAssoc α β γ).symm (Sum.inr (Sum.inr c)) = Sum.inr c


/-- An isometry from a metric space is a uniform inducing map -/
protected theorem uniformInducing (hf : Isometry f) : UniformInducing f

{α : Type u}
{β : Type v}
[PseudoEMetricSpace α]
[PseudoEMetricSpace β]
{f : α → β}
(hf : Isometry f)


/-- An isomorphism of short complexes `S₁ ≅ S₂` induces an isomorphism on the `Q` fields
of right homology data of `S₁` and `S₂`. -/
@[simps]
def opcyclesMapIso' (e : S₁ ≅ S₂) (h₁ : S₁.RightHomologyData)
    (h₂ : S₂.RightHomologyData) : h₁.Q ≅ h₂.Q

(CategoryTheory.ShortComplex.opcyclesMapIso' e h₁ h₂).hom = CategoryTheory.ShortComplex.opcyclesMap' e.hom h₁ h₂


@[simp]
theorem Chain.nil (r : α → α → Prop) : Cycle.Chain r (@nil α)


theorem not_mem_of_mem_diff {s t : Set α} {x : α} (h : x ∈ s \ t) : x ∉ t

{α : Type u}
{s t : Set α}
{x : α}
(h : x ∈ s \ t)


protected theorem IsPrefix.subset (hl : l₁ <+: l₂) : l₁ ⊆ l₂

∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁ ⊆ l₂


lemma egauge_lt_iff : egauge 𝕜 s x < r ↔ ∃ c : 𝕜, x ∈ c • s ∧ ‖c‖₊ < r

{𝕜 : Type u_1}
[NNNorm 𝕜]
{E : Type u_2}
[SMul 𝕜 E]
{s : Set E}
{x : E}
{r : ℝ≥0∞}

egauge 𝕜 s x < r ↔ ∃ c, x ∈ c • s ∧ ↑‖c‖₊ < r


(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)
(ha : p a := by cfc_tac)


theorem _root_.Function.Injective.wSameSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).WSameSide (f x) (f y) ↔ s.WSameSide x y

{R : Type u_1}
{V : Type u_2}
{V' : Type u_3}
{P : Type u_4}
{P' : Type u_5}
[StrictOrderedCommRing R]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
[AddCommGroup V']
[Module R V']
[AddTorsor V' P']
{s : AffineSubspace R P}
{x y : P}
{f : P →ᵃ[R] P'}
(hf : Function.Injective ⇑f)

(AffineSubspace.map f s).WSameSide (f x) (f y) ↔ s.WSameSide x y


@[fun_prop]
protected theorem HasStrictFDerivAt.iterate {f : E → E} {f' : E →L[𝕜] E}
    (hf : HasStrictFDerivAt f f' x) (hx : f x = x) (n : ℕ) :
    HasStrictFDerivAt f^[n] (f' ^ n) x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{x : E}
{f : E → E}
{f' : E →L[𝕜] E}
(hf : HasStrictFDerivAt f f' x)
(hx : f x = x)
(n : ℕ)


theorem card_aux₁ (hucard : u.card = m * 4 ^ P.parts.card + a) :
    (4 ^ P.parts.card - a) * m + a * (m + 1) = u.card


theorem Basis'.basis_inter_ground (hIX : M.Basis' I X) : M.Basis I (X ∩ M.E)

{α : Type u_1}
{M : Matroid α}
{I X : Set α}
(hIX : M.Basis' I X)


@[simp]
theorem compContinuousLinearMap_applyComposition {n : ℕ} (p : FormalMultilinearSeries 𝕜 F G)
    (f : E →L[𝕜] F) (c : Composition n) (v : Fin n → E) :
    (p.compContinuousLinearMap f).applyComposition c v = p.applyComposition c (f ∘ v)

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
{G : Type u_4}
[CommRing 𝕜]
[AddCommGroup E]
[AddCommGroup F]
[AddCommGroup G]
[Module 𝕜 E]
[Module 𝕜 F]
[Module 𝕜 G]
[TopologicalSpace E]
[TopologicalSpace F]
[TopologicalSpace G]
[TopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E]
[TopologicalAddGroup F]
[ContinuousConstSMul 𝕜 F]
[TopologicalAddGroup G]
[ContinuousConstSMul 𝕜 G]
{n : ℕ}
(p : FormalMultilinearSeries 𝕜 F G)
(f : E →L[𝕜] F)
(c : Composition n)
(v : Fin n → E)

(p.compContinuousLinearMap f).applyComposition c v = p.applyComposition c (⇑f ∘ v)


/-- A σ-compact measure zero subset is meagre.
(More generally, every Fσ set of measure zero is meagre.) -/
lemma IsMeagre.of_isSigmaCompact_null [T2Space X] (h₁s : IsSigmaCompact s) (h₂s : μ s = 0) :
    IsMeagre s

{X : Type u_1}
[TopologicalSpace X]
[MeasurableSpace X]
{s : Set X}
{μ : MeasureTheory.Measure X}
[μ.IsOpenPosMeasure]
[T2Space X]
(h₁s : IsSigmaCompact s)
(h₂s : μ s = 0)


@[reassoc (attr := simp)]
theorem triangle_assoc_comp_right (X Y : C) :
    (α_ X (𝟙_ C) Y).inv ≫ ((ρ_ X).hom ▷ Y) = X ◁ (λ_ Y).hom

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

CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X (𝟙_ C) Y).inv
    (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.rightUnitor X).hom Y) =
  CategoryTheory.MonoidalCategory.whiskerLeft X (CategoryTheory.MonoidalCategory.leftUnitor Y).hom


/-- Symmetric statement to `Finset.image₂_image_left_anticomm`. -/
theorem image_image₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (image₂ f s t).image g = image₂ f' (t.image g') s

{f : α → β → γ}

(h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a)

Finset.image g (Finset.image₂ f s t) = Finset.image₂ f' (Finset.image g' t) s


protected theorem neg_lt_of_neg_lt {a b : Int} (h : -a < b) : -b < a


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

(c : CategoryTheory.Limits.BinaryBicone P Q)

CategoryTheory.Limits.BinaryCofan.inl c.toCocone = c.inl


theorem irreducibleComponent_property (x : X) :
    IsPreirreducible (irreducibleComponent x) ∧
      {x} ⊆ irreducibleComponent x ∧
        ∀ u, IsPreirreducible u → irreducibleComponent x ⊆ u → u = irreducibleComponent x

{X : Type u_1}
[TopologicalSpace X]
(x : X)

IsPreirreducible (irreducibleComponent x) ∧
  {x} ⊆ irreducibleComponent x ∧
    ∀ (u : Set X), IsPreirreducible u → irreducibleComponent x ⊆ u → u = irreducibleComponent x


theorem eq_of_not_mem_of_mem_insert (ha : b ∈ insert a s) (hb : b ∉ s) : b = a

{α : Type u_1}
[DecidableEq α]
{s : Finset α}
{a b : α}
(ha : b ∈ insert a s)
(hb : b ∉ s)


theorem map_matrix_mul (M : Matrix m n α) (N : Matrix n o α) (i : m) (j : o) (f : α →+* β) :
    f ((M * N) i j) = (M.map f * N.map f) i j

{m : Type u_2}
{n : Type u_3}
{o : Type u_4}
{α : Type v}
{β : Type w}
[Fintype n]
[NonAssocSemiring α]
[NonAssocSemiring β]
(M : Matrix m n α)
(N : Matrix n o α)
(i : m)
(j : o)
(f : α →+* β)

f ((M * N) i j) = (M.map ⇑f * N.map ⇑f) i j


theorem apply_symm_apply_eq_coordChangeL (e e' : Trivialization F (π F E)) [e.IsLinear R]
    [e'.IsLinear R] {b : B} (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    e' (e.toPartialHomeomorph.symm (b, v)) = (b, e.coordChangeL R e' b v)

[TopologicalSpace (Bundle.TotalSpace F E)]

(e e' : Trivialization F Bundle.TotalSpace.proj)

↑e' (↑e.symm (b, v)) = (b, (Trivialization.coordChangeL R e e' b) v)


/-- Given a morphism of short complexes `φ : S₁ ⟶ S₂` in an abelian category, if `S₁.g = 0`
(e.g when `S₁` is of the form `S₁.X₁ ⟶ S₁.X₂ ⟶ 0`) and both `S₂.f` and `S₂.g` are zero
(e.g when `S₂` is of the form `0 ⟶ S₂.X₂ ⟶ 0`), then `φ` is a quasi-isomorphism iff
the obvious short complex `S₁.X₂ ⟶ S₁.X₂ ⟶ S₂.X₂` is exact and `φ.τ₂` is an epi). -/
lemma quasiIso_iff_of_zeros' {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (hg₂ : S₂.g = 0) :
    QuasiIso φ ↔
      (ShortComplex.mk S₁.f φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero])).Exact ∧ Epi φ.τ₂

{C : Type u_1}
[CategoryTheory.Category.{u_3, u_1} C]
[CategoryTheory.Abelian C]
{S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂)
(hg₁ : S₁.g = 0)
(hf₂ : S₂.f = 0)
(hg₂ : S₂.g = 0)

CategoryTheory.ShortComplex.QuasiIso φ ↔ (CategoryTheory.ShortComplex.mk S₁.f φ.τ₂ ⋯).Exact ∧ CategoryTheory.Epi φ.τ₂


@[simp] lemma shatters_shatterer : 𝒜.shatterer.Shatters s ↔ 𝒜.Shatters s

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


theorem right_dom_of_mod_dom [Mod α] {a b : Part α} (hab : Dom (a % b)) : b.Dom

{α : Type u_1}
[Mod α]
{a b : Part α}
(hab : (a % b).Dom)


/-- A topological space is **Alexandrov-discrete** or **finitely generated** if the intersection of
a family of open sets is open. -/
class AlexandrovDiscrete (α : Type*) [TopologicalSpace α] : Prop where
  /-- The intersection of a family of open sets is an open set. Use `isOpen_sInter` in the root
  namespace instead. -/
  protected isOpen_sInter : ∀ S : Set (Set α), (∀ s ∈ S, IsOpen s) → IsOpen (⋂₀ S)

{α : Type u_1}
[TopologicalSpace α]
[self : AlexandrovDiscrete α]
(S : Set (Set α))


@[simp]
theorem cells_sup (μ ν : YoungDiagram) : (μ ⊔ ν).cells = μ.cells ∪ ν.cells


@[simp]
theorem congr_refl : congr (LinearEquiv.refl R M) = LinearEquiv.refl R _

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]

LinearMap.BilinForm.congr (LinearEquiv.refl R M) = LinearEquiv.refl R (LinearMap.BilinForm R M)


/-- Dirac delta measures at two points are equal if and only if the two points are equal,
assuming the measurable space separates points. -/
lemma dirac_eq_dirac_iff [SeparatesPoints α] {x y : α} :
    Measure.dirac x = Measure.dirac y ↔ x = y

{α : Type u_1}
[MeasurableSpace α]
[MeasurableSpace.SeparatesPoints α]
{x y : α}

MeasureTheory.Measure.dirac x = MeasureTheory.Measure.dirac y ↔ x = y


theorem split_add_lt {o e n a m} [NF o] (h : split o = (oadd e n a, m)) :
    repr a + m < ω ^ repr e

{o e : ONote}
{n : ℕ+}
{a : ONote}
{m : ℕ}
[o.NF]
(h : o.split = (e.oadd n a, m))


theorem HasStrictDerivAt.hasDerivAt (h : HasStrictDerivAt f f' x) : HasDerivAt f f' x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{F : Type v}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : 𝕜 → F}
{f' : F}
{x : 𝕜}
(h : HasStrictDerivAt f f' x)


@[simp]
theorem map_units_smul {X Y : C} (r : Rˣ) (f : X ⟶ Y) : F.map (r • f) = r • F.map f

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


@[simp] theorem ofDistribMulAction_ρ_apply_apply (g : G) (a : A) :
    (ofDistribMulAction k G A).ρ g a = g • a

(k G A : Type u)
[CommRing k]
[Monoid G]
[AddCommGroup A]
[Module k A]
[DistribMulAction G A]
[SMulCommClass G k A]
(g : G)
(a : A)

((Rep.ofDistribMulAction k G A).ρ g) a = g • a


protected theorem Tendsto.Ico {l₁ l₂ : Filter α} [TendstoIxxClass Ico l₁ l₂] {lb : Filter β}
    {u₁ u₂ : β → α} (h₁ : Tendsto u₁ lb l₁) (h₂ : Tendsto u₂ lb l₁) :
    Tendsto (fun x => Ico (u₁ x) (u₂ x)) lb l₂.smallSets

{α : Type u_1}
{β : Type u_2}
[Preorder α]
{l₁ l₂ : Filter α}
[Filter.TendstoIxxClass Set.Ico l₁ l₂]
{lb : Filter β}
{u₁ u₂ : β → α}
(h₁ : Filter.Tendsto u₁ lb l₁)
(h₂ : Filter.Tendsto u₂ lb l₁)

Filter.Tendsto (fun x => Set.Ico (u₁ x) (u₂ x)) lb l₂.smallSets


@[simp]
theorem toDual_wcovBy_toDual_iff : toDual b ⩿ toDual a ↔ a ⩿ b

OrderDual.toDual b ⩿ OrderDual.toDual a ↔ a ⩿ b


@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_inj {s t : NonemptyInterval α} : (s : Interval α) = t ↔ s = t

{α : Type u_1}
[LE α]
{s t : NonemptyInterval α}


@[simp] lemma zero_le_log_iff {x : ℝ≥0∞} : 0 ≤ log x ↔ 1 ≤ x


/-- A simplicial object that is isomorphic to a split simplicial object is split. -/
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y

{X Y : CategoryTheory.SimplicialObject C}

(s.ofIso e).ι n = s.ι n ≫ e.hom.app (Opposite.op [n])


protected theorem sub_lt_sub_right {a b : Int} (h : a < b) (c : Int) : a - c < b - c


theorem div_opow_log_pos (b : Ordinal) {o : Ordinal} (ho : o ≠ 0) : 0 < o / (b ^ log b o)

(b : Ordinal.{u_1})
{o : Ordinal.{u_1}}
(ho : o ≠ 0)


/-- The kernel of `biprod.fst : X ⊞ Y ⟶ X` is `Y`. -/
@[simps!]
def kernelBiprodFstIso : kernel (biprod.fst : X ⊞ Y ⟶ X) ≅ Y

CategoryTheory.Limits.kernelBiprodFstIso.hom =
  (CategoryTheory.Limits.biprod.isKernelFstKernelFork X Y).lift
    (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.parallelPair CategoryTheory.Limits.biprod.fst 0))


@[to_additive sum_strictMono]
theorem prod_strictMono' : StrictMono fun f : ι → M ↦ ∏ x, f x

{ι : Type u_1}
{M : Type u_4}
[Fintype ι]
[OrderedCancelAddCommMonoid M]


theorem SemilatticeInf.dual_dual (α : Type*) [H : SemilatticeInf α] :
    OrderDual.instSemilatticeInf αᵒᵈ = H


/-- Inserting on the left and right commutes. -/
theorem insertRight_insertLeft {x x' x'' : PGame} :
    insertRight (insertLeft x x') x'' = insertLeft (insertRight x x'') x'

(x.insertLeft x').insertRight x'' = (x.insertRight x'').insertLeft x'


@[to_additive]
protected lemma mul_eq_one_iff_inv_eq (h : IsUnit a) : a * b = 1 ↔ a⁻¹ = b

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


lemma flip_injective {F₁ F₂ : B ⥤ C ⥤ D} (h : F₁.flip = F₂.flip) :
    F₁ = F₂

{F₁ F₂ : CategoryTheory.Functor B (CategoryTheory.Functor C D)}


/-- Compact sets are σ-compact. -/
lemma IsCompact.isSigmaCompact {s : Set X} (hs : IsCompact s) : IsSigmaCompact s

{X : Type u_1}
[TopologicalSpace X]
{s : Set X}
(hs : IsCompact s)


@[simp]
theorem inv_whiskerLeft (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h) [IsIso η] :
    inv (f ◁ η) = f ◁ inv η

{B : Type u}
[CategoryTheory.Bicategory B]
{a b c : B}
(f : a ⟶ b)
{g h : b ⟶ c}
(η : g ⟶ h)
[CategoryTheory.IsIso η]

CategoryTheory.inv (CategoryTheory.Bicategory.whiskerLeft f η) =
  CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.inv η)


theorem IsUniversalColimit.whiskerEquivalence {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} (hc : IsUniversalColimit c) :
    IsUniversalColimit (c.whisker e.functor)

(hc : CategoryTheory.IsUniversalColimit c)

CategoryTheory.IsUniversalColimit (CategoryTheory.Limits.Cocone.whisker e.functor c)


theorem deleteFar_iff :
    G.DeleteFar p r ↔ ∀ ⦃H : SimpleGraph _⦄ [DecidableRel H.Adj],
      H ≤ G → p H → r ≤ G.edgeFinset.card - H.edgeFinset.card

{V : Type u_1}
{G : SimpleGraph V}
{𝕜 : Type u_2}
[OrderedRing 𝕜]
[Fintype (Sym2 V)]
[Fintype ↑G.edgeSet]
{p : SimpleGraph V → Prop}
{r : 𝕜}

G.DeleteFar p r ↔
  ∀ ⦃H : SimpleGraph V⦄ [inst : DecidableRel H.Adj], H ≤ G → p H → r ≤ ↑G.edgeFinset.card - ↑H.edgeFinset.card


theorem compl_frontier_eq_union_interior :
    (frontier s)ᶜ = interior s ∪ interior sᶜ

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


@[simp]
theorem iSup_eq_bot : iSup s = ⊥ ↔ ∀ i, s i = ⊥

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


@[to_additive]
theorem lt_one_of_mul_lt_left [ContravariantClass α α (swap (· * ·)) (· < ·)] {a b : α}
    (h : a * b < b) :
    a < 1

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


@[simp]
theorem univ_eq : (univ : Set Bool) = {false, true}


theorem mfderivWithin_snd {s : Set (M × M')} {x : M × M'}
    (hxs : UniqueMDiffWithinAt (I.prod I') s x) :
    mfderivWithin (I.prod I') I' Prod.snd s x =
      ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)


protected theorem coe_eq_zero {x : S} : (x : A) = 0 ↔ x = 0

{R : Type u}
{A : Type v}
[CommSemiring R]
[NonUnitalNonAssocSemiring A]
[Module R A]
[Star A]
(S : NonUnitalStarSubalgebra R A)
{x : ↥S}


theorem Antiperiodic.const_smul₀ [AddCommMonoid α] [Neg β] [DivisionSemiring γ] [Module γ α]
    (h : Antiperiodic f c) {a : γ} (ha : a ≠ 0) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c)

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

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


theorem real_inner_self_eq_norm_mul_norm (x : F) : ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖

{F : Type u_3}
[NormedAddCommGroup F]
[InnerProductSpace ℝ F]
(x : F)


lemma disjoint_or_nonempty_inter (s t : Set α) : Disjoint s t ∨ (s ∩ t).Nonempty


/-- The continuous homomorphism given by inclusion of the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the first factor."]
def inl : ContinuousMonoidHom A (A × B)

(A : Type u_2)
(B : Type u_3)
[Monoid A]
[Monoid B]
[TopologicalSpace A]
[TopologicalSpace B]
(i : A)

(ContinuousMonoidHom.inl A B) i =
  ((ContinuousMonoidHom.id A).toMonoidHom i, (ContinuousMonoidHom.one A B).toMonoidHom i)


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

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

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


@[simp]
theorem mk_natCast (n : ℕ) : (⟨n, n.cast_nonneg'⟩ : { x : α // 0 ≤ x }) = n

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

⟨↑n, ⋯⟩ = ↑n


/-- If the tangent of a complex number is well-defined,
then it is equal to zero iff the number is equal to `k * π` for an integer `k`.

See also `Complex.tan_eq_zero_iff` for a version that takes into account junk values of `θ`. -/
theorem tan_eq_zero_iff' {θ : ℂ} (hθ : cos θ ≠ 0) : tan θ = 0 ↔ ∃ k : ℤ, k * π = θ

Complex.tan θ = 0 ↔ ∃ k, ↑k * ↑Real.pi = θ


lemma injOn_dualMap_subtype_span_range_range {ι : Type*} [NoZeroSMulDivisors ℤ M]
    {r : ι ↪ M} {c : ι → Dual R M} (hfin : (range r).Finite)
    (h_two : ∀ i, c i (r i) = 2)
    (h_mapsTo : ∀ i, MapsTo (preReflection (r i) (c i)) (range r) (range r)) :
    InjOn (span R (range r)).subtype.dualMap (range c)

(h_mapsTo : ∀ (i : ι), Set.MapsTo (⇑(Module.preReflection (r i) (c i))) (Set.range ⇑r) (Set.range ⇑r))

Set.InjOn (⇑(Submodule.span R (Set.range ⇑r)).subtype.dualMap) (Set.range c)


@[simp] theorem add_imK : (a + b).imK = a.imK + b.imK

{R : Type u_3}
[CommRing R]
{c₁ c₂ : R}
(a b : ℍ[R,c₁,c₂])


theorem smul_monoidHom_apply (c : Mᵈᵐᵃ) (f : A →* B) (a : A) : (c • f) a = f (mk.symm c • a)

{M : Type u_5}
{A : Type u_7}
{B : Type u_8}
[Monoid M]
[Monoid A]
[MulDistribMulAction M A]
[MulOneClass B]
(c : Mᵈᵐᵃ)
(f : A →* B)
(a : A)


lemma smul_pos' [SMulPosStrictMono α β] (ha : 0 < a) (hb : 0 < b) : 0 < a • b

{α : Type u_1}
{β : Type u_2}
{a : α}
{b : β}
[Zero α]
[Zero β]
[SMulWithZero α β]
[Preorder α]
[Preorder β]
[SMulPosStrictMono α β]
(ha : 0 < a)
(hb : 0 < b)


theorem lTensor_comp_apply (x : M ⊗[R] N) :
    (g.comp f).lTensor M x = (g.lTensor M) ((f.lTensor M) x)

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

(LinearMap.lTensor M (g ∘ₗ f)) x = (LinearMap.lTensor M g) ((LinearMap.lTensor M f) x)


protected theorem Finite.false [Infinite α] (_ : Finite α) : False


theorem Prime.mul_eq_prime_sq_iff {x y p : ℕ} (hp : p.Prime) (hx : x ≠ 1) (hy : y ≠ 1) :
    x * y = p ^ 2 ↔ x = p ∧ y = p

{x y p : ℕ}
(hp : Nat.Prime p)
(hx : x ≠ 1)
(hy : y ≠ 1)


theorem Ioo_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ioo a b ∈ 𝓝 x

{α : Type u}
[TopologicalSpace α]
[LinearOrder α]
[OrderClosedTopology α]
{a b x : α}
(ha : a < x)
(hb : x < b)


/-- `Polynomial.eval₂` as an `AlgHom` for noncommutative algebras.

This is `Polynomial.eval₂RingHom'` for `AlgHom`s. -/
@[simps!]
def eval₂AlgHom' (f : A →ₐ[R] B) (b : B) (hf : ∀ a, Commute (f a) b) : A[X] →ₐ[R] B

{R : Type u}
{A : Type z}
{B : Type u_2}
[CommSemiring R]
[Semiring A]
[Semiring B]
[Algebra R A]
[Algebra R B]
(f : A →ₐ[R] B)
(b : B)
(hf : ∀ (a : A), Commute (f a) b)
(p : A[X])

(Polynomial.eval₂AlgHom' f b hf) p = Polynomial.eval₂ (↑f) b p


@[to_additive]
theorem preimage_mul_left_one' : preimage 1 (a⁻¹ * ·) (mul_right_injective _).injOn = {a}

Finset.preimage 1 (fun x => a⁻¹ * x) ⋯ = {a}


theorem addHaar_singleton_add_smul_div_singleton_add_smul {r : ℝ} (hr : r ≠ 0) (x y : E)
    (s t : Set E) : μ ({x} + r • s) / μ ({y} + r • t) = μ s / μ t

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[MeasurableSpace E]
[BorelSpace E]
[FiniteDimensional ℝ E]
(μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure]
{r : ℝ}
(hr : r ≠ 0)
(x y : E)
(s t : Set E)


theorem coeFn_injective : @Function.Injective (Homotopy p₀ p₁) (I × I → X) (⇑)

{X : Type u}
[TopologicalSpace X]
{x₀ x₁ : X}
{p₀ p₁ : Path x₀ x₁}


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

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

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


theorem dualPairing_nondegenerate (W : Subspace K V₁) : W.dualPairing.Nondegenerate

{K : Type uK}
[Field K]
{V₁ : Type uV₁}
[AddCommGroup V₁]
[Module K V₁]
(W : Subspace K V₁)


theorem smul_eq_mulAut_conj (g : ConjAct G) (h : G) : g • h = MulAut.conj (ofConjAct g) h

{G : Type u_3}
[Group G]
(g : ConjAct G)
(h : G)

g • h = (MulAut.conj (ConjAct.ofConjAct g)) h


/-- A function `f : X → Y` between topological spaces is inducing if the topology on `X` is induced
by the topology on `Y` through `f`, meaning that a set `s : Set X` is open iff it is the preimage
under `f` of some open set `t : Set Y`. -/
@[mk_iff]
structure Inducing (f : X → Y) : Prop where
  /-- The topology on the domain is equal to the induced topology. -/
  induced : tX = tY.induced f

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


protected theorem Ne.dite_ne_left_iff (h : ∀ h, a ≠ B h) : dite P (fun _ ↦ a) B ≠ a ↔ ¬P

{α : Sort u_1}
{P : Prop}
[Decidable P]
{a : α}
{B : ¬P → α}
(h : ∀ (h : ¬P), a ≠ B h)


protected lemma le_max_iff : (a : WithZero α) ≤ max (b : WithZero α) c ↔ a ≤ max b c

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


@[simp]
theorem lt_one_iff_zero {a : Ordinal} : a < 1 ↔ a = 0


@[to_additive max_neg_neg]
theorem max_inv_inv' (a b : α) : max a⁻¹ b⁻¹ = (min a b)⁻¹

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


/-- One can bound the `k`-th derivative of the Fourier integral of `f`, multiplied by `(L v w) ^ n`,
in terms of integrals of iterated derivatives of `f` (of order up to `n`) multiplied by `‖v‖ ^ i`
(for `i ≤ k`). -/
lemma pow_mul_norm_iteratedFDeriv_fourierIntegral_le [FiniteDimensional ℝ V]
    {μ : Measure V} [Measure.IsAddHaarMeasure μ] {K N : ℕ∞} (hf : ContDiff ℝ N f)
    (h'f : ∀ (k n : ℕ), k ≤ K → n ≤ N → Integrable (fun v ↦ ‖v‖^k * ‖iteratedFDeriv ℝ n f v‖) μ)
    {k n : ℕ} (hk : k ≤ K) (hn : n ≤ N) (v : V) (w : W) :
    |L v w| ^ n * ‖(iteratedFDeriv ℝ k (fourierIntegral 𝐞 μ L.toLinearMap₂ f)) w‖ ≤
      ‖v‖ ^ n * (2 * π * ‖L‖) ^ k * (2 * k + 2) ^ n *
        ∑ p in Finset.range (k + 1) ×ˢ Finset.range (n + 1),
          ∫ v, ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ

(h'f : ∀ (k n : ℕ), ↑k ≤ K → ↑n ≤ N → MeasureTheory.Integrable (fun v => ‖v‖ ^ k * ‖iteratedFDeriv ℝ n f v‖) μ)

|(L v) w| ^ n * ‖iteratedFDeriv ℝ k (VectorFourier.fourierIntegral 𝐞 μ L.toLinearMap₂ f) w‖ ≤
  ‖v‖ ^ n * (2 * π * ‖L‖) ^ k * (2 * ↑k + 2) ^ n *
    ∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ∫ (v : V), ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ ∂μ


/-- In a canonically-ordered monoid, a product bounds each of its terms.

See also `Finset.single_le_prod'`. -/
@[to_additive "In a canonically-ordered additive monoid, a sum bounds each of its terms.

See also `Finset.single_le_sum`."]
lemma _root_.CanonicallyOrderedCommMonoid.single_le_prod {i : ι} (hi : i ∈ s) :
    f i ≤ ∏ j ∈ s, f j

{ι : Type u_1}
{M : Type u_4}
[CanonicallyOrderedAddCommMonoid M]
{f : ι → M}
{s : Finset ι}
{i : ι}
(hi : i ∈ s)


theorem coe_nonneg (x : Icc (0 : α) 1) : 0 ≤ (x : α)

{α : Type u_1}
[OrderedSemiring α]
(x : ↑(Set.Icc 0 1))


theorem normSq_kahler (x y : E) : Complex.normSq (o.kahler x y) = ‖x‖ ^ 2 * ‖y‖ ^ 2

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

Complex.normSq ((o.kahler x) y) = ‖x‖ ^ 2 * ‖y‖ ^ 2


@[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_inv (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U ≫
    (smoothSheafCommRing.forgetStalk IM I M R x).inv =
    (forget CommRingCat).map
      (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U)

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{EM : Type u_2}
[NormedAddCommGroup EM]
[NormedSpace 𝕜 EM]
{HM : Type u_3}
[TopologicalSpace HM]
(IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_5}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
(M : Type u)
[TopologicalSpace M]
[ChartedSpace HM M]
(R : Type u)
[TopologicalSpace R]
[ChartedSpace H R]
[CommRing R]
[SmoothRing I R]
(x : ↑(TopCat.of M))
(U : (TopologicalSpace.OpenNhds x)ᵒᵖ)

CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.colimit.ι ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheaf IM I M R).presheaf)
      U)
    (smoothSheafCommRing.forgetStalk IM I M R x).inv =
  (CategoryTheory.forget CommRingCat).map
    (CategoryTheory.Limits.colimit.ι
      ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U)


/-- Scalar multiplication preserves neighborhoods. -/
theorem set_smul_mem_nhds_smul {c : G₀} {s : Set α} {x : α} (hs : s ∈ 𝓝 x) (hc : c ≠ 0) :
    c • s ∈ 𝓝 (c • x : α)

{α : Type u_2}
{G₀ : Type u_6}
[GroupWithZero G₀]
[MulAction G₀ α]
[TopologicalSpace α]
[ContinuousConstSMul G₀ α]
{c : G₀}
{s : Set α}
{x : α}
(hs : s ∈ 𝓝 x)
(hc : c ≠ 0)


lemma IsSeparable.prod {β : Type*} [TopologicalSpace β]
    {s : Set α} {t : Set β} (hs : IsSeparable s) (ht : IsSeparable t) :
    IsSeparable (s ×ˢ t)

{α : Type u}
[t : TopologicalSpace α]
{β : Type u_2}
[TopologicalSpace β]
{s : Set α}

∀ {t_1 : Set β},
  TopologicalSpace.IsSeparable s → TopologicalSpace.IsSeparable t_1 → TopologicalSpace.IsSeparable (s ×ˢ t_1)


/-- An angle in a right-angled triangle expressed using `arctan`. -/
theorem oangle_add_right_eq_arctan_of_oangle_eq_pi_div_two {x y : V} (h : o.oangle x y = ↑(π / 2)) :
    o.oangle x (x + y) = Real.arctan (‖y‖ / ‖x‖)

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

o.oangle x (x + y) = ↑(Real.arctan (‖y‖ / ‖x‖))


theorem completeSpace_extension {m : β → α} (hm : UniformInducing m) (dense : DenseRange m)
    (h : ∀ f : Filter β, Cauchy f → ∃ x : α, map m f ≤ 𝓝 x) : CompleteSpace α

(h : ∀ (f : Filter β), Cauchy f → ∃ x, Filter.map m f ≤ 𝓝 x)


/-- The natural isomorphism expressing that functors `Karoubi C ⥤ Karoubi D` obtained
using `functorExtension₁` actually extends the original functors `C ⥤ Karoubi D`. -/
@[simps!]
def functorExtension₁CompWhiskeringLeftToKaroubiIso :
    functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C) ≅ 𝟭 _

(X : CategoryTheory.Functor C (CategoryTheory.Idempotents.Karoubi D))

∀ (X_1 : C),
  (((CategoryTheory.Idempotents.functorExtension₁CompWhiskeringLeftToKaroubiIso C D).hom.app X).app X_1).f =
    (X.obj X_1).p


/-- If `e : C ≌ D` is an equivalence of categories, and `iso : e.functor ≅ G` is
an isomorphism, then there is an equivalence of categories whose inverse is `G`. -/
@[simps!]
def changeInverse (e : C ≌ D) {G : D ⥤ C} (iso : e.inverse ≅ G) : C ≌ D

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D)
{G : CategoryTheory.Functor D C}
(iso : e.inverse ≅ G)
(X : D)

(e.changeInverse iso).counitIso.inv.app X =
  CategoryTheory.CategoryStruct.comp (e.counitIso.inv.app X) (e.functor.map (iso.hom.app X))


@[simp]
theorem map_C : ∀ a : R, map f (C a : MvPolynomial σ R) = C (f a)

{R : Type u}
{S₁ : Type v}
{σ : Type u_1}
[CommSemiring R]
[CommSemiring S₁]
(f : R →+* S₁)
(a : R)

(MvPolynomial.map f) (MvPolynomial.C a) = MvPolynomial.C (f a)


theorem unbounded_le_univ [LE α] [NoTopOrder α] : Unbounded (· ≤ ·) (@Set.univ α)

Set.Unbounded (fun x x_1 => x ≤ x_1) Set.univ


/-- In a quiver with involutive inverses, the star and costar at every vertex are equivalent.
This map is induced by `Quiver.reverse`. -/
@[simps]
def Quiver.starEquivCostar (u : U) : Quiver.Star u ≃ Quiver.Costar u

{U : Type u_1}
[Quiver U]
[Quiver.HasInvolutiveReverse U]
(u : U)
(e : Quiver.Star u)

((Quiver.starEquivCostar u) e).snd = Quiver.reverse e.snd


@[to_additive (attr := simp)]
theorem smul_empty : s • (∅ : Set β) = ∅

{α : Type u_2}
{β : Type u_3}
[SMul α β]
{s : Set α}


@[simp]
protected theorem add_sub_cancel_left (ha : a ≠ ∞) : a + b - a = b


protected theorem inv_mul_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a⁻¹ * a = 1


/-- The equivalence of categories expressing left unity of products of categories.  -/
@[simps]
def leftUnitorEquivalence : Discrete (PUnit : Type w) × C ≌ C

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

(CategoryTheory.prod.leftUnitorEquivalence C).counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.prod.leftInverseUnitor C ⋙ CategoryTheory.prod.leftUnitor C)


theorem mul_distrib_left (xs ys zs : IntList) : (xs + ys) * zs = xs * zs + ys * zs


theorem Real.sSup_smul_of_nonpos (ha : a ≤ 0) (s : Set ℝ) : sSup (a • s) = a • sInf s

{α : Type u_2}
[LinearOrderedField α]
[Module α ℝ]
[OrderedSMul α ℝ]
{a : α}
(ha : a ≤ 0)
(s : Set ℝ)


/-- Composite functors induce composite functors on matrix categories.
-/
@[simps!]
def mapMatComp {E : Type*} [Category.{v₁} E] [Preadditive E] (F : C ⥤ D) [Functor.Additive F]
    (G : D ⥤ E) [Functor.Additive G] : (F ⋙ G).mapMat_ ≅ F.mapMat_ ⋙ G.mapMat_

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Preadditive C]
{D : Type u_1}
[CategoryTheory.Category.{v₁, u_1} D]
[CategoryTheory.Preadditive D]
{E : Type u_2}
[CategoryTheory.Category.{v₁, u_2} E]
[CategoryTheory.Preadditive E]
(F : C ⥤ D)
[F.Additive]
(G : D ⥤ E)
[G.Additive]
(X : CategoryTheory.Mat_ C)

(F.mapMatComp G).inv.app X = 𝟙 ((F ⋙ G).mapMat_.obj X)


@[simp]
theorem nonempty_Ici : (Ici a).Nonempty


@[to_additive]
theorem setLIntegral_eq_tsum (h : IsFundamentalDomain G s μ) (f : α → ℝ≥0∞) (t : Set α) :
    ∫⁻ x in t, f x ∂μ = ∑' g : G, ∫⁻ x in t ∩ g • s, f x ∂μ

[MeasureTheory.VAddInvariantMeasure G α μ]

(h : MeasureTheory.IsAddFundamentalDomain G s μ)

(f : α → ℝ≥0∞)

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


theorem symm_injective : Function.Injective (symm : α ≃o β → β ≃o α)

{α : Type u_2}
{β : Type u_3}
[LE α]
[LE β]


@[to_additive]
theorem mul_left_cancel : a * b = a * c → b = c

{G : Type u_1}
[Add G]
[IsLeftCancelAdd G]
{a b c : G}


theorem Wequiv.refl (x : q.P.W) : Wequiv x x

{F : Type u → Type u}
[q : QPF F]
(x : (QPF.P F).W)


theorem supPrime_iff_not_isMin : SupPrime a ↔ ¬IsMin a


theorem smul_right {R : Type*} [Semiring R] [DistribMulAction R N] [ContinuousConstSMul R N]
    (r : R) (h : v ⟂ᵥ w) : v ⟂ᵥ r • w

{α : Type u_1}
{m : MeasurableSpace α}
{M : Type u_4}
{N : Type u_5}
[AddCommMonoid M]
[TopologicalSpace M]
[AddCommMonoid N]
[TopologicalSpace N]
{v : MeasureTheory.VectorMeasure α M}
{w : MeasureTheory.VectorMeasure α N}
{R : Type u_6}
[Semiring R]
[DistribMulAction R N]
[ContinuousConstSMul R N]
(r : R)
(h : v ⟂ᵥ w)


/-- The open thickening `Metric.thickening δ E` is contained in the closed thickening
`Metric.cthickening δ E` with the same radius. -/
theorem thickening_subset_cthickening (δ : ℝ) (E : Set α) : thickening δ E ⊆ cthickening δ E

{α : Type u}
[PseudoEMetricSpace α]
(δ : ℝ)
(E : Set α)

Metric.thickening δ E ⊆ Metric.cthickening δ E


theorem Continuous.subtype_map {f : X → Y} (h : Continuous f) {q : Y → Prop}
    (hpq : ∀ x, p x → q (f x)) : Continuous (Subtype.map f hpq)

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[TopologicalSpace Y]
{p : X → Prop}
{f : X → Y}
(h : Continuous f)
{q : Y → Prop}
(hpq : ∀ (x : X), p x → q (f x))


/-- Map an `Arrow` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow

{J : CategoryTheory.GrothendieckTopology C}


@[to_additive add_zsmul]
lemma zpow_add (a : G) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n

{G : Type u_3}
[Group G]
(a : G)
(m n : ℤ)


theorem ext' [T : TopologicalSpace α] {σ : Type*} {F : Ctop α σ}
    (H : ∀ a s, s ∈ 𝓝 a ↔ ∃ b, a ∈ F b ∧ F b ⊆ s) : F.toTopsp = T

(H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s)


@[simp]
theorem addHaar_preimage_smul {r : ℝ} (hr : r ≠ 0) (s : Set E) :
    μ ((r • ·) ⁻¹' s) = ENNReal.ofReal (abs (r ^ finrank ℝ E)⁻¹) * μ s

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[MeasurableSpace E]
[BorelSpace E]
[FiniteDimensional ℝ E]
(μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure]
{r : ℝ}
(hr : r ≠ 0)
(s : Set E)

μ ((fun x => r • x) ⁻¹' s) = ENNReal.ofReal |(r ^ FiniteDimensional.finrank ℝ E)⁻¹| * μ s


theorem integral_one : (∫ _ in a..b, (1 : ℝ)) = b - a


theorem const_append1 {β γ} (x : γ) {n} (α : TypeVec n) :
    TypeVec.const x (α ::: β) = appendFun (TypeVec.const x α) fun _ => x

{β : Type u_1}
{γ : Type u_2}
(x : γ)
{n : ℕ}
(α : TypeVec.{u_1} n)

TypeVec.const x (α ::: β) = (TypeVec.const x α ::: fun x_1 => x)


theorem exi_rat_seq_conv_cauchy : IsCauSeq (padicNorm p) (limSeq f)

{p : ℕ}
[Fact (Nat.Prime p)]
(f : CauSeq ℚ_[p] ⇑padicNormE)


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

∀ {X Y : CategoryTheory.ShortComplex (CategoryTheory.Functor J C)} (φ : X ⟶ Y) (j : J),
  ((CategoryTheory.ShortComplex.FunctorEquivalence.functor J C).map φ).app j =
    ((CategoryTheory.evaluation J C).obj j).mapShortComplex.map φ


theorem swap_mul_swap_mul_swap {x y z : α} (hxy : x ≠ y) (hxz : x ≠ z) :
    swap y z * swap x y * swap y z = swap z x

{α : Type u}
[DecidableEq α]
{x y z : α}
(hxy : x ≠ y)
(hxz : x ≠ z)

Equiv.swap y z * Equiv.swap x y * Equiv.swap y z = Equiv.swap z x


theorem coe_compRingHom_apply (p q : R[X]) : (compRingHom q : R[X] → R[X]) p = comp p q

{R : Type u}
[CommSemiring R]
(p q : R[X])


theorem arrow_iso_iff (P : MorphismProperty C) [RespectsIso P] {f g : Arrow C}
    (e : f ≅ g) : P f.hom ↔ P g.hom

{C : Type u}
[CategoryTheory.Category.{v, u} C]
(P : CategoryTheory.MorphismProperty C)
[P.RespectsIso]
{f g : CategoryTheory.Arrow C}
(e : f ≅ g)


@[simp]
theorem IsInternal.ofBijective_coeLinearMap_same (h : IsInternal A)
    {i : ι} (x : A i) :
    (LinearEquiv.ofBijective (coeLinearMap A) h).symm x i = x

{R : Type u}
[Semiring R]
{ι : Type v}
[dec_ι : DecidableEq ι]
{M : Type u_1}
[AddCommMonoid M]
[Module R M]
{A : ι → Submodule R M}
(h : DirectSum.IsInternal A)
{i : ι}
(x : ↥(A i))

((LinearEquiv.ofBijective (DirectSum.coeLinearMap A) h).symm ↑x) i = x


theorem isOpenMap_mkQ [TopologicalAddGroup M] : IsOpenMap S.mkQ

{R : Type u_1}
{M : Type u_2}
[Ring R]
[AddCommGroup M]
[Module R M]
[TopologicalSpace M]
(S : Submodule R M)
[TopologicalAddGroup M]


theorem ContinuousWithinAt.fst {f : α → β × γ} {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => (f x).fst) s a

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

ContinuousWithinAt (fun x => (f x).1) s a


/--
Proof that the equality of a compare function corresponds
to propositional equality and vice versa.
-/
class LawfulCmpEq (α : Type u) (cmp : α → α → Ordering) extends EqOfCmp α cmp where
  cmp_rfl {a : α} : cmp a a = .eq

{α : Type u}
{cmp : α → α → Ordering}
[self : Lake.LawfulCmpEq α cmp]
{a : α}


@[simp]
theorem sub_im (z w : ℤ√d) : (z - w).im = z.im - w.im


theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
    WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) (WithBot.ofDual a)

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

WithBot.ofDual (WithBot.map f a) = WithBot.map (⇑OrderDual.ofDual ∘ f ∘ ⇑OrderDual.toDual) (WithBot.ofDual a)


/-- `StarHomClass F R S` states that `F` is a type of `star`-preserving maps from `R` to `S`. -/
class StarHomClass (F : Type*) (R S : outParam Type*) [Star R] [Star S] [FunLike F R S] : Prop where
  /-- the maps preserve star -/
  map_star : ∀ (f : F) (r : R), f (star r) = star (f r)

{F : Type u_1}
{R : outParam (Type u_2)}
{S : outParam (Type u_3)}
[Star R]
[Star S]
[FunLike F R S]
[self : StarHomClass F R S]
(f : F)
(r : R)


theorem reindexFinsetRange_repr_self (i : ι) :
    b.reindexFinsetRange.repr (b i) =
      Finsupp.single ⟨b i, Finset.mem_image_of_mem b (Finset.mem_univ i)⟩ 1

{ι : Type u_1}
{R : Type u_3}
{M : Type u_6}
[Semiring R]
[AddCommMonoid M]
[Module R M]
(b : Basis ι R M)
[Fintype ι]
[DecidableEq M]
(i : ι)

b.reindexFinsetRange.repr (b i) = Finsupp.single ⟨b i, ⋯⟩ 1


@[to_additive]
theorem nmem_mulSupport {f : α → M} {x : α} : x ∉ mulSupport f ↔ f x = 1

{α : Type u_1}
{M : Type u_5}
[One M]
{f : α → M}
{x : α}


theorem pos_of_floor_pos (h : 0 < ⌊a⌋₊) : 0 < a

{α : Type u_2}
[LinearOrderedSemiring α]
[FloorSemiring α]
{a : α}
(h : 0 < ⌊a⌋₊)


theorem torsionBySet_le_torsionBySet_of_subset {s t : Set R} (st : s ⊆ t) :
    torsionBySet R M t ≤ torsionBySet R M s

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
{s t : Set R}
(st : s ⊆ t)

Submodule.torsionBySet R M t ≤ Submodule.torsionBySet R M s


/-- The short complex `L₀.X₃ ⟶ L₃.X₁ ⟶ L₃.X₂`. -/
@[simps]
noncomputable def L₂' : ShortComplex C

(S : CategoryTheory.ShortComplex.SnakeInput C)


lemma optionEquivRight_C (r : R) : optionEquivRight R S₁ (C r) = C (Polynomial.C r)

(R : Type u)
(S₁ : Type v)
[CommSemiring R]
(r : R)

(MvPolynomial.optionEquivRight R S₁) (MvPolynomial.C r) = MvPolynomial.C (Polynomial.C r)


@[simp]
theorem pushoutCocone_inr :
    (pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom (A := B)

(R A B : Type u)
[CommRing R]
[CommRing A]
[CommRing B]
[Algebra R A]
[Algebra R B]

(CommRingCat.pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom


theorem ofMulAction_single (g : G) (x : H) (r : k) :
    ofMulAction k G H g (Finsupp.single x r) = Finsupp.single (g • x) r

{k : Type u_1}
[CommSemiring k]
{G : Type u_2}
[Monoid G]
{H : Type u_3}
[MulAction G H]
(g : G)
(x : H)
(r : k)

((Representation.ofMulAction k G H) g) (Finsupp.single x r) = Finsupp.single (g • x) r


theorem associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : ModuleCat R} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
    (f₃ : X₃ ⟶ Y₃) :
    tensorHom (tensorHom f₁ f₂) f₃ ≫ (associator Y₁ Y₂ Y₃).hom =
      (associator X₁ X₂ X₃).hom ≫ tensorHom f₁ (tensorHom f₂ f₃)

{R : Type u}
[CommRing R]
{X₁ : ModuleCat R}
{X₂ : ModuleCat R}
{X₃ : ModuleCat R}
{Y₁ : ModuleCat R}
{Y₂ : ModuleCat R}
{Y₃ : ModuleCat R}
(f₁ : X₁ ⟶ Y₁)
(f₂ : X₂ ⟶ Y₂)
(f₃ : X₃ ⟶ Y₃)

ModuleCat.MonoidalCategory.tensorHom (ModuleCat.MonoidalCategory.tensorHom f₁ f₂) f₃ ≫
    (ModuleCat.MonoidalCategory.associator Y₁ Y₂ Y₃).hom =
  (ModuleCat.MonoidalCategory.associator X₁ X₂ X₃).hom ≫
    ModuleCat.MonoidalCategory.tensorHom f₁ (ModuleCat.MonoidalCategory.tensorHom f₂ f₃)


lemma toOpen_eq (U) :
    (by exact StructureSheaf.toOpen R U) =
    (ΓSpecIso R).inv ≫ (Spec R).presheaf.map (homOfLE le_top).op

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

AlgebraicGeometry.StructureSheaf.toOpen (↑R) U =
  (AlgebraicGeometry.Scheme.ΓSpecIso R).inv ≫ (AlgebraicGeometry.Spec R).presheaf.map (CategoryTheory.homOfLE ⋯).op


theorem zeroLocus_sup_homogeneousIdeal (I J : HomogeneousIdeal 𝒜) :
    zeroLocus 𝒜 ((I ⊔ J : HomogeneousIdeal 𝒜) : Set A) = zeroLocus _ I ∩ zeroLocus _ J

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

ProjectiveSpectrum.zeroLocus 𝒜 ↑(I ⊔ J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∩ ProjectiveSpectrum.zeroLocus 𝒜 ↑J


theorem fromGlued_injective : Function.Injective 𝒰.fromGlued.1.base

{X : AlgebraicGeometry.Scheme}
(𝒰 : X.OpenCover)


@[reassoc (attr := simp)]
lemma homologyι_naturality (φ : S₁ ⟶ S₂) [S₁.HasHomology] [S₂.HasHomology] :
    homologyMap φ ≫ S₂.homologyι = S₁.homologyι ≫ S₁.opcyclesMap φ

CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
  CategoryTheory.CategoryStruct.comp S₁.homologyι (CategoryTheory.ShortComplex.opcyclesMap φ)


/-- In a linearly ordered field with the order topology, if `f` tends to `Filter.atBot` and `g`
tends to a negative constant `C` then `f * g` tends to `Filter.atTop`. -/
theorem Filter.Tendsto.atBot_mul_neg {C : 𝕜} (hC : C < 0) (hf : Tendsto f l atBot)
    (hg : Tendsto g l (𝓝 C)) : Tendsto (fun x => f x * g x) l atTop

{𝕜 : Type u_1}
{α : Type u_2}
[LinearOrderedField 𝕜]
[TopologicalSpace 𝕜]
[OrderTopology 𝕜]
{l : Filter α}
{f g : α → 𝕜}
{C : 𝕜}
(hC : C < 0)
(hf : Filter.Tendsto f l Filter.atBot)
(hg : Filter.Tendsto g l (𝓝 C))

Filter.Tendsto (fun x => f x * g x) l Filter.atTop


@[to_additive]
theorem Contravariant.MulLECancellable [Mul α] [LE α] [ContravariantClass α α (· * ·) (· ≤ ·)]
    {a : α} :
    MulLECancellable a

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


@[simp]
theorem map₂_map_right (f₁ : α → γ → ζ) (f₂ : β → γ) :
    map₂ f₁ xs (map f₂ ys) = map₂ (fun x y => f₁ x (f₂ y)) xs ys

{α : Type u_3}
{n : ℕ}
{β : Type u_4}
(xs : Mathlib.Vector α n)
(ys : Mathlib.Vector β n)
{γ : Type u_1}
{ζ : Type u_2}
(f₁ : α → γ → ζ)
(f₂ : β → γ)

Mathlib.Vector.map₂ f₁ xs (Mathlib.Vector.map f₂ ys) = Mathlib.Vector.map₂ (fun x y => f₁ x (f₂ y)) xs ys


theorem aeval_algebraMap_eq_zero_iff_of_injective {x : σ → A} {p : MvPolynomial σ R}
    (h : Function.Injective (algebraMap A B)) :
    aeval (algebraMap A B ∘ x) p = 0 ↔ aeval x p = 0

(h : Function.Injective ⇑(algebraMap A B))

(MvPolynomial.aeval (⇑(algebraMap A B) ∘ x)) p = 0 ↔ (MvPolynomial.aeval x) p = 0


theorem comp_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
    (ho : type r = o) (f : ∀ a < o, α) (g : α → β) :
    g ∘ familyOfBFamily' r ho f = familyOfBFamily' r ho fun i hi => g (f i hi)

{α : Type u_1}
{β : Type u_2}
{ι : Type u}
(r : ι → ι → Prop)
[IsWellOrder ι r]
{o : Ordinal.{u}}
(ho : Ordinal.type r = o)
(f : (a : Ordinal.{u}) → a < o → α)
(g : α → β)

g ∘ Ordinal.familyOfBFamily' r ho f = Ordinal.familyOfBFamily' r ho fun i hi => g (f i hi)


@[ext]
theorem ext {I J : Ideal α} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J

{α : Type u}
[Semiring α]
{I J : Ideal α}
(h : ∀ (x : α), x ∈ I ↔ x ∈ J)


theorem ContMDiff.of_le (hf : ContMDiff I I' n f) (le : m ≤ n) : ContMDiff I I' m f

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{E' : Type u_5}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_6}
[TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7}
[TopologicalSpace M']
[ChartedSpace H' M']
{f : M → M'}
{m n : ℕ∞}
(hf : ContMDiff I I' n f)
(le : m ≤ n)


theorem algebraMapCLM_toLinearMap : (algebraMapCLM R A).toLinearMap = Algebra.linearMap R A

(R : Type u_1)
(A : Type u)
[CommSemiring R]
[Semiring A]
[Algebra R A]
[TopologicalSpace R]
[TopologicalSpace A]
[ContinuousSMul R A]

↑(algebraMapCLM R A) = Algebra.linearMap R A


theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
    (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤

{α : Type u_2}
[DecidableEq α]
[Fintype α]
{σ τ : Equiv.Perm α}
(h0 : Nat.Prime (Fintype.card α))
(h1 : σ.IsCycle)
(h2 : σ.support = Finset.univ)
(h3 : τ.IsSwap)


theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
    (∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y)

{α : Type u_1}
{β : Type u_2}
{f : Filter α}
{p : α × β → Prop}
{s : Set β}

(∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y)


theorem union_eq_union_iff_left : s ∪ t = s ∪ u ↔ t ⊆ s ∪ u ∧ u ⊆ s ∪ t


@[simp]
theorem mem_cthickening_iff : x ∈ cthickening δ s ↔ infEdist x s ≤ ENNReal.ofReal δ

{α : Type u}
[PseudoEMetricSpace α]
{δ : ℝ}
{s : Set α}
{x : α}

x ∈ Metric.cthickening δ s ↔ EMetric.infEdist x s ≤ ENNReal.ofReal δ


theorem normSq_add (z w : ℂ) : normSq (z + w) = normSq z + normSq w + 2 * (z * conj w).re

Complex.normSq (z + w) = Complex.normSq z + Complex.normSq w + 2 * (z * (starRingEnd ℂ) w).re


theorem enum_map (l : List α) (f : α → β) : (l.map f).enum = l.enum.map (Prod.map id f)

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

(List.map f l).enum = List.map (Prod.map id f) l.enum


@[simp]
theorem tail_think (s : Computation α) : tail (think s) = s


/-- Adding a `weightedVSub` to an `affineCombination`. -/
theorem weightedVSub_vadd_affineCombination (w₁ w₂ : ι → k) (p : ι → P) :
    s.weightedVSub p w₁ +ᵥ s.affineCombination k p w₂ = s.affineCombination k p (w₁ + w₂)

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

(s.weightedVSub p) w₁ +ᵥ (Finset.affineCombination k s p) w₂ = (Finset.affineCombination k s p) (w₁ + w₂)


/-- We can always derive `HasFiniteLimits C` by providing limits at an
arbitrary universe. -/
theorem hasFiniteLimits_of_hasFiniteLimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasLimitsOfShape J C) :
    HasFiniteLimits C

(h :
  ∀ (J : Type w) {𝒥 : CategoryTheory.SmallCategory J},
    CategoryTheory.FinCategory J → CategoryTheory.Limits.HasLimitsOfShape J C)


theorem add_top (x : PartENat) : x + ⊤ = ⊤


/-- The inverse of an equivalence of first-order languages. -/
@[simps]
protected def symm : L' ≃ᴸ L

{L : FirstOrder.Language}
{L' : FirstOrder.Language}
(e : L ≃ᴸ L')


theorem evalWhiskerRight_id
    {η : f ⟶ g} {η₁ : f ⟶ g ⊗ 𝟙_ C} {η₂ : f ⊗ 𝟙_ C ⟶ g ⊗ 𝟙_ C}
    (pf_η₁ : η ≫ (ρ_ _).inv = η₁) (pf_η₂ : (ρ_ _).hom ≫ η₁ = η₂) :
    η ▷ 𝟙_ C = η₂

{η₁ : f ⟶ CategoryTheory.MonoidalCategory.tensorObj g (𝟙_ C)}

{η₂ : CategoryTheory.MonoidalCategory.tensorObj f (𝟙_ C) ⟶ CategoryTheory.MonoidalCategory.tensorObj g (𝟙_ C)}

(pf_η₁ : CategoryTheory.CategoryStruct.comp η (CategoryTheory.MonoidalCategory.rightUnitor g).inv = η₁)

(pf_η₂ : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.rightUnitor f).hom η₁ = η₂)

CategoryTheory.MonoidalCategory.whiskerRight η (𝟙_ C) = η₂


theorem tendsto_nhds_top_mono [TopologicalSpace β] [Preorder β] [OrderTop β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊤)) (hg : f ≤ᶠ[l] g) : Tendsto g l (𝓝 ⊤)

{α : Type u}
{β : Type v}
[TopologicalSpace β]
[Preorder β]
[OrderTop β]
[OrderTopology β]
{l : Filter α}
{f g : α → β}
(hf : Filter.Tendsto f l (𝓝 ⊤))
(hg : f ≤ᶠ[l] g)


@[simp]
theorem log_zero_left : ∀ b, log 0 b = 0


/-- Any morphism between affine schemes that is surjective on global sections is a
closed immersion. -/
lemma of_surjective_of_isAffine {X Y : Scheme} [IsAffine X] [IsAffine Y] (f : X ⟶ Y)
    (h : Function.Surjective (Scheme.Γ.map f.op)) : IsClosedImmersion f

(h : Function.Surjective ⇑(AlgebraicGeometry.Scheme.Γ.map f.op))


/-- For rewriting in the reverse direction, see `Fin.cast_natAdd_right`. -/
theorem natAdd_cast {n n' : Nat} (m : Nat) (i : Fin n') (h : n' = n) :
    natAdd m (cast h i) = cast (congrArg _ h) (natAdd m i)

Fin.natAdd m (Fin.cast h i) = Fin.cast ⋯ (Fin.natAdd m i)


theorem map_nhdsWithin_eq (s : Set H) (x : H) : map I (𝓝[s] x) = 𝓝[I '' s] I x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
(s : Set H)
(x : H)

Filter.map (↑I) (𝓝[s] x) = 𝓝[↑I '' s] ↑I x


lemma Function.Injective.isSeparatedMap {f : X → Y} (inj : f.Injective) : IsSeparatedMap f

{X : Type u_1}
{Y : Sort u_2}
[TopologicalSpace X]
{f : X → Y}
(inj : Function.Injective f)


@[measurability]
protected theorem MeasurableSet.insert {s : Set α} (hs : MeasurableSet s) (a : α) :
    MeasurableSet (insert a s)

{α : Type u_1}
[MeasurableSpace α]
[MeasurableSingletonClass α]
{s : Set α}
(hs : MeasurableSet s)
(a : α)


@[simp]
theorem mem_Ico : x ∈ Ico a b ↔ a ≤ x ∧ x < b


protected lemma add_smul : smul α φ (r + r') m = smul α φ r m + smul α φ r' m

{J : CategoryTheory.GrothendieckTopology C}

PresheafOfModules.Sheafify.smul α φ (r + r') m =
  PresheafOfModules.Sheafify.smul α φ r m + PresheafOfModules.Sheafify.smul α φ r' m


theorem diam_iUnion_mem_option {ι : Type*} (o : Option ι) (s : ι → Set α) :
    diam (⋃ i ∈ o, s i) = ⨆ i ∈ o, diam (s i)

{α : Type u}
[PseudoEMetricSpace α]
{ι : Type u_2}
(o : Option ι)
(s : ι → Set α)

EMetric.diam (⋃ i ∈ o, s i) = ⨆ i ∈ o, EMetric.diam (s i)


theorem condexpL1CLM_lpMeas (f : lpMeas F' ℝ m 1 μ) :
    condexpL1CLM F' hm μ (f : α →₁[μ] F') = ↑f

(f : ↥(MeasureTheory.lpMeas F' ℝ m 1 μ))

(MeasureTheory.condexpL1CLM F' hm μ) ↑f = ↑f


@[simp] theorem length_dropLast_cons (a : α) (as : List α) : (a :: as).dropLast.length = as.length


@[to_additive (attr := measurability)]
theorem List.measurable_prod (l : List (α → M)) (hl : ∀ f ∈ l, Measurable f) :
    Measurable fun x => (l.map fun f : α → M => f x).prod

{M : Type u_2}
{α : Type u_3}
[Monoid M]
[MeasurableSpace M]
[MeasurableMul₂ M]
{m : MeasurableSpace α}
(l : List (α → M))
(hl : ∀ f ∈ l, Measurable f)

Measurable fun x => (List.map (fun f => f x) l).prod


@[to_additive]
lemma smul_def (a : M) (x : α × β) : a • x = (a • x.1, a • x.2)

{M : Type u_1}
{α : Type u_5}
{β : Type u_6}
[SMul M α]
[SMul M β]
(a : M)
(x : α × β)


lemma Directed.exists_mem_subset_of_finset_subset_biUnion {α ι : Type*} [Nonempty ι]
    {f : ι → Set α} (h : Directed (· ⊆ ·) f) {s : Finset α} (hs : (s : Set α) ⊆ ⋃ i, f i) :
    ∃ i, (s : Set α) ⊆ f i

{α : Type u_1}
{ι : Type u_2}
[Nonempty ι]
{f : ι → Set α}
(h : Directed (fun x x_1 => x ⊆ x_1) f)
{s : Finset α}
(hs : ↑s ⊆ ⋃ i, f i)


@[simp]
theorem bind_assoc (s : WSeq α) (f : α → WSeq β) (g : β → WSeq γ) :
    bind (bind s f) g ~ʷ bind s fun x : α => bind (f x) g

{α : Type u}
{β : Type v}
{γ : Type w}
(s : Stream'.WSeq α)
(f : α → Stream'.WSeq β)
(g : β → Stream'.WSeq γ)

(s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g


protected theorem sum_le_tsum {f : α → ℝ≥0∞} (s : Finset α) : ∑ x ∈ s, f x ≤ ∑' x, f x

{α : Type u_1}
{f : α → ℝ≥0∞}
(s : Finset α)


theorem toEnd_def (x : M) : toEnd M x = x

(CategoryTheory.SingleObj.toEnd M) x = x


/-- An identity partial homeomorphism belongs to the `C^n` groupoid. -/
theorem ofSet_mem_contDiffGroupoid {s : Set H} (hs : IsOpen s) :
    PartialHomeomorph.ofSet s hs ∈ contDiffGroupoid n I

(n : ℕ∞)
{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
{s : Set H}
(hs : IsOpen s)


@[simp]
theorem symm_dual_comp (g : CompleteLatticeHom βᵒᵈ γᵒᵈ) (f : CompleteLatticeHom αᵒᵈ βᵒᵈ) :
    CompleteLatticeHom.dual.symm (g.comp f) =
      (CompleteLatticeHom.dual.symm g).comp (CompleteLatticeHom.dual.symm f)

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[CompleteLattice α]
[CompleteLattice β]
[CompleteLattice γ]
(g : CompleteLatticeHom βᵒᵈ γᵒᵈ)
(f : CompleteLatticeHom αᵒᵈ βᵒᵈ)


@[simp]
theorem withDensity_eq_zero_iff {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
    μ.withDensity f = 0 ↔ f =ᵐ[μ] 0

{α : Type u_1}
{m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : α → ℝ≥0∞}
(hf : AEMeasurable f μ)


theorem Numeric.mul_pos (hp₁ : 0 < x₁) (hp₂ : 0 < x₂) : 0 < x₁ * x₂

{x₁ x₂ : SetTheory.PGame}
(hx₁ : x₁.Numeric)
(hx₂ : x₂.Numeric)
(hp₁ : 0 < x₁)
(hp₂ : 0 < x₂)


@[simp]
lemma disjoint_union_left : Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u


@[simp]
theorem ofDual_natCast [NatCast α] (n : ℕ) : (ofDual n : α) = n


theorem inv_cpow_eq_ite (x : ℂ) (n : ℂ) :
    x⁻¹ ^ n = if x.arg = π then conj (x ^ conj n)⁻¹ else (x ^ n)⁻¹

x⁻¹ ^ n = if x.arg = π then (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)⁻¹ else (x ^ n)⁻¹


theorem exists_prime_mul_pow_lt_factorial (n a c : ℕ) : ∃ p > n, p.Prime ∧ a * c ^ p < (p - 1)!

∃ p > n, Nat.Prime p ∧ a * c ^ p < (p - 1)!


@[simp]
theorem ofLeftInverseS_apply {g : S → R} {f : R →+* S} (h : Function.LeftInverse g f) (x : R) :
    ↑(ofLeftInverseS h x) = f x

{R : Type u}
{S : Type v}
[NonAssocSemiring R]
[NonAssocSemiring S]
{g : S → R}
{f : R →+* S}
(h : Function.LeftInverse g ⇑f)
(x : R)


/-- An odd function on a linear ordered additive commutative group is antitone on the whole group
provided that it is monotone on `Set.Ici 0`. -/
theorem antitone_of_odd_of_monotoneOn_nonneg {f : G → H} (h₁ : ∀ x, f (-x) = -f x)
    (h₂ : AntitoneOn f (Ici 0)) : Antitone f

{G : Type u_1}
{H : Type u_2}
[LinearOrderedAddCommGroup G]
[OrderedAddCommGroup H]
{f : G → H}
(h₁ : ∀ (x : G), f (-x) = -f x)
(h₂ : AntitoneOn f (Set.Ici 0))


@[to_additive]
theorem mulDysonETransform.subset :
    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2

{α : Type u_1}
[DecidableEq α]
[AddCommGroup α]
(e : α)
(x : Finset α × Finset α)

(Finset.addDysonETransform e x).1 + (Finset.addDysonETransform e x).2 ⊆ x.1 + x.2


theorem MDifferentiableWithinAt.mdifferentiableAt (h : MDifferentiableWithinAt I I' f s x)
    (hs : s ∈ 𝓝 x) : MDifferentiableAt I I' f x


@[to_additive (attr := simp)]
lemma inv_smul_set_distrib (a : α) (s : Set α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹

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


@[simp] theorem not_mem_nil (a : α) : ¬ a ∈ []


@[to_additive]
theorem continuousOn_list_prod {f : ι → X → M} (l : List ι) {t : Set X}
    (h : ∀ i ∈ l, ContinuousOn (f i) t) :
    ContinuousOn (fun a => (l.map fun i => f i a).prod) t

{ι : Type u_1}
{M : Type u_3}
{X : Type u_5}
[TopologicalSpace X]
[TopologicalSpace M]
[AddMonoid M]
[ContinuousAdd M]
{f : ι → X → M}
(l : List ι)
{t : Set X}
(h : ∀ i ∈ l, ContinuousOn (f i) t)

ContinuousOn (fun a => (List.map (fun i => f i a) l).sum) t


theorem norm_mul_le (a b : α) : ‖a * b‖ ≤ ‖a‖ * ‖b‖

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

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


theorem convex_halfspace_re_ge (r : ℝ) : Convex ℝ { c : ℂ | r ≤ c.re }


protected theorem le_of_transpose_le {μ ν : YoungDiagram} (h_le : μ.transpose ≤ ν) :
    μ ≤ ν.transpose


@[simp]
theorem v2_coeff {p' R'} (x y : WittVector p' R') (i : Fin 2) :
    (![x, y] i).coeff = ![x.coeff, y.coeff] i

{p' : ℕ}
{R' : Type u_2}
(x y : WittVector p' R')
(i : Fin 2)


@[simp]
theorem laverage_const (μ : Measure α) [IsFiniteMeasure μ] [h : NeZero μ] (c : ℝ≥0∞) :
    ⨍⁻ _x, c ∂μ = c

{α : Type u_1}
{m0 : MeasurableSpace α}
(μ : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure μ]
[h : NeZero μ]
(c : ℝ≥0∞)


theorem chart_source_mem_nhds (x : M) : (chartAt H x).source ∈ 𝓝 x

(H : Type u)
{M : Type u_2}
[TopologicalSpace H]
[TopologicalSpace M]
[ChartedSpace H M]
(x : M)


theorem piCongr_symm_apply (f : ∀ b, Z b) :
    (h₁.piCongr h₂).symm f = fun a => (h₂ a).symm (f (h₁ a))

{α : Sort u_1}
{β : Sort u_2}
{W : α → Sort w}
{Z : β → Sort z}
(h₁ : α ≃ β)
(h₂ : (a : α) → W a ≃ Z (h₁ a))
(f : (b : β) → Z b)


theorem le_add_one {a b : Int} (h : a ≤ b) : a ≤ b + 1


theorem transAssocReparamAux_mem_I (t : I) : transAssocReparamAux t ∈ I

Path.Homotopy.transAssocReparamAux t ∈ I


@[simp]
theorem integral_const (c : E) : ∫ _ : α, c ∂μ = (μ univ).toReal • c

{α : Type u_1}
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[hE : CompleteSpace E]
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
(c : E)

∫ (x : α), c ∂μ = (μ Set.univ).toReal • c


@[simp]
theorem coeFun_mapEquiv (g : P ≃ₐ[R] P') :
    (mapEquiv g : FractionalIdeal S P → FractionalIdeal S P') = map g

{R : Type u_1}
[CommRing R]
{S : Submonoid R}
{P : Type u_2}
[CommRing P]
[Algebra R P]
{P' : Type u_3}
[CommRing P']
[Algebra R P']
(g : P ≃ₐ[R] P')

⇑(FractionalIdeal.mapEquiv g) = FractionalIdeal.map ↑g


@[simp]
theorem Basis.ofIsLocalizedModule_apply (i : ι) : b.ofIsLocalizedModule Rₛ S f i = f (b i)

{R : Type u_1}
(Rₛ : Type u_2)
[CommSemiring R]
(S : Submonoid R)
[CommRing Rₛ]
[Algebra R Rₛ]
[hT : IsLocalization S Rₛ]
{M : Type u_3}
{Mₛ : Type u_4}
[AddCommGroup M]
[AddCommGroup Mₛ]
[Module R M]
[Module R Mₛ]
[Module Rₛ Mₛ]
(f : M →ₗ[R] Mₛ)
[IsLocalizedModule S f]
[IsScalarTower R Rₛ Mₛ]
{ι : Type u_5}
(b : Basis ι R M)
(i : ι)

(Basis.ofIsLocalizedModule Rₛ S f b) i = f (b i)


theorem abv_neg (a : R) : abv (-a) = abv a

{R : Type u_3}
{S : Type u_4}
[OrderedCommRing S]
[NoZeroDivisors S]
[Ring R]
(abv : R → S)
[IsAbsoluteValue abv]
(a : R)


@[simp]
theorem eval₂_zero'_apply (f : R →+* S₂) (p : MvPolynomial σ R) :
    eval₂ f (fun _ => 0 : σ → S₂) p = f (constantCoeff p)

{R : Type u}
{S₂ : Type w}
{σ : Type u_1}
[CommSemiring R]
[CommSemiring S₂]
(f : R →+* S₂)
(p : MvPolynomial σ R)

MvPolynomial.eval₂ f (fun x => 0) p = f (MvPolynomial.constantCoeff p)


@[simp] lemma arrowCongr_symm (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) :
    (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
{G : Type u_4}
{H : Type u_5}
[AddCommGroup E]
[AddCommGroup F]
[AddCommGroup G]
[AddCommGroup H]
[NontriviallyNormedField 𝕜]
[Module 𝕜 E]
[Module 𝕜 F]
[Module 𝕜 G]
[Module 𝕜 H]
[TopologicalSpace E]
[TopologicalSpace F]
[TopologicalSpace G]
[TopologicalSpace H]
[TopologicalAddGroup G]
[TopologicalAddGroup H]
[ContinuousConstSMul 𝕜 G]
[ContinuousConstSMul 𝕜 H]
(e₁ : E ≃L[𝕜] F)
(e₂ : H ≃L[𝕜] G)


@[simp] lemma id_τ₁ : Hom.τ₁ (𝟙 S) = 𝟙 _

(CategoryTheory.CategoryStruct.id S).τ₁ = CategoryTheory.CategoryStruct.id S.X₁


theorem fst_injective [Subsingleton β] : Function.Injective (@fst α β)

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


@[simp] theorem ForInStep.run_done : (ForInStep.done a).run = a

∀ {α : Type u_1} {a : α}, (ForInStep.done a).run = a