L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
α : Type u_3
n : ℕ
φ : L.BoundedFormula α n
v : α → ↥⊤
xs : Fin n → ↥⊤
⊢ φ.Realize v xs ↔ φ.Realize (Subtype.val ∘ v) (Subtype.val ∘ xs)

L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
α : Type u_3
n : ℕ
φ : L.BoundedFormula α n
v : α → ↥⊤
xs : Fin n → ↥⊤
⊢ φ.Realize (⇑topEquiv ∘ v) (⇑topEquiv ∘ xs) ↔ φ.Realize (Subtype.val ∘ v) (Subtype.val ∘ xs)

rw [← Substructure.topEquiv.realize_boundedFormula φ]


α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
⊢ (p ^ n) x ∈ p.toList x ↔ x ∈ p.support

α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
⊢ x ∈ p.support → p.SameCycle x ((p ^ n) x)

α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x : α
n : ℕ
x✝ : x ∈ p.support
⊢ p.SameCycle ((p ^ n) x) x


C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
⊢ IsSheafFor P (ofArrows X π) ↔
    ∀ (x : (i : I) → P.obj (op (X i))), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i

case refine_1
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
h : IsSheafFor P (ofArrows X π)
x : (i : I) → P.obj (op (X i))
hx : Arrows.Compatible P π x
⊢ ∃! t, ∀ (i : I), P.map (π i).op t = x i

case refine_2
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
h : ∀ (x : (i : I) → P.obj (op (X i))), Arrows.Compatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i
x : FamilyOfElements P (ofArrows X π)
hx : x.Compatible
⊢ ∃! t, x.IsAmalgamation t

refine ⟨fun h x hx ↦ ?_, fun h x hx ↦ ?_⟩


𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
⊢ (r.comp q).comp p = r.comp (q.comp p)

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
⊢ ((r.comp q).comp p n) v = (r.comp (q.comp p) n) v

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
⊢ ((r.comp q).comp p n) v = (r.comp (q.comp p) n) v

let f : (Σ a : Composition n, Composition a.length) → H := fun c =>
    r c.2.length (applyComposition q c.2 (applyComposition p c.1 v))

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
⊢ ((r.comp q).comp p n) v = (r.comp (q.comp p) n) v

let g : (Σ c : Composition n, ∀ i : Fin c.length, Composition (c.blocksFun i)) → H := fun c =>
    r c.1.length fun i : Fin c.1.length =>
      q (c.2 i).length (applyComposition p (c.2 i) (v ∘ c.1.embedding i))

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
⊢ ∑ c : (a : Composition n) × Composition a.length, f c =
    ∑ c : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)), g c

suffices ∑ c, f c = ∑ c, g c by
    simpa (config := { unfoldPartialApp := true }) only [FormalMultilinearSeries.comp,
      ContinuousMultilinearMap.sum_apply, compAlongComposition_apply, Finset.sum_sigma',
      applyComposition, ContinuousMultilinearMap.map_sum]

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
⊢ ∑ c : (a : Composition n) × Composition a.length, f c =
    ∑ i : (a : Composition n) × Composition a.length, g ((sigmaEquivSigmaPi n) i)

case h.H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
⊢ ∀ x ∈ Finset.univ, f x = g ((sigmaEquivSigmaPi n) x)

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
⊢ f ⟨a, b⟩ = g ((sigmaEquivSigmaPi n) ⟨a, b⟩)

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
⊢ f ⟨a, b⟩ = g ⟨a.gather b, a.sigmaCompositionAux b⟩

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
⊢ ∀ (i : ℕ) (him : i < b.length) (hin : i < (a.gather b).length),
    q.applyComposition ⟨a, b⟩.snd (p.applyComposition ⟨a, b⟩.fst v) ⟨i, him⟩ =
      (q (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hin⟩).length)
        (p.applyComposition (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hin⟩)
          (v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hin⟩)))

apply r.congr (Composition.length_gather a b).symm

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
⊢ q.applyComposition ⟨a, b⟩.snd (p.applyComposition ⟨a, b⟩.fst v) ⟨i, hi1⟩ =
    (q (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).length)
      (p.applyComposition (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩)
        (v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)))

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
⊢ ∀ (i_1 : ℕ) (him : i_1 < b.blocksFun ⟨i, hi1⟩) (hin : i_1 < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length),
    (p.applyComposition ⟨a, b⟩.fst v ∘ ⇑(⟨a, b⟩.snd.embedding ⟨i, hi1⟩)) ⟨i_1, him⟩ =
      p.applyComposition (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩)
        (v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)) ⟨i_1, hin⟩

apply q.congr (length_sigmaCompositionAux a b _).symm

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 : j < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length
⊢ (p.applyComposition ⟨a, b⟩.fst v ∘ ⇑(⟨a, b⟩.snd.embedding ⟨i, hi1⟩)) ⟨j, hj1⟩ =
    p.applyComposition (⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩)
      (v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)) ⟨j, hj2⟩

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 : j < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length
⊢ ∀ (i_1 : ℕ) (him : i_1 < a.blocksFun ((b.embedding ⟨i, hi1⟩) ⟨j, hj1⟩))
    (hin : i_1 < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).blocksFun ⟨↑⟨j, hj1⟩, ⋯⟩),
    (v ∘ ⇑(⟨a, b⟩.fst.embedding ((⟨a, b⟩.snd.embedding ⟨i, hi1⟩) ⟨j, hj1⟩))) ⟨i_1, him⟩ =
      ((v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)) ∘
          ⇑((⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).embedding ⟨j, hj2⟩))
        ⟨i_1, hin⟩

apply p.congr (blocksFun_sigmaCompositionAux a b _ _).symm

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 : j < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length
k : ℕ
hk1 : k < a.blocksFun ((b.embedding ⟨i, hi1⟩) ⟨j, hj1⟩)
hk2 : k < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).blocksFun ⟨↑⟨j, hj1⟩, ⋯⟩
⊢ (v ∘ ⇑(⟨a, b⟩.fst.embedding ((⟨a, b⟩.snd.embedding ⟨i, hi1⟩) ⟨j, hj1⟩))) ⟨k, hk1⟩ =
    ((v ∘ ⇑(⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)) ∘
        ⇑((⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).embedding ⟨j, hj2⟩))
      ⟨k, hk2⟩

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 : j < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length
k : ℕ
hk1 : k < a.blocksFun ((b.embedding ⟨i, hi1⟩) ⟨j, hj1⟩)
hk2 : k < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).blocksFun ⟨↑⟨j, hj1⟩, ⋯⟩
⊢ ↑((⟨a, b⟩.fst.embedding ((⟨a, b⟩.snd.embedding ⟨i, hi1⟩) ⟨j, hj1⟩)) ⟨k, hk1⟩) =
    ↑((⟨a.gather b, a.sigmaCompositionAux b⟩.fst.embedding ⟨i, hi2⟩)
        (((⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).embedding ⟨j, hj2⟩) ⟨k, hk2⟩))

case h.H.mk
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : Fin n → E
f : (a : Composition n) × Composition a.length → H :=
  fun c => (r c.snd.length) (q.applyComposition c.snd (p.applyComposition c.fst v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun c => (r c.fst.length) fun i => (q (c.snd i).length) (p.applyComposition (c.snd i) (v ∘ ⇑(c.fst.embedding i)))
a : Composition n
b : Composition a.length
a✝ : ⟨a, b⟩ ∈ Finset.univ
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 : j < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).length
k : ℕ
hk1 : k < a.blocksFun ((b.embedding ⟨i, hi1⟩) ⟨j, hj1⟩)
hk2 : k < (a.sigmaCompositionAux b ⟨↑⟨i, hi1⟩, ⋯⟩).blocksFun ⟨↑⟨j, hj1⟩, ⋯⟩
⊢ a.sizeUpTo (b.sizeUpTo i + j) + k = (a.gather b).sizeUpTo i + ((a.sigmaCompositionAux b ⟨i, hi2⟩).sizeUpTo j + k)

rw [sizeUpTo_sizeUpTo_add _ _ hi1 hj1, add_assoc]


G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
⊢ map f (normalClosure s) = normalClosure (⇑f '' s)

G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) = normalClosure (⇑f '' s)

have : Normal (map f (normalClosure s)) := Normal.map inferInstance f hf

case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ map f (normalClosure s) ≤ normalClosure (⇑f '' s)

case a
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
s : Set G
f : G →* N
hf : Surjective ⇑f
this : (map f (normalClosure s)).Normal
⊢ normalClosure (⇑f '' s) ≤ map f (normalClosure s)


α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : ℝ → E
s : Set ℝ
l : ℝ≥0
⊢ HasConstantSpeedOnWith f s 0 ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0

α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : ℝ → E
s : Set ℝ
l : ℝ≥0
⊢ (∀ ⦃x : ℝ⦄, x ∈ s → ∀ ⦃y : ℝ⦄, y ∈ s → eVariationOn f (s ∩ Icc x y) = ENNReal.ofReal (0 * (y - x))) ↔
    ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) = 0

α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : ℝ → E
s : Set ℝ
l : ℝ≥0
⊢ (∀ ⦃x : ℝ⦄, x ∈ s → ∀ ⦃y : ℝ⦄, y ∈ s → eVariationOn f (s ∩ Icc x y) = 0) ↔ eVariationOn f s = 0

simp only [zero_mul, ENNReal.ofReal_zero, ← eVariationOn.eq_zero_iff]

case mp
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : ℝ → E
s : Set ℝ
l : ℝ≥0
⊢ (∀ ⦃x : ℝ⦄, x ∈ s → ∀ ⦃y : ℝ⦄, y ∈ s → eVariationOn f (s ∩ Icc x y) = 0) → eVariationOn f s = 0

case mpr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : ℝ → E
s : Set ℝ
l : ℝ≥0
⊢ eVariationOn f s = 0 → ∀ ⦃x : ℝ⦄, x ∈ s → ∀ ⦃y : ℝ⦄, y ∈ s → eVariationOn f (s ∩ Icc x y) = 0


l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommRing α
A✝ B : Matrix n n α
inst✝³ : Fintype m
inst✝² : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
inst✝¹ : Invertible A
inst✝ : Invertible (A.submatrix ⇑e₁ ⇑e₂)
⊢ ⅟(A.submatrix ⇑e₁ ⇑e₂) = (⅟A).submatrix ⇑e₂ ⇑e₁

l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommRing α
A✝ B : Matrix n n α
inst✝³ : Fintype m
inst✝² : DecidableEq m
A : Matrix m m α
e₁ e₂ : n ≃ m
inst✝¹ : Invertible A
inst✝ : Invertible (A.submatrix ⇑e₁ ⇑e₂)
this : Invertible (A.submatrix ⇑e₁ ⇑e₂) := A.submatrixEquivInvertible e₁ e₂
⊢ ⅟(A.submatrix ⇑e₁ ⇑e₂) = (⅟A).submatrix ⇑e₂ ⇑e₁

letI := submatrixEquivInvertible A e₁ e₂

convert (rfl : ⅟ (A.submatrix e₁ e₂) = _)


I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝⁵ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝⁴ : X.HasMap p
inst✝³ : Y.HasMap p
inst✝² : Z.HasMap p
q : J → K
r : I → K
hpqr : ∀ (i : I), q (p i) = r i
inst✝¹ : HasZeroMorphisms C
inst✝ : DecidableEq J
i : I
j : J
⊢ X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j

case pos
I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝⁵ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝⁴ : X.HasMap p
inst✝³ : Y.HasMap p
inst✝² : Z.HasMap p
q : J → K
r : I → K
hpqr : ∀ (i : I), q (p i) = r i
inst✝¹ : HasZeroMorphisms C
inst✝ : DecidableEq J
i : I
j : J
h : p i = j
⊢ X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j

case neg
I : Type u_1
J : Type u_2
K : Type u_3
C : Type u_4
inst✝⁵ : Category.{u_5, u_4} C
X Y Z : GradedObject I C
φ : X ⟶ Y
e : X ≅ Y
ψ : Y ⟶ Z
p : I → J
j✝ : J
inst✝⁴ : X.HasMap p
inst✝³ : Y.HasMap p
inst✝² : Z.HasMap p
q : J → K
r : I → K
hpqr : ∀ (i : I), q (p i) = r i
inst✝¹ : HasZeroMorphisms C
inst✝ : DecidableEq J
i : I
j : J
h : ¬p i = j
⊢ X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j


α β : Type u
c : Cardinal.{u_1}
h : ∀ (n : ℕ), ↑n ≤ c
hn : c < ℵ₀
⊢ False

case intro
α β : Type u
n : ℕ
h : ∀ (n_1 : ℕ), ↑n_1 ≤ ↑n
hn : ↑n < ℵ₀
⊢ False

exact (Nat.lt_succ_self _).not_le (natCast_le.1 (h (n + 1)))


α : Type u_1
M : Matroid α
E B I X R J : Set α
hIE : I ⊆ E
⊢ (uniqueBaseOn I E).Base B ↔ B = I

rw [uniqueBaseOn, base_restrict_iff', freeOn_basis'_iff, inter_eq_self_of_subset_right hIE]


M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
⊢ (f.lift hg).comp f.toMap = g

case h
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x✝ : M
⊢ ((f.lift hg).comp f.toMap) x✝ = g x✝


R : Type u_1
inst✝¹² : CommRing R
M✝ : Type u_2
inst✝¹¹ : AddCommGroup M✝
inst✝¹⁰ : Module R M✝
M' : Type u_3
inst✝⁹ : AddCommGroup M'
inst✝⁸ : Module R M'
ι : Type u_4
inst✝⁷ : DecidableEq ι
inst✝⁶ : Fintype ι
e : Basis ι R M✝
A : Type u_5
inst✝⁵ : CommRing A
inst✝⁴ : Module A M✝
κ : Type u_6
inst✝³ : Fintype κ
𝕜 : Type u_7
inst✝² : Field 𝕜
M : Type u_8
inst✝¹ : AddCommGroup M
inst✝ : Module 𝕜 M
⊢ LinearMap.det 0 = 0 ^ FiniteDimensional.finrank 𝕜 M

simp only [← zero_smul 𝕜 (1 : M →ₗ[𝕜] M), det_smul, mul_one, MonoidHom.map_one]


𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ = ⨅ v, LinearMap.ker ((innerSL 𝕜) ↑v)

case a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ ≤ ⨅ v, LinearMap.ker ((innerSL 𝕜) ↑v)

case a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ ⨅ v, LinearMap.ker ((innerSL 𝕜) ↑v) ≤ Kᗮ


α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddSemigroup α
inst✝ : Neg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = -(fun x => f (a + x)) x


α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
inst✝ : Decidable o.Dom
a : α
⊢ o.toOption = Option.some a ↔ a ∈ o


n : ℕ
v : Vector ℕ n.succ
⊢ v.get 0 = v.head


α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
inst✝ : IsFiniteKernel κ
hf : IsRatCondKernelCDF f κ ν
a : α
x : ℝ
⊢ ∫⁻ (b : β), ENNReal.ofReal (↑(stieltjesOfMeasurableRat f ⋯ (a, b)) x) ∂ν a = (κ a) (univ ×ˢ Iic x)

rw [← setLIntegral_univ, setLIntegral_stieltjesOfMeasurableRat hf _ _ MeasurableSet.univ]


R : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f g : R[ε] →ₐ[R] A
hε : f ε = g ε
⊢ f = g

case hinr.h
R : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f g : R[ε] →ₐ[R] A
hε : f ε = g ε
⊢ (f.toLinearMap ∘ₗ ↑R (LinearMap.toSpanSingleton R R[ε] ε)) 1 =
    (g.toLinearMap ∘ₗ ↑R (LinearMap.toSpanSingleton R R[ε] ε)) 1

case hinr.h
R : Type u_1
A✝ : Type u_2
B : Type u_3
A : Type u_4
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f g : R[ε] →ₐ[R] A
hε : f ε = g ε
⊢ f (1 • ε) = g (1 • ε)


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a (-b) = -(toIocDiv hp (-a) b + 1)

α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a (-b) = -toIocDiv hp (-(a + p)) b

suffices toIcoDiv hp a (-b) = -toIocDiv hp (-(a + p)) b by
    rwa [neg_add, ← sub_eq_add_neg, toIocDiv_sub_eq_toIocDiv_add', toIocDiv_add_right] at this

α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp (-(a + p)) b = -toIcoDiv hp a (-b)

case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : a ≤ -b - toIcoDiv hp a (-b) • p
ho : -b - toIcoDiv hp a (-b) • p < a + p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

obtain ⟨hc, ho⟩ := sub_toIcoDiv_zsmul_mem_Ico hp a (-b)

case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : a ≤ -b - toIcoDiv hp a (-b) • p
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

rw [← neg_lt_neg_iff, neg_sub' (-b), neg_neg, ← neg_smul] at ho

case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : b - -toIcoDiv hp a (-b) • p ≤ -a
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

rw [← neg_le_neg_iff, neg_sub' (-b), neg_neg, ← neg_smul] at hc

case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : b - -toIcoDiv hp a (-b) • p ≤ -a
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ -a = -(a + p) + p


V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
⊢ w ∈ p.support ↔ w = u ∨ w ∈ p.support.tail


ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b✝ c d b : α
⊢ a \ ⊥ ≤ b ↔ a ≤ b


ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ Icc a b \ {a, b} = Ioo a b


ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s t : Finset α
f g : α → β
⊢ ∏ x ∈ s, t.piecewise f g x = (∏ x ∈ s ∩ t, f x) * ∏ x ∈ s \ t, g x

erw [prod_ite, filter_mem_eq_inter, ← sdiff_eq_filter]


C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ (tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ f ▷ Xᘁ) = (ρ_ Yᘁ).hom ≫ fᘁ

C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasRightDual X
inst✝ : HasRightDual Y
f : X ⟶ Y
⊢ Yᘁ ◁ (η_ X Xᘁ ≫ f ▷ Xᘁ) ≫ (α_ Yᘁ Y Xᘁ).inv ≫ ε_ Y Yᘁ ▷ Xᘁ ≫ (λ_ Xᘁ).hom =
    (ρ_ Yᘁ).hom ≫ (ρ_ Yᘁ).inv ≫ Yᘁ ◁ η_ X Xᘁ ≫ Yᘁ ◁ f ▷ Xᘁ ≫ (α_ Yᘁ Y Xᘁ).inv ≫ ε_ Y Yᘁ ▷ Xᘁ ≫ (λ_ Xᘁ).hom


C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
p : YonedaCollection F X
⊢ (map₁ η p).yonedaEquivFst = p.yonedaEquivFst

simp only [YonedaCollection.yonedaEquivFst_eq, map₁_fst]


F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n✝ n : ℕ
⊢ ∃ k, n = 2 * k ∨ n = 2 * k + 1

simpa only [← two_mul, exists_or, Odd, Even] using even_or_odd n


C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x = Hom.stalkMap f y ≫ X.presheaf.stalkSpecializes h

C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
        { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
              naturality := ⋯ } } ≫
      colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
      colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
        { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
              naturality := ⋯ } }

dsimp [stalkSpecializes, Hom.stalkMap, stalkFunctor, stalkPushforward]

C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : (OpenNhds (f.base y))ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } }

case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        (op j) ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        (op j) ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } }

case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) (op j) ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) (op j) ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } }

case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app ((OpenNhds.inclusion (f.base x)).op.obj (op { obj := j.obj, property := ⋯ })) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op.obj (op { obj := j.obj, property := ⋯ }))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ })) =
    f.c.app ((OpenNhds.inclusion (f.base y)).op.obj (op j)) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op.obj (op j))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          (op { obj := (unop ((OpenNhds.map f.base y).op.obj (op j))).obj, property := ⋯ })

simp only [colimit.ι_desc_assoc, ι_colimMap_assoc, whiskerLeft_app,
    whiskerRight_app, NatTrans.id_app, map_id, colimit.ι_pre, id_comp, assoc,
    colimit.pre_desc, colimit.map_desc, colimit.ι_desc, Cocones.precompose_obj_ι,
    Cocone.whisker_ι, NatTrans.comp_app]

case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app ((OpenNhds.inclusion (f.base x)).op.obj (op { obj := j.obj, property := ⋯ })) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ })) =
    f.c.app ((OpenNhds.inclusion (f.base y)).op.obj (op j)) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ }))


α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν✝ ν₁ ν₂ : Measure α
s t : Set α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
P : α → Prop
h : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ν s < ⊤ → ∀ᵐ (x : α) ∂μ.restrict s, P x
⊢ ∀ᵐ (x : α) ∂μ, P x

α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν✝ ν₁ ν₂ : Measure α
s t : Set α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
P : α → Prop
h : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ν s < ⊤ → ∀ᵐ (x : α) ∂μ.restrict s, P x
this : ∀ (n : ℕ), ∀ᵐ (x : α) ∂μ, x ∈ spanningSets (μ + ν) n → P x
⊢ ∀ᵐ (x : α) ∂μ, P x

have : ∀ n, ∀ᵐ x ∂μ, x ∈ spanningSets (μ + ν) n → P x := by
    intro n
    have := h
      (spanningSets (μ + ν) n) (measurable_spanningSets _ _)
      ((self_le_add_right _ _).trans_lt (measure_spanningSets_lt_top (μ + ν) _))
      ((self_le_add_left _ _).trans_lt (measure_spanningSets_lt_top (μ + ν) _))
    exact (ae_restrict_iff' (measurable_spanningSets _ _)).mp this

filter_upwards [ae_all_iff.2 this] with _ hx using hx _ (mem_spanningSetsIndex _ _)


a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : b ≤ a
ha : a ≠ ⊤
⊢ (a - b).toReal = a.toReal - b.toReal

case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
ha : a ≠ ⊤
b : ℝ≥0
h : ↑b ≤ a
⊢ (a - ↑b).toReal = a.toReal - (↑b).toReal

lift b to ℝ≥0 using ne_top_of_le_ne_top ha h

case intro.intro
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
h : ↑b ≤ ↑a
⊢ (↑a - ↑b).toReal = (↑a).toReal - (↑b).toReal

simp only [← ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]


α : Type u_1
β : Type u_2
f : α → Option β
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ List.filterMap f l₁ ~ List.filterMap f l₂

induction p with
  | nil => simp
  | cons x _p IH => cases h : f x <;> simp [h, filterMap_cons, IH, Perm.cons]
  | swap x y l₂ => cases hx : f x <;> cases hy : f y <;> simp [hx, hy, filterMap_cons, swap]
  | trans _p₁ _p₂ IH₁ IH₂ => exact IH₁.trans IH₂


α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Periodic f c₁
h2 : Antiperiodic f c₂
⊢ Antiperiodic f (c₁ - c₂)

simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg


E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
⊢ ∫ (x : ℝ) in t..t + T, f x = ∫ (x : ℝ) in s..s + T, f x

E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
⊢ ∫ (x : ℝ) in Ioc t (t + T), f x ∂volume = ∫ (x : ℝ) in Ioc s (s + T), f x ∂volume

simp only [integral_of_le, hT.le, le_add_iff_nonneg_right]

E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
this : VAddInvariantMeasure ↥(zmultiples T) ℝ volume
⊢ ∫ (x : ℝ) in Ioc t (t + T), f x ∂volume = ∫ (x : ℝ) in Ioc s (s + T), f x ∂volume

haveI : VAddInvariantMeasure (AddSubgroup.zmultiples T) ℝ volume :=
    ⟨fun c s _ => measure_preimage_add _ _ _⟩

case hs
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
this : VAddInvariantMeasure ↥(zmultiples T) ℝ volume
⊢ IsAddFundamentalDomain (↥(zmultiples T)) (Ioc t (t + T)) volume

case ht
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
this : VAddInvariantMeasure ↥(zmultiples T) ℝ volume
⊢ IsAddFundamentalDomain (↥(zmultiples T)) (Ioc s (s + T)) volume

case hf
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
hf : Periodic f T
hT : 0 < T
t s : ℝ
this : VAddInvariantMeasure ↥(zmultiples T) ℝ volume
⊢ ∀ (g : ↥(zmultiples T)) (x : ℝ), f (g +ᵥ x) = f x

apply IsAddFundamentalDomain.setIntegral_eq (G := AddSubgroup.zmultiples T)

exacts [isAddFundamentalDomain_Ioc hT t, isAddFundamentalDomain_Ioc hT s, hf.map_vadd_zmultiples]


R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
x : FractionalIdeal S P
⊢ (mapEquiv AlgEquiv.refl) x = (RingEquiv.refl (FractionalIdeal S P)) x


α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (bliminf s atTop p)

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace α
s : ℕ → Set α
p : ℕ → Prop
h : ∀ (n : ℕ), p n → MeasurableSet (s n)
⊢ MeasurableSet (⋃ i, ⋂ j, ⋂ (_ : p j ∧ i ≤ j), s j)

simp only [Filter.bliminf_eq_iSup_biInf_of_nat, iInf_eq_iInter, iSup_eq_iUnion]

exact .iUnion fun n => .iInter fun m => .iInter fun hm => h m hm.1


p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
f : PiLp ⊤ β
⊢ ‖f‖₊ = ⨆ i, ‖f i‖₊

case a
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
f : PiLp ⊤ β
⊢ ↑‖f‖₊ = ↑(⨆ i, ‖f i‖₊)


R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0

R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (if i' = i then 1 else 0) = if i = i' then 1 else 0

rw [LinearMap.stdBasis_apply, Function.update_apply, Pi.zero_apply]

case e_c
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i i' : ι
⊢ (i' = i) = (i = i')


R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
⊢ ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
⊢ ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

have xεpos : 0 < (p x)/ε := by positivity

case intro
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
⊢ ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

rcases exists_mem_Ico_zpow xεpos hc with ⟨n, hn⟩

case intro
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
⊢ ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

case intro
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
cnpos : 0 < ‖c ^ (n + 1)‖
⊢ ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

have cnpos : 0 < ‖c^(n+1)‖ := by rw [norm_zpow]; exact xεpos.trans hn.2

case intro.refine_1
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
cnpos : 0 < ‖c ^ (n + 1)‖
⊢ c ^ (-(n + 1)) ≠ 0

case intro.refine_2
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
cnpos : 0 < ‖c ^ (n + 1)‖
⊢ p (c ^ (-(n + 1)) • x) < ε

case intro.refine_3
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
cnpos : 0 < ‖c ^ (n + 1)‖
⊢ ε / ‖c‖ ≤ p (c ^ (-(n + 1)) • x)

case intro.refine_4
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
c : 𝕜
hc : 1 < ‖c‖
ε : ℝ
εpos : 0 < ε
x : E
hx : p x ≠ 0
xεpos : 0 < p x / ε
n : ℤ
hn : p x / ε ∈ Ico (‖c‖ ^ n) (‖c‖ ^ (n + 1))
cpos : 0 < ‖c‖
cnpos : 0 < ‖c ^ (n + 1)‖
⊢ ‖c ^ (-(n + 1))‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x


K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
⊢ finrank K ↥(range f.dualMap) = finrank K ↥(range f)

K : Type uK
inst✝⁴ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
f : V₁ →ₗ[K] V₂
⊢ Function.Injective ⇑f.rangeRestrict.dualMap

rw [congr_arg dualMap (show f = (range f).subtype.comp f.rangeRestrict by rfl),
    ← dualMap_comp_dualMap, range_comp,
    range_eq_top.mpr (dualMap_surjective_of_injective (range f).injective_subtype),
    Submodule.map_top, finrank_range_of_inj, Subspace.dual_finrank_eq]

exact dualMap_injective_of_surjective (range_eq_top.mp f.range_rangeRestrict)


F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ι : Sort u_6
κ : ι → Sort u_7
inst✝⁴ : FunLike F α β
inst✝³ : CompleteLattice α
inst✝² : CompleteLattice β
inst✝¹ : CompleteLattice γ
inst✝ : CompleteLattice δ
g : FrameHom β γ
f₁ f₂ : FrameHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)


α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ s ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card

case zero
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ ∂⁺ ^[0] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + 0 = s.card

case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
ih : ∀ {𝒜 : Finset (Finset α)} {s : Finset α}, s ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ ∂⁺ ^[k + 1] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card

case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
ih : ∀ {𝒜 : Finset (Finset α)} {s : Finset α}, s ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ ∂⁺ ^[k] (∂⁺ 𝒜) ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card

simp only [exists_prop, Function.comp_apply, Function.iterate_succ]

case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
ih : ∀ {𝒜 : Finset (Finset α)} {s : Finset α}, s ∈ ∂⁺ ^[k] 𝒜 ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + k = s.card
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ t ∈ ∂⁺ 𝒜, t ⊆ s ∧ t.card + k = s.card) ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card

case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ t ∈ ∂⁺ 𝒜, t ⊆ s ∧ t.card + k = s.card) ↔ ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card

case succ.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ t ∈ ∂⁺ 𝒜, t ⊆ s ∧ t.card + k = s.card) → ∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card

case succ.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
t : Finset α
a : α
r k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ t ∈ 𝒜, t ⊆ s ∧ t.card + (k + 1) = s.card) → ∃ t ∈ ∂⁺ 𝒜, t ⊆ s ∧ t.card + k = s.card


α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : SeparableSpace α
inst✝ : PartialOrder α
⊢ ∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∈ s) ∧ ∀ (x : α), IsTop x → x ∈ s


α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a b : α
ha : a ∈ t
s : Finset α
⊢ s.erase a ∪ t = s ∪ t

rw [← insert_erase (mem_union_right s ha), erase_union_distrib, ← union_insert, insert_erase ha]


S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
⊢ shiftFunctor C 0 ≅ 𝟭 (DifferentialObject S C)

case refine_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X : DifferentialObject S C
⊢ ((shiftFunctor C 0).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).app X.obj).hom =
    ((shiftFunctorZero C S).app X.obj).hom ≫ ((𝟭 (DifferentialObject S C)).obj X).d

case refine_2
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X✝ Y✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
⊢ (shiftFunctor C 0).map f ≫ ((fun X => mkIso ((shiftFunctorZero C S).app X.obj) ⋯) Y✝).hom =
    ((fun X => mkIso ((shiftFunctorZero C S).app X.obj) ⋯) X✝).hom ≫ (𝟭 (DifferentialObject S C)).map f

refine NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) ?_) (fun f => ?_)


C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ ∀ (j : WalkingMultispan I.fstFrom I.sndFrom),
    ((𝟭 (Multicofork I)).obj K).ι.app j ≫ (Iso.refl ((𝟭 (Multicofork I)).obj K).pt).hom =
      ((I.toSigmaCoforkFunctor ⋙ I.ofSigmaCoforkFunctor).obj K).ι.app j

C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Cofork I.fstSigmaMap I.sndSigmaMap
⊢ ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).π ≫
      (Iso.refl ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).pt).hom =
    ((𝟭 (Cofork I.fstSigmaMap I.sndSigmaMap)).obj K).π

case w
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Cofork I.fstSigmaMap I.sndSigmaMap
⊢ ∀ (j : Discrete I.R),
    colimit.ι (Discrete.functor I.right) j ≫
        ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).π ≫
          (Iso.refl ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).pt).hom =
      colimit.ι (Discrete.functor I.right) j ≫ ((𝟭 (Cofork I.fstSigmaMap I.sndSigmaMap)).obj K).π

case w.mk
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Cofork I.fstSigmaMap I.sndSigmaMap
j : I.R
⊢ colimit.ι (Discrete.functor I.right) { as := j } ≫
      ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).π ≫
        (Iso.refl ((I.ofSigmaCoforkFunctor ⋙ I.toSigmaCoforkFunctor).obj K).pt).hom =
    colimit.ι (Discrete.functor I.right) { as := j } ≫ ((𝟭 (Cofork I.fstSigmaMap I.sndSigmaMap)).obj K).π

case w.mk
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Cofork I.fstSigmaMap I.sndSigmaMap
j : I.R
⊢ colimit.ι (Discrete.functor I.right) { as := j } ≫ Sigma.desc (Multicofork.ofSigmaCofork I K).π ≫ 𝟙 K.pt =
    colimit.ι (Discrete.functor I.right) { as := j } ≫ K.π

case w.mk
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Cofork I.fstSigmaMap I.sndSigmaMap
j : I.R
⊢ (Multicofork.ofSigmaCofork I K).π j = colimit.ι (Discrete.functor I.right) { as := j } ≫ K.π

simp only [Category.comp_id, colimit.ι_desc, Cofan.mk_ι_app]


J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimit F
E : K ⥤ J
inst✝¹ : HasLimit (E ⋙ F)
L : Type u₃
inst✝ : Category.{v₃, u₃} L
D : L ⥤ K
h : HasLimit (D ⋙ E ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)

J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimit F
E : K ⥤ J
inst✝¹ : HasLimit (E ⋙ F)
L : Type u₃
inst✝ : Category.{v₃, u₃} L
D : L ⥤ K
h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
⊢ pre F E ≫ pre (E ⋙ F) D = pre F (D ⋙ E)

case w
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimit F
E : K ⥤ J
inst✝¹ : HasLimit (E ⋙ F)
L : Type u₃
inst✝ : Category.{v₃, u₃} L
D : L ⥤ K
h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ (pre F E ≫ pre (E ⋙ F) D) ≫ π (D ⋙ E ⋙ F) j = pre F (D ⋙ E) ≫ π (D ⋙ E ⋙ F) j

case w
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimit F
E : K ⥤ J
inst✝¹ : HasLimit (E ⋙ F)
L : Type u₃
inst✝ : Category.{v₃, u₃} L
D : L ⥤ K
h : HasLimit (D ⋙ E ⋙ F)
this : HasLimit ((D ⋙ E) ⋙ F)
j : L
⊢ π F (E.obj (D.obj j)) = π F ((D ⋙ E).obj j)

erw [assoc, limit.pre_π, limit.pre_π, limit.pre_π]


m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
⊢ hA.sqrt ^ 2 = A

m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
C : Matrix n n 𝕜 := ↑⋯.eigenvectorUnitary
⊢ hA.sqrt ^ 2 = A

let C : Matrix n n 𝕜 := hA.1.eigenvectorUnitary

m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
C : Matrix n n 𝕜 := ↑⋯.eigenvectorUnitary
E : Matrix n n 𝕜 := diagonal (RCLike.ofReal ∘ Real.sqrt ∘ ⋯.eigenvalues)
⊢ hA.sqrt ^ 2 = A

let E := diagonal ((↑) ∘ Real.sqrt ∘ hA.1.eigenvalues : n → 𝕜)

m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
C : Matrix n n 𝕜 := ↑⋯.eigenvectorUnitary
E : Matrix n n 𝕜 := diagonal (RCLike.ofReal ∘ Real.sqrt ∘ ⋯.eigenvalues)
⊢ C * (E * (star C * C) * E) * star C = A

suffices C * (E * (star C * C) * E) * star C = A by
    rw [Matrix.PosSemidef.sqrt, pow_two]
    simpa only [← mul_assoc] using this

m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
C : Matrix n n 𝕜 := ↑⋯.eigenvectorUnitary
E : Matrix n n 𝕜 := diagonal (RCLike.ofReal ∘ Real.sqrt ∘ ⋯.eigenvalues)
this : E * E = diagonal (RCLike.ofReal ∘ ⋯.eigenvalues)
⊢ C * (E * (star C * C) * E) * star C = A

have : E * E = diagonal ((↑) ∘ hA.1.eigenvalues) := by
    rw [diagonal_mul_diagonal]
    congr! with v
    simp [← pow_two, ← RCLike.ofReal_pow, Real.sq_sqrt (hA.eigenvalues_nonneg v)]

simpa [C, this] using hA.1.spectral_theorem.symm


E : Type u_1
X : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : TopologicalSpace X
a b b₀ b₁ b₂ : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b) μ
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ) (Icc a b)

case pos
E : Type u_1
X : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : TopologicalSpace X
a b b₀ b₁ b₂ : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b) μ
h : a ≤ b
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ) (Icc a b)

case neg
E : Type u_1
X : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : TopologicalSpace X
a b b₀ b₁ b₂ : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝ : NoAtoms μ
h_int : IntegrableOn f (Icc a b) μ
h : ¬a ≤ b
⊢ ContinuousOn (fun x => ∫ (t : ℝ) in Ioc a x, f t ∂μ) (Icc a b)


I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
⊢ ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C fun x => x ∈ s)))

I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
⊢ ⊤ ≤ Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s)))

I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
⊢ Submodule.span ℤ (Set.range (spanFinBasis C s)) ≤ Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s)))

refine le_trans (spanFinBasis.span C s) ?_

I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
⊢ Set.range (spanFinBasis C s) ⊆ ↑(Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s))))

case intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
⊢ spanFinBasis C s x ∈ ↑(Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s))))

case intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod ∈ ↑(Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s))))

case intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
l : List I := Finset.sort (fun x x_1 => x ≥ x_1) s
⊢ (factors C s x).prod ∈ ↑(Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s))))

case intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
l : List I := Finset.sort (fun x x_1 => x ≥ x_1) s
⊢ (List.map (fun i => if ↑x i = true then e (π C fun x => x ∈ s) i else 1 - e (π C fun x => x ∈ s) i)
        (Finset.sort (fun x x_1 => x ≥ x_1) s)).prod ∈
    ↑(Submodule.span ℤ (Set.range (Products.eval (π C fun x => x ∈ s))))


ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
⊢ (∏ x ∈ s₂ \ s₁, f x) * ∏ x ∈ s₁, f x = ∏ x ∈ s₂, f x

rw [← prod_union sdiff_disjoint, sdiff_union_of_subset h]


α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : (i : ι) → κ i → Set α
⊢ s ∪ ⋂ i, ⋂ j, t i j = ⋂ i, ⋂ j, s ∪ t i j


ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
i : ι
a : 𝕜
v : EuclideanSpace 𝕜 ι
⊢ ⟪v, single i a⟫_𝕜 = a * (starRingEnd ((fun x => 𝕜) i)) (v i)


n✝ : ℤ
⊢ ↑n✝ / ↑0 = ↑0


R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : Nontrivial R
ι : Type u_4
v : ι → M
hv : LinearIndependent R v
⊢ Finite ι

R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : Nontrivial R
ι : Type u_4
v : ι → M
hv : LinearIndependent R v
hwf : WellFounded fun x x_1 => x > x_1
⊢ Finite ι

have hwf := isNoetherian_iff_wellFounded.mp (by infer_instance : IsNoetherian R M)

R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : Nontrivial R
ι : Type u_4
v : ι → M
hv : LinearIndependent R v
hwf : WellFounded fun x x_1 => x > x_1
i : ι
contra : span R {v i} = ⊥
⊢ False

refine CompleteLattice.WellFounded.finite_of_independent hwf hv.independent_span_singleton
    fun i contra => ?_

R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : Nontrivial R
ι : Type u_4
v : ι → M
hv : LinearIndependent R v
hwf : WellFounded fun x x_1 => x > x_1
i : ι
contra : span R {v i} = ⊥
⊢ v i = 0

R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : Nontrivial R
ι : Type u_4
v : ι → M
hv : LinearIndependent R v
hwf : WellFounded fun x x_1 => x > x_1
i : ι
contra : span R {v i} = ⊥
this : v i ∈ span R {v i}
⊢ v i = 0

have : v i ∈ R ∙ v i := Submodule.mem_span_singleton_self (v i)


R : Type u
M : Type v
N : Type w
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ finrank R ↥⊤ = finrank R M

R : Type u
M : Type v
N : Type w
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ toNat (Module.rank R ↥⊤) = toNat (Module.rank R M)


τ : Type u_1
α : Type u_2
β : Type u_3
ι : Type u_4
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
y : β
⊢ y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ (t : τ) in f, (ϕ t '' s ∩ n).Nonempty


ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : OrderedSemiring α
inst✝⁴ : OrderedAddCommMonoid β
inst✝³ : MulActionWithZero α β
inst✝² : FloorDiv α β
a : α
inst✝¹ : PosSMulMono α β
inst✝ : PosSMulReflectLE α β
ha : 0 < a
b : β
⊢ ∀ (c : β), c ≤ a • b ⌊/⌋ a ↔ c ≤ b


R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p q : R[X]
inst✝³ : CommRing T
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
r : T
⊢ (X - C r).aroots S = {(algebraMap T S) r}

rw [aroots_def, Polynomial.map_sub, map_X, map_C, roots_X_sub_C]


α : Type u_1
ι : Type u_2
X : Type u_3
Y : Type u_4
Z : Type u_5
β : Type u_6
inst✝⁸ : MeasurableSpace X
inst✝⁷ : StandardBorelSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T0Space Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : OpensMeasurableSpace Y
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace Z
inst✝ : SecondCountableTopology Y
f : X → Y
hf : Measurable f
hsurj : Surjective f
⊢ MeasurableSpace.map f inst✝⁸ = borel Y

α : Type u_1
ι : Type u_2
X : Type u_3
Y : Type u_4
Z : Type u_5
β : Type u_6
inst✝⁸ : MeasurableSpace X
inst✝⁷ : StandardBorelSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T0Space Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : OpensMeasurableSpace Y
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace Z
inst✝ : SecondCountableTopology Y
f : X → Y
hf : Measurable f
hsurj : Surjective f
d : Measurable f
⊢ MeasurableSpace.map f inst✝⁸ = borel Y

have d := hf.mono le_rfl OpensMeasurableSpace.borel_le

α : Type u_1
ι : Type u_2
X : Type u_3
Y : Type u_4
Z : Type u_5
β : Type u_6
inst✝⁸ : MeasurableSpace X
inst✝⁷ : StandardBorelSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T0Space Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : OpensMeasurableSpace Y
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace Z
inst✝ : SecondCountableTopology Y
f : X → Y
hf : Measurable f
hsurj : Surjective f
d : Measurable f
this : MeasurableSpace Y := borel Y
⊢ MeasurableSpace.map f inst✝⁸ = borel Y

α : Type u_1
ι : Type u_2
X : Type u_3
Y : Type u_4
Z : Type u_5
β : Type u_6
inst✝⁸ : MeasurableSpace X
inst✝⁷ : StandardBorelSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T0Space Y
inst✝⁴ : MeasurableSpace Y
inst✝³ : OpensMeasurableSpace Y
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace Z
inst✝ : SecondCountableTopology Y
f : X → Y
hf : Measurable f
hsurj : Surjective f
d : Measurable f
this✝ : MeasurableSpace Y := borel Y
this : BorelSpace Y
⊢ MeasurableSpace.map f inst✝⁸ = borel Y


E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ ‖fderiv ℝ (fun x => ‖f x‖ ^ p) x‖ ≤ p * ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ ‖p‖ * ‖‖f x‖ ^ (p - 2)‖ * ‖((innerSL ℝ) (f x)).comp (fderiv ℝ f x)‖ ≤ p * ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

rw [hf.fderiv_norm_rpow hp, norm_smul, norm_mul]

E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ p * (‖f x‖ ^ (p - 2) * ‖((innerSL ℝ) (f x)).comp (fderiv ℝ f x)‖) ≤ p * (‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖)

simp_rw [norm_rpow_of_nonneg (norm_nonneg _), norm_norm, norm_eq_abs,
    abs_eq_self.mpr <| zero_le_one.trans hp.le, mul_assoc]

case h
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ ‖f x‖ ^ (p - 2) * ‖((innerSL ℝ) (f x)).comp (fderiv ℝ f x)‖ ≤ ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

case h
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ ‖f x‖ ^ (p - 2) * (‖(innerSL ℝ) (f x)‖ * ‖fderiv ℝ f x‖) = ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

refine mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le ..) (by positivity)
    |>.trans_eq ?_

case h
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : F → E
hf : Differentiable ℝ f
x : F
p : ℝ
hp : 1 < p
⊢ ‖f x‖ ^ (p - 2 + 1) * ‖fderiv ℝ f x‖ = ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

rw [innerSL_apply_norm, ← mul_assoc, ← Real.rpow_add_one' (by positivity) (by linarith)]


R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
⊢ ∀ {a : R ⧸ I}, a ≠ 0 → ∃ b, a * b = 1

case mk
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
⊢ ∃ b, Quot.mk Setoid.r a * b = 1

case mk.intro.intro.intro
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b✝ : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
b c : R
hc : c ∈ I
abc : b * a + c = 1
⊢ ∃ b, Quot.mk Setoid.r a * b = 1

rcases hI.exists_inv (mt eq_zero_iff_mem.2 h) with ⟨b, c, hc, abc⟩

case mk.intro.intro.intro
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b✝ : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
b c : R
hc : c ∈ I
abc : a * b + c = 1
⊢ ∃ b, Quot.mk Setoid.r a * b = 1

case mk.intro.intro.intro
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b✝ : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
b c : R
hc : c ∈ I
abc : a * b + c = 1
⊢ Setoid.r ((fun x x_1 => x * x_1) a b) 1

case mk.intro.intro.intro
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b✝ : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
b c : R
hc : c ∈ I
abc : a * b + c = 1
⊢ a * b - 1 ∈ I

case mk.intro.intro.intro
R : Type u
inst✝ : CommRing R
I✝ : Ideal R
a✝¹ b✝ : R
S : Type v
x y : R
I : Ideal R
hI : I.IsMaximal
a✝ : R ⧸ I
a : R
h : Quot.mk Setoid.r a ≠ 0
b c : R
hc : c ∈ I
abc : c = 1 - a * b
⊢ a * b - 1 ∈ I

rwa [abc, ← neg_mem_iff (G := R) (H := I), neg_sub] at hc


R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : Monoid R
inst✝⁸ : NonUnitalNonAssocSemiring A
inst✝⁷ : DistribMulAction R A
inst✝⁶ : Star A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : DistribMulAction R B
inst✝³ : Star B
inst✝² : NonUnitalNonAssocSemiring C
inst✝¹ : DistribMulAction R C
inst✝ : Star C
f : (A →⋆ₙₐ[R] B) × (A →⋆ₙₐ[R] C)
⊢ (fun f => ((fst R B C).comp f, (snd R B C).comp f)) ((fun f => f.1.prod f.2) f) = f

R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : Monoid R
inst✝⁸ : NonUnitalNonAssocSemiring A
inst✝⁷ : DistribMulAction R A
inst✝⁶ : Star A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : DistribMulAction R B
inst✝³ : Star B
inst✝² : NonUnitalNonAssocSemiring C
inst✝¹ : DistribMulAction R C
inst✝ : Star C
f : A →⋆ₙₐ[R] B × C
⊢ (fun f => f.1.prod f.2) ((fun f => ((fst R B C).comp f, (snd R B C).comp f)) f) = f


α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
v : V
x : P
⊢ dist (v +ᵥ x) x = ‖v‖


ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
n : ℕ
f : ℕ → G
⊢ (map (fun k => f k / f (k + 1)) (range n)).prod = f 0 / f n

case zero
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
f : ℕ → G
⊢ (map (fun k => f k / f (k + 1)) (range 0)).prod = f 0 / f 0

case succ
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
f : ℕ → G
n : ℕ
h : (map (fun k => f k / f (k + 1)) (range n)).prod = f 0 / f n
⊢ (map (fun k => f k / f (k + 1)) (range (n + 1))).prod = f 0 / f (n + 1)


α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
s : Set α
⊢ span s = ⊤ ↔ ∃ s', ↑s' ⊆ s ∧ span ↑s' = ⊤

α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
s : Set α
⊢ 1 ∈ span s ↔ ∃ s', ↑s' ⊆ s ∧ 1 ∈ span ↑s'

exact ⟨Submodule.mem_span_finite_of_mem_span, fun ⟨s', h₁, h₂⟩ => span_mono h₁ h₂⟩


C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
⊢ ∀ {Y Z : C} {f : Y ⟶ X},
    S.bind (fun Y f h => (R h).arrows) f → ∀ (g : Z ⟶ Y), S.bind (fun Y f h => (R h).arrows) (g ≫ f)

case intro.intro.intro.intro.intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z✝ : C
f✝ : Y✝ ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
Y Z W : C
f : Y ⟶ W
h : W ⟶ X
hh : S h
hf : (R hh).arrows f
g : Z ⟶ Y
⊢ S.bind (fun Y f h => (R h).arrows) (g ≫ f ≫ h)


u v : Level
n : ℕ
pn : NormNum.IsNat n 0
⊢ List.range n = []

rw [pn.out, Nat.cast_zero, List.range_zero]


a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSymNat a b = r

a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = jacobiSym (↑a / 2) b

simp only [jacobiSymNat, ← hr, ← hc, Int.ofNat_ediv, Nat.cast_ofNat]

a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1

rw [← jacobiSym.even_odd (mod_cast ha), if_neg (by simp [hb])]

case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 1
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8


R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
⊢ (monomial n) (a - b) = (monomial n) a - (monomial n) b

R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
⊢ (monomial n) a + -(monomial n) b = (monomial n) a - (monomial n) b

rw [sub_eq_add_neg, monomial_add, monomial_neg]


α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ : Finset β
s : Set β
hs : s.Finite
f : β → α
⊢ Multipliable (f ∘ Subtype.val)

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ : Finset β
s : Set β
hs : s.Finite
f : β → α
this : Multipliable (f ∘ Subtype.val)
⊢ Multipliable (f ∘ Subtype.val)


C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c : X ⟶ Y
⊢ a + b + c = a + (b + c)

C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c : X ⟶ Y
⊢ a - -b + c = a + (b + c)

rw [sub_add, ← add_neg, neg_sub', neg_neg]


α : Type u_1
β : Type u_2
R✝ : Type u_3
S✝ : Type u_4
F✝ : Type u_5
inst✝⁵ : NonAssocSemiring R✝
inst✝⁴ : NonAssocSemiring S✝
R : Type u_6
S : Type u_7
inst✝³ : Semiring R
inst✝² : Semiring S
F : Type u_8
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
n : ℕ
hn : NeZero ↑n
⊢ NeZero (f ↑n)


α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin n → G
i : Fin n
⊢ (partialProd f i.castSucc)⁻¹ * partialProd f i.succ = f i

case mk
α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
n : ℕ
G : Type u_3
inst✝ : Group G
f : Fin n → G
i : ℕ
hn : i < n
⊢ (partialProd f ⟨i, hn⟩.castSucc)⁻¹ * partialProd f ⟨i, hn⟩.succ = f ⟨i, hn⟩

induction i with
  | zero => simp [-Fin.succ_mk, partialProd_succ]
  | succ i hi =>
    specialize hi (lt_trans (Nat.lt_succ_self i) hn)
    simp only [Fin.coe_eq_castSucc, Fin.succ_mk, Fin.castSucc_mk] at hi ⊢
    rw [← Fin.succ_mk _ _ (lt_trans (Nat.lt_succ_self _) hn), ← Fin.succ_mk _ _ hn]
    simp only [partialProd_succ, mul_inv_rev, Fin.castSucc_mk]
    -- Porting note: was
    -- assoc_rw [hi, inv_mul_cancel_left]
    rw [← mul_assoc, mul_left_eq_self, mul_assoc, hi, mul_left_inv]


α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ≤ b ↔ ∃ c, b = a ⊔ c

case mp
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ≤ b → ∃ c, b = a ⊔ c

case mpr
α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ (∃ c, b = a ⊔ c) → a ≤ b


α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : CancelMonoidWithZero M₀
a b c : M₀
hb : b ≠ 0
⊢ b = a * b ↔ a = 1


R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom = (μ R X X').hom ≫ (free R).map (f ⊗ g)

case H
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
      (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g))

case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ∀ (a : X),
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle a =
      (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle a

case H.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
        (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
      Finsupp.lsingle x =
    (TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
      Finsupp.lsingle x

case H.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
          (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
        Finsupp.lsingle x)
      1 =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
        Finsupp.lsingle x)
      1

case H.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
⊢ ∀ (a : X'),
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a =
      ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle a

case H.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
            (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x' =
    ((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
          Finsupp.lsingle x)
        1 ∘ₗ
      Finsupp.lsingle x'

case H.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
              (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1 =
    (((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
            Finsupp.lsingle x)
          1 ∘ₗ
        Finsupp.lsingle x')
      1

case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
⊢ ∀ (a : Y ⊗ Y'),
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                  (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a =
      ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
                Finsupp.lsingle x)
              1 ∘ₗ
            Finsupp.lsingle x')
          1)
        a

case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
y : Y
y' : Y'
⊢ ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂
                (((free R).map f ⊗ (free R).map g) ≫ (μ R Y Y').hom) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y') =
    ((((TensorProduct.mk R ↑((free R).obj X) ↑((free R).obj X')).compr₂ ((μ R X X').hom ≫ (free R).map (f ⊗ g)) ∘ₗ
              Finsupp.lsingle x)
            1 ∘ₗ
          Finsupp.lsingle x')
        1)
      (y, y')

case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
y : Y
y' : Y'
⊢ ((finsuppTensorFinsupp' R Y Y')
        (Finsupp.mapDomain f (Finsupp.single x 1) ⊗ₜ[R] Finsupp.mapDomain g (Finsupp.single x' 1)))
      (y, y') =
    (Finsupp.mapDomain (f ⊗ g) ((finsuppTensorFinsupp' R X X') (Finsupp.single x 1 ⊗ₜ[R] Finsupp.single x' 1))) (y, y')

change (finsuppTensorFinsupp' R Y Y')
    (Finsupp.mapDomain f (Finsupp.single x 1) ⊗ₜ[R] Finsupp.mapDomain g (Finsupp.single x' 1)) _
    = (Finsupp.mapDomain (f ⊗ g) (finsuppTensorFinsupp' R X X'
    (Finsupp.single x 1 ⊗ₜ[R] Finsupp.single x' 1))) _

case H.h.h.h.h.h
R : Type u
inst✝ : CommRing R
X Y X' Y' : Type u
f : X ⟶ Y
g : X' ⟶ Y'
x : X
x' : X'
y : Y
y' : Y'
⊢ (Finsupp.single (f x, g x') 1) (y, y') = (Finsupp.single (f x, g x') 1) (y, y')

simp_rw [Finsupp.mapDomain_single, finsuppTensorFinsupp'_single_tmul_single, mul_one,
    Finsupp.mapDomain_single, CategoryTheory.tensor_apply]


α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b✝ : Option β
c : Option γ
f : α → β → γ
a : Option α
b : β
⊢ map₂ f a (some b) = Option.map (fun a => f a b) a


ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / (b * e) ≤ c / (d * e)

ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / b * (1 / e) ≤ c / d * (1 / e)

exact mul_le_mul_of_nonneg_right h (one_div_nonneg (α := α) |>.2 he)


x✝ y x : ℝ
hx : 0 < cos x
⊢ tan x / √(1 + tan x ^ 2) = sin x

rw [← tan_mul_cos hx.ne', ← inv_sqrt_one_add_tan_sq hx, div_eq_mul_inv]


R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
α : Type u_2
inst✝ : DecidableEq α
x y a : R
s : Finset α
p : α → R
hp : ∀ i ∈ s, Prime (p i)
hx : x * y = a * ∏ i ∈ s, p i
⊢ ∃ t u b c, t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i

case empty
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
α : Type u_2
inst✝ : DecidableEq α
p : α → R
x y a : R
hp : ∀ i ∈ ∅, Prime (p i)
hx : x * y = a * ∏ i ∈ ∅, p i
⊢ ∃ t u b c, t ∪ u = ∅ ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i

case insert
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
α : Type u_2
inst✝ : DecidableEq α
p : α → R
i : α
s : Finset α
his : i ∉ s
ih :
  ∀ {x y a : R},
    (∀ i ∈ s, Prime (p i)) →
      x * y = a * ∏ i ∈ s, p i →
        ∃ t u b c, t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i
x y a : R
hp : ∀ i_1 ∈ insert i s, Prime (p i_1)
hx : x * y = a * ∏ i ∈ insert i s, p i
⊢ ∃ t u b c, t ∪ u = insert i s ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i

induction' s using Finset.induction with i s his ih generalizing x y a


α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
f : E → F
p : FormalMultilinearSeries 𝕜 E F
x : E
⊢ HasFPowerSeriesWithinAt f p univ x ↔ HasFPowerSeriesAt f p x

simp only [HasFPowerSeriesWithinAt, hasFPowerSeriesWithinOnBall_univ, HasFPowerSeriesAt]


R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
z : S
⊢ (algebraMap R S) (sec M z).1 = (algebraMap R S) ↑(sec M z).2 * z


α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), ‖↑(r i n) - b i * ↑n‖ ≤ ↑n / log ↑n ^ 2

α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2

α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ ∀ᶠ (x : ℕ) in atTop, ‖↑(r i x) - b i * ↑x‖ ≤ ↑x / log ↑x ^ 2

simpa using IsLittleO.eventuallyLE (R.dist_r_b i)


ξ : ℝ
n : ℕ
n_pos : 0 < n
⊢ ∃ q, |ξ - ↑q| ≤ 1 / ((↑n + 1) * ↑q.den) ∧ q.den ≤ n

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
⊢ ∃ q, |ξ - ↑q| ≤ 1 / ((↑n + 1) * ↑q.den) ∧ q.den ≤ n

obtain ⟨j, k, hk₀, hk₁, h⟩ := exists_int_int_abs_mul_sub_le ξ n_pos

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk₀' : 0 < ↑k
⊢ ∃ q, |ξ - ↑q| ≤ 1 / ((↑n + 1) * ↑q.den) ∧ q.den ≤ n

have hk₀' : (0 : ℝ) < k := Int.cast_pos.mpr hk₀

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk₀' : 0 < ↑k
hden : ↑(↑j / ↑k).den ≤ k
⊢ ∃ q, |ξ - ↑q| ≤ 1 / ((↑n + 1) * ↑q.den) ∧ q.den ≤ n

have hden : ((j / k : ℚ).den : ℤ) ≤ k := by
    convert le_of_dvd hk₀ (Rat.den_dvd j k)
    exact Rat.intCast_div_eq_divInt _ _

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk₀' : 0 < ↑k
hden : ↑(↑j / ↑k).den ≤ k
⊢ |ξ - ↑(↑j / ↑k)| ≤ 1 / ((↑n + 1) * ↑(↑j / ↑k).den)

refine ⟨j / k, ?_, Nat.cast_le.mp (hden.trans hk₁)⟩

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk₀' : 0 < ↑k
hden : ↑(↑j / ↑k).den ≤ k
⊢ |ξ - ↑(↑j / ↑k)| * ↑(↑j / ↑k).den ≤ 1 / (↑n + 1)

rw [← div_div, le_div_iff (Nat.cast_pos.mpr <| Rat.pos _ : (0 : ℝ) < _)]

case intro.intro.intro.intro
ξ : ℝ
n : ℕ
n_pos : 0 < n
j k : ℤ
hk₀ : 0 < k
hk₁ : k ≤ ↑n
h : |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)
hk₀' : 0 < ↑k
hden : ↑(↑j / ↑k).den ≤ k
⊢ |ξ - ↑(↑j / ↑k)| * ↑k ≤ 1 / (↑n + 1)

refine (mul_le_mul_of_nonneg_left (Int.cast_le.mpr hden : _ ≤ (k : ℝ)) (abs_nonneg _)).trans ?_

rwa [← abs_of_pos hk₀', Rat.cast_div, Rat.cast_intCast, Rat.cast_intCast, ← abs_mul, sub_mul,
    div_mul_cancel₀ _ hk₀'.ne', mul_comm]


ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a ⇔ b = a ⇨ b

rw [bihimp, himp_eq_top_iff.2 h, top_inf_eq]


R : Type u_1
inst✝ : NonAssocSemiring R
⊢ ↑(ringChar R) = 0


ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : b ≤ a
⊢ a \ b ⊔ b = a


R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Nonsingular x (W.negY x y) ↔ W.Nonsingular x y

R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ∧ (W.a₁ * W.negY x y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ W.negY x y) ↔
    W.Equation x y ∧ (W.a₁ * y ≠ 3 * x ^ 2 + 2 * W.a₂ * x + W.a₄ ∨ y ≠ -y - W.a₁ * x - W.a₃)

rw [nonsingular_iff, equation_neg_iff, ← negY, negY_negY, ← @ne_comm _ y, nonsingular_iff]

exact and_congr_right' <| (iff_congr not_and_or.symm not_and_or.symm).mpr <|
    not_congr <| and_congr_left fun h => by rw [← h]


X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t U : Set X
⊢ Continuous U.boolIndicator ↔ IsClopen U

rw [continuous_bool_rng true, preimage_boolIndicator_true]


F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
ps : Path F
a : F.A
f : F.B a → F.M
i : F.B a
⊢ isubtree (⟨a, i⟩ :: ps) (M.mk ⟨a, f⟩) = isubtree ps (f i)

F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited F.M
ps : Path F
a : F.A
f : F.B a → F.M
i : F.B a
⊢ isubtree ps (f (cast ⋯ i)) = isubtree ps (f i)

simp only [isubtree, ichildren_mk, PFunctor.Obj.iget, dif_pos, isubtree, M.casesOn_mk']


convert Int.ediv_add_emod' (2 * c + 1) 2


M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
mul : ∀ (x y : M), p x → p y → p (x * y)
⊢ p x

M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x

have : ∀ x ∈ closure s, p x := fun x hx => closure_induction hx mem mul


σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
⊢ ∃ r, (eval r) F ≠ 0

σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
hF₀ : F ≠ 0
⊢ ∃ r, (eval r) F ≠ 0

have hF₀ : F ≠ 0 := by contrapose! hFn; simp [hFn]

σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
⊢ ∃ r, (eval r) F ≠ 0

have hdeg : natDegree (finSuccEquiv R N F) < n + 1 := by
    linarith [natDegree_finSuccEquiv F, degreeOf_le_totalDegree F 0, hF.totalDegree hF₀]

case h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
⊢ (eval (Fin.cons 1 0)) F ≠ 0

case h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
⊢ (eval (Fin.cons 1 0)) F ≠ 0

have aux : ∀ i ∈ Finset.range n, constantCoeff ((finSuccEquiv R N F).coeff i) = 0 := by
    intro i hi
    rw [Finset.mem_range] at hi
    apply (hF.finSuccEquiv_coeff_isHomogeneous i (n-i) (by omega)).coeff_eq_zero
    simp only [Finsupp.degree_zero]
    rw [← Nat.sub_ne_zero_iff_lt] at hi
    exact hi.symm

case h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hFn : ((finSuccEquiv R N) F).coeff n ≠ 0
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
⊢ constantCoeff (((finSuccEquiv R N) F).coeff n) ≠ 0

simp_rw [eval_eq_eval_mv_eval', eval_one_map, Polynomial.eval_eq_sum_range' hdeg,
    eval_zero, one_pow, mul_one, map_sum, Finset.sum_range_succ, Finset.sum_eq_zero aux, zero_add]

case h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
hFn : constantCoeff (((finSuccEquiv R N) F).coeff n) = 0
⊢ ((finSuccEquiv R N) F).coeff n = 0

case h.a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
hFn : constantCoeff (((finSuccEquiv R N) F).coeff n) = 0
d : Fin N →₀ ℕ
⊢ coeff d (((finSuccEquiv R N) F).coeff n) = coeff d 0

case h.a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
hFn : constantCoeff (((finSuccEquiv R N) F).coeff n) = 0
d : Fin N →₀ ℕ
⊢ coeff d (((finSuccEquiv R N) F).coeff n) = 0

case h.a.inl
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
hFn : constantCoeff (((finSuccEquiv R N) F).coeff n) = 0
⊢ coeff 0 (((finSuccEquiv R N) F).coeff n) = 0

case h.a.inr
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n✝ N : ℕ
F : MvPolynomial (Fin N.succ) R
n : ℕ
hF : F.IsHomogeneous n
hF₀ : F ≠ 0
hdeg : ((finSuccEquiv R N) F).natDegree < n + 1
aux : ∀ i ∈ Finset.range n, constantCoeff (((finSuccEquiv R N) F).coeff i) = 0
hFn : constantCoeff (((finSuccEquiv R N) F).coeff n) = 0
d : Fin N →₀ ℕ
hd : d ≠ 0
⊢ coeff d (((finSuccEquiv R N) F).coeff n) = 0


R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (h.lift f') ((f x₁) x₂) = (f' x₁) x₂

R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (TensorProduct.lift f' ∘ₗ ↑h.equiv.symm) ((f x₁) x₂) = (f' x₁) x₂