C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f : X✝ ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasCokernels C
X : C
⊢ ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : Mono f] [inst_1 : Mono g] (i : A ≅ B),
    i.hom ≫ g = f →
      (fun A f x => Subobject.mk (cokernel.π f).op) A f inst = (fun A f x => Subobject.mk (cokernel.π f).op) B g inst_1

C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f : X✝ ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasCokernels C
X A B : C
g : B ⟶ X
hg : Mono g
i : A ≅ B
hf : Mono (i.hom ≫ g)
⊢ (fun A f x => Subobject.mk (cokernel.π f).op) A (i.hom ≫ g) hf = (fun A f x => Subobject.mk (cokernel.π f).op) B g hg

case refine_1
C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f : X✝ ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasCokernels C
X A B : C
g : B ⟶ X
hg : Mono g
i : A ≅ B
hf : Mono (i.hom ≫ g)
⊢ cokernel g ≅ cokernel (i.hom ≫ g)

case refine_2
C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f : X✝ ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasCokernels C
X A B : C
g : B ⟶ X
hg : Mono g
i : A ≅ B
hf : Mono (i.hom ≫ g)
⊢ (?refine_1.op.hom ≫ (cokernel.π g).op).unop = (cokernel.π (i.hom ≫ g)).op.unop

refine Subobject.mk_eq_mk_of_comm _ _ (Iso.op ?_) (Quiver.Hom.unop_inj ?_)

C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f : X✝ ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasCokernels C
X : C
⊢ ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [inst : Mono f] [inst_1 : Mono g],
    Subobject.mk f ≤ Subobject.mk g →
      Subobject.lift (fun A f x => Subobject.mk (cokernel.π f).op) ⋯ (Subobject.mk f) ≤
        Subobject.lift (fun A f x => Subobject.mk (cokernel.π f).op) ⋯ (Subobject.mk g)

C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f✝ : X✝ ⟶ Y
inst✝¹ : HasKernel f✝
inst✝ : HasCokernels C
X A B : C
f : A ⟶ X
g : B ⟶ X
hf : Mono f
hg : Mono g
h : Subobject.mk f ≤ Subobject.mk g
⊢ Subobject.lift (fun A f x => Subobject.mk (cokernel.π f).op) ⋯ (Subobject.mk f) ≤
    Subobject.lift (fun A f x => Subobject.mk (cokernel.π f).op) ⋯ (Subobject.mk g)

C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f✝ : X✝ ⟶ Y
inst✝¹ : HasKernel f✝
inst✝ : HasCokernels C
X A B : C
f : A ⟶ X
g : B ⟶ X
hf : Mono f
hg : Mono g
h : Subobject.mk f ≤ Subobject.mk g
⊢ Subobject.mk (cokernel.π f).op ≤ Subobject.mk (cokernel.π g).op

case refine_1
C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f✝ : X✝ ⟶ Y
inst✝¹ : HasKernel f✝
inst✝ : HasCokernels C
X A B : C
f : A ⟶ X
g : B ⟶ X
hf : Mono f
hg : Mono g
h : Subobject.mk f ≤ Subobject.mk g
⊢ f ≫ cokernel.π g = 0

case refine_2
C : Type u
inst✝³ : Category.{v, u} C
X✝ Y Z : C
inst✝² : HasZeroMorphisms C
f✝ : X✝ ⟶ Y
inst✝¹ : HasKernel f✝
inst✝ : HasCokernels C
X A B : C
f : A ⟶ X
g : B ⟶ X
hf : Mono f
hg : Mono g
h : Subobject.mk f ≤ Subobject.mk g
⊢ (cokernel.desc f (cokernel.π g) ?refine_1).op ≫ (cokernel.π f).op = (cokernel.π g).op

refine Subobject.mk_le_mk_of_comm (cokernel.desc f (cokernel.π g) ?_).op ?_


x✝¹ x✝ : ℤ
e : IsInt x✝¹ x✝
⊢ IsInt (x✝¹ % ↑0) x✝


α : 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
inst✝ : CompleteLattice β
S : Set (Set α)
f : α → β
⊢ ⨅ x ∈ ⋃₀ S, f x = ⨅ s ∈ S, ⨅ x ∈ s, f x

rw [sUnion_eq_iUnion, iInf_iUnion, ← iInf_subtype'']


f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
hn : n ≠ 0
⊢ f 1 + logGammaSeq x n ≤ f x

f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
hn : n ≠ 0
⊢ f 1 + (x * log ↑n + log ↑n ! - ∑ m ∈ Finset.range (n + 1), log (x + ↑m)) ≤ f x

f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
hn : n ≠ 0
⊢ f 1 + (x * log ↑n + log ↑n !) ≤ f (↑(n + 1) + x)

rw [← add_sub_assoc, sub_le_iff_le_add, ← f_add_nat_eq (@hf_feq) hx, add_comm x _]

case refine_1
f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
hn : n ≠ 0
⊢ f 1 + (x * log ↑n + log ↑n !) = f ↑(n + 1) + x * log (↑(n + 1) - 1)

case refine_2
f : ℝ → ℝ
x : ℝ
n : ℕ
hf_conv : ConvexOn ℝ (Ioi 0) f
hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y
hx : 0 < x
hn : n ≠ 0
⊢ 2 ≤ n + 1

refine le_trans (le_of_eq ?_) (f_add_nat_ge hf_conv @hf_feq ?_ hx)


J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
X✝ Y✝ : J
f : X✝ ⟶ Y✝
g : (fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y) X✝
⊢ (fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y) Y✝

case refine_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
X✝ Y✝ : J
f : X✝ ⟶ Y✝
g : (fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y) X✝
⊢ limit.π (F ⋙ objects) Y✝ X = (F.map f).obj (limit.π (F ⋙ objects) X✝ X)

case refine_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
X✝ Y✝ : J
f : X✝ ⟶ Y✝
g : (fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y) X✝
⊢ (F.map f).obj (limit.π (F ⋙ objects) X✝ Y) = limit.π (F ⋙ objects) Y✝ Y

refine eqToHom ?_ ≫ (F.map f).map g ≫ eqToHom ?_

J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X✝ Y : limit (F ⋙ objects)
X : J
⊢ { obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
            map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
        X)

case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X✝ Y : limit (F ⋙ objects)
X : J
f :
  { obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
        map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
    X
⊢ { obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (𝟙 X) f =
    𝟙
      ({ obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
            map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
        X)
      f

case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X✝ Y : limit (F ⋙ objects)
X : J
f :
  { obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
        map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
    X
this : Category.{v, v} (objects.obj (F.obj X)) := inferInstance
⊢ { obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (𝟙 X) f =
    𝟙
      ({ obj := fun j => limit.π (F ⋙ objects) j X✝ ⟶ limit.π (F ⋙ objects) j Y,
            map := fun {X Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
        X)
      f

letI : Category (objects.obj (F.obj X)) := (inferInstance : Category (F.obj X))

J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
x✝¹ x✝ Z : J
f : x✝¹ ⟶ x✝
g : x✝ ⟶ Z
⊢ { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (f ≫ g) =
    { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
            map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
        f ≫
      { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
            map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
        g

case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
x✝¹ x✝ Z : J
f : x✝¹ ⟶ x✝
g : x✝ ⟶ Z
h :
  { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
        map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
    x✝¹
⊢ { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (f ≫ g) h =
    ({ obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
              map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
          f ≫
        { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
              map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
          g)
      h

case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
x✝¹ x✝ Z : J
f : x✝¹ ⟶ x✝
g : x✝ ⟶ Z
h :
  { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
        map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.obj
    x✝¹
this : Category.{v, v} (objects.obj (F.obj Z)) := inferInstance
⊢ { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
          map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
      (f ≫ g) h =
    ({ obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
              map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
          f ≫
        { obj := fun j => limit.π (F ⋙ objects) j X ⟶ limit.π (F ⋙ objects) j Y,
              map := fun {X_1 Y_1} f g => eqToHom ⋯ ≫ (F.map f).map g ≫ eqToHom ⋯ }.map
          g)
      h

letI : Category (objects.obj (F.obj Z)) := (inferInstance : Category (F.obj Z))

simp [Functor.congr_hom (F.map_comp f g) h, eqToHom_map]


α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M✝
α : Type u_13
M : Type u_14
inst✝ : Zero M
⊢ Injective graph

α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M✝
α : Type u_13
M : Type u_14
inst✝ : Zero M
f g : α →₀ M
h : f.graph = g.graph
⊢ f = g

classical
    have hsup : f.support = g.support := by rw [← image_fst_graph, h, image_fst_graph]
    refine ext_iff'.2 ⟨hsup, fun x hx => apply_eq_of_mem_graph <| h.symm ▸ ?_⟩
    exact mk_mem_graph _ (hsup ▸ hx)


C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ (e.hom ≫ e'.hom) ≫ e'.inv ≫ e.inv = e.hom ≫ (e'.hom ≫ e'.inv) ≫ e.inv

C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ e.hom ≫ 𝟙 S₂ ≫ e.inv = e.hom ≫ e.inv

C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ (e'.inv ≫ e.inv) ≫ e.hom ≫ e'.hom = e'.inv ≫ (e.inv ≫ e.hom) ≫ e'.hom

C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ e'.inv ≫ 𝟙 S₂ ≫ e'.hom = e'.inv ≫ e'.hom


k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h : affineSpan k s = ⊤
⊢ s.Nonempty

k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h : affineSpan k s = ⊤
⊢ s ≠ ∅

k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
h : affineSpan k ∅ = ⊤
⊢ False

k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
h : ⊥ = ⊤
⊢ False


α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
h : (𝓤 α).HasBasis p s
x : α
⊢ (𝓝 x).HasBasis p fun i => {y | (y, x) ∈ s i}

α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
x : α
h : (comap Prod.swap (𝓤 α)).HasBasis p fun i => Prod.swap ⁻¹' s i
⊢ (𝓝 x).HasBasis p fun i => {y | (y, x) ∈ s i}

α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
x : α
h : (𝓤 α).HasBasis p fun i => Prod.swap ⁻¹' s i
⊢ (𝓝 x).HasBasis p fun i => {y | (y, x) ∈ s i}


α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)

α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)

α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Nat.card α = Nat.card β ↔ Nonempty (α ≃ β)

simp only [Nat.card_eq_fintype_card, Fintype.card_eq]


C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : ShortComplex (CochainComplex C ℤ)
hS : S.ShortExact
i j : ℤ
h : i + -1 = j
⊢ (inl S.f).v i j h ≫ (descShortComplex S).f j = 0


α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(g.compQuasiMeasurePreserving f hf) =ᶠ[ae μ] ↑g ∘ f

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(mk (↑g ∘ f) ⋯) =ᶠ[ae μ] ↑g ∘ f


ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N : Type u_3
inst✝¹ : Monoid N
inst✝ : DecidableEq ι
i : ι
x : M i
⊢ (lift (Pi.mulSingle i (MonoidHom.id (M i)))) (of x) = x

simp only [lift_of, Pi.mulSingle_eq_same, MonoidHom.id_apply]


l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
⊢ rank 1 = Fintype.card n

rw [rank, mulVecLin_one, LinearMap.range_id, finrank_top, finrank_pi]


α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x y : FreeGroup α
⊢ (x * y).norm = (mk (x.toWord ++ y.toWord)).norm


α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : ContinuousAt f x
hg : Tendsto g p (𝓝 x)
hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
⊢ Tendsto (fun n => F n (g n)) p (𝓝 (f x))

α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : ContinuousWithinAt f univ x
hg : Tendsto g p (𝓝 x)
hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
⊢ Tendsto (fun n => F n (g n)) p (𝓝 (f x))

α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : ContinuousWithinAt f univ x
hg : Tendsto g p (𝓝[univ] x)
hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝[univ] x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
⊢ Tendsto (fun n => F n (g n)) p (𝓝 (f x))

exact tendsto_comp_of_locally_uniform_limit_within h hg hunif


α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : ¬(s.Nonempty ∧ t.Nonempty)
⊢ False

α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : s = ∅ ∨ t = ∅
⊢ False

simp_rw [not_and_or, not_nonempty_iff_eq_empty] at H

obtain rfl | rfl := H <;> simp [Nat.not_lt_zero] at h


M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i

M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ⨆ i, S i → ∃ i, x ∈ S i

refine ⟨?_, fun ⟨i, hi⟩ ↦ le_iSup S i hi⟩

M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ closure (⋃ i, ↑(S i)) → ∃ i, x ∈ S i

suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
    simpa only [closure_iUnion, closure_eq (S _)] using this

case refine_1
M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
hx : x ∈ closure (⋃ i, ↑(S i))
⊢ ∃ i, 1 ∈ S i

case refine_2
M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
hι : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
hx : x ∈ closure (⋃ i, ↑(S i))
⊢ ∀ (x y : M), (∃ i, x ∈ S i) → (∃ i, y ∈ S i) → ∃ i, x * y ∈ S i

refine fun hx ↦ closure_induction hx (fun _ ↦ mem_iUnion.1) ?_ ?_


α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h : x ∉ xs
⊢ (xs ++ [x]).nextOr x d = d

case nil
α : Type u_1
inst✝ : DecidableEq α
x d : α
h : x ∉ []
⊢ ([] ++ [x]).nextOr x d = d

case cons
α : Type u_1
inst✝ : DecidableEq α
x d z : α
zs : List α
IH : x ∉ zs → (zs ++ [x]).nextOr x d = d
h : x ∉ z :: zs
⊢ (z :: zs ++ [x]).nextOr x d = d


J : Type u
inst✝ : Category.{v, u} J
F G : J ⥤ Type w
φ : F ⟶ G
x : (fun F => ↑F.sections) F
j j' : J
f : j ⟶ j'
⊢ (F.map f ≫ φ.app j') (↑x j) = (fun j => φ.app j (↑x j)) j'


X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen ((X.basicOpen r).ι ⁻¹ᵁ U)

X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen ((X.basicOpen r).ι ''ᵁ (X.basicOpen r).ι ⁻¹ᵁ U)

X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (⋯.functor.obj ((X.basicOpen r).ι ⁻¹ᵁ U))

X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) r))

rw [Opens.functor_obj_map_obj, Opens.openEmbedding_obj_top, inf_comm,
    ← Scheme.basicOpen_res _ _ (homOfLE le_top).op]


α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f

α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ {x | x ∈ s → x ∈ ∅} ∈ f ↔ sᶜ ∈ f

rw [← empty_mem_iff_bot, mem_inf_principal]

simp only [mem_empty_iff_false, imp_false, compl_def]


a✝ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b : ℝ
⊢ ∫ (x : ℝ) in a..b, Complex.cos (z * ↑x) = Complex.sin (z * ↑b) / z - Complex.sin (z * ↑a) / z

case hderiv
a✝ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b : ℝ
⊢ ∀ x ∈ [[a, b]], HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

case hint
a✝ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b : ℝ
⊢ IntervalIntegrable (fun y => Complex.cos (z * ↑y)) MeasureTheory.volume a b

case hint
a✝ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b : ℝ
⊢ IntervalIntegrable (fun y => Complex.cos (z * ↑y)) MeasureTheory.volume a b

case hderiv
a✝ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b : ℝ
⊢ ∀ x ∈ [[a, b]], HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

case hderiv
a✝¹ b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a b x : ℝ
a✝ : x ∈ [[a, b]]
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

case hderiv
a✝² b✝ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b x : ℝ
a✝ : x ∈ [[a✝¹, b]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

have a := Complex.hasDerivAt_sin (↑x * z)

case hderiv
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

have b : HasDerivAt (fun y => y * z : ℂ → ℂ) z ↑x := hasDerivAt_mul_const _

case hderiv
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
c : HasDerivAt (fun y => Complex.sin (y * z)) (Complex.cos (↑x * z) * z) ↑x
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

have c : HasDerivAt (fun y : ℂ => Complex.sin (y * z)) _ ↑x := HasDerivAt.comp (𝕜 := ℂ) x a b

case hderiv
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
c : HasDerivAt (fun y => Complex.sin (y * z)) (Complex.cos (↑x * z) * z) ↑x
d : HasDerivAt (fun y => Complex.sin (↑y * z) / z) (Complex.cos (↑x * z) * z / z) x
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

have d := HasDerivAt.comp_ofReal (c.div_const z)

case hderiv
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
c : HasDerivAt (fun y => Complex.sin (y * z)) (Complex.cos (↑x * z) * z) ↑x
d : HasDerivAt (fun y => Complex.sin (z * ↑y) / z) (z * Complex.cos (z * ↑x) / z) x
⊢ HasDerivAt (fun b => Complex.sin (z * ↑b) / z) (Complex.cos (z * ↑x)) x

case h.e'_7
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
c : HasDerivAt (fun y => Complex.sin (y * z)) (Complex.cos (↑x * z) * z) ↑x
d : HasDerivAt (fun y => Complex.sin (z * ↑y) / z) (z * Complex.cos (z * ↑x) / z) x
⊢ Complex.cos (z * ↑x) = z * Complex.cos (z * ↑x) / z

case h.e'_7
a✝² b✝¹ : ℝ
n : ℕ
z : ℂ
hz : z ≠ 0
a✝¹ b✝ x : ℝ
a✝ : x ∈ [[a✝¹, b✝]]
a : HasDerivAt Complex.sin (Complex.cos (↑x * z)) (↑x * z)
b : HasDerivAt (fun y => y * z) z ↑x
c : HasDerivAt (fun y => Complex.sin (y * z)) (Complex.cos (↑x * z) * z) ↑x
d : HasDerivAt (fun y => Complex.sin (z * ↑y) / z) (z * Complex.cos (z * ↑x) / z) x
⊢ Complex.cos (z * ↑x) = Complex.cos (z * ↑x) * z / z


F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
⊢ infClosure s ×ˢ infClosure t ≤ infClosure (s ×ˢ t)

case mk.intro.intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ (u.inf' hu id, v.inf' hv id) ∈ infClosure (s ×ˢ t)

rintro ⟨_, _⟩ ⟨⟨u, hu, hus, rfl⟩, v, hv, hvt, rfl⟩

case mk.intro.intro.intro.intro.intro.intro.intro.refine_1
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ ↑(u ×ˢ v) ⊆ s ×ˢ t

case mk.intro.intro.intro.intro.intro.intro.intro.refine_2
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ (u ×ˢ v).inf' ⋯ id = (u.inf' hu id, v.inf' hv id)


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

simp_rw [erase_eq, sdiff_union_sdiff_cancel hts (singleton_subset_iff.2 ha)]


V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : G.Walk u v
hu : u = u'
hv : v = v'
⊢ (p.copy hu hv).reverse = p.reverse.copy hv hu

V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u' v' : V
p : G.Walk u' v'
⊢ (p.copy ⋯ ⋯).reverse = p.reverse.copy ⋯ ⋯


a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
n : ℤ
⊢ a ^ n < ⊤

case ofNat
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
a✝ : ℕ
⊢ a ^ Int.ofNat a✝ < ⊤

case negSucc
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
a✝ : ℕ
⊢ a ^ Int.negSucc a✝ < ⊤


α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a : α
b c : β
f : α → β
s : Finset α
y : β
⊢ (filter (fun x => f x = y) s).Nonempty ↔ y ∈ image f s


α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
h2 : a ≤ c
h3 : c ≤ b
⊢ c = a ∨ c = b

case inl
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
h2✝ : a ≤ c
h3 : c ≤ b
h2 : a = c
⊢ c = a ∨ c = b

case inr
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
h2✝ : a ≤ c
h3 : c ≤ b
h2 : a < c
⊢ c = a ∨ c = b

case inr.inl
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
h2✝ : a ≤ c
h3✝ : c ≤ b
h2 : a < c
h3 : c = b
⊢ c = a ∨ c = b

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ⩿ b
h2✝ : a ≤ c
h3✝ : c ≤ b
h2 : a < c
h3 : c < b
⊢ c = a ∨ c = b


R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
⊢ ∀ (i j : Γ₀ˣ), ∃ k, v.ltAddSubgroup k ≤ v.ltAddSubgroup i ⊓ v.ltAddSubgroup j

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ₀ γ₁ : Γ₀ˣ
⊢ ∃ k, v.ltAddSubgroup k ≤ v.ltAddSubgroup γ₀ ⊓ v.ltAddSubgroup γ₁

case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ₀ γ₁ : Γ₀ˣ
⊢ v.ltAddSubgroup (min γ₀ γ₁) ≤ v.ltAddSubgroup γ₀ ⊓ v.ltAddSubgroup γ₁

case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ₀ γ₁ : Γ₀ˣ
⊢ ∀ (a : R), v a < ↑γ₀ → v a < ↑γ₁ → v a < ↑γ₀

simp only [ltAddSubgroup, Units.min_val, Units.val_le_val, lt_min_iff,
        AddSubgroup.mk_le_mk, setOf_subset_setOf, le_inf_iff, and_imp, imp_self, implies_true,
        forall_const, and_true]

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
⊢ ∀ (i : Γ₀ˣ), ∃ j, ↑(v.ltAddSubgroup j) * ↑(v.ltAddSubgroup j) ⊆ ↑(v.ltAddSubgroup i)

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ : Γ₀ˣ
⊢ ∃ j, ↑(v.ltAddSubgroup j) * ↑(v.ltAddSubgroup j) ⊆ ↑(v.ltAddSubgroup γ)

case intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ γ₀ : Γ₀ˣ
h : γ₀ * γ₀ ≤ γ
⊢ ∃ j, ↑(v.ltAddSubgroup j) * ↑(v.ltAddSubgroup j) ⊆ ↑(v.ltAddSubgroup γ)

case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ γ₀ : Γ₀ˣ
h : γ₀ * γ₀ ≤ γ
⊢ ↑(v.ltAddSubgroup γ₀) * ↑(v.ltAddSubgroup γ₀) ⊆ ↑(v.ltAddSubgroup γ)

case h.intro.intro.intro.intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
γ γ₀ : Γ₀ˣ
h : γ₀ * γ₀ ≤ γ
r : R
r_in : r ∈ ↑(v.ltAddSubgroup γ₀)
s : R
s_in : s ∈ ↑(v.ltAddSubgroup γ₀)
⊢ (fun x x_1 => x * x_1) r s ∈ ↑(v.ltAddSubgroup γ)

calc
        (v (r * s) : Γ₀) = v r * v s := Valuation.map_mul _ _ _
        _ < γ₀ * γ₀ := mul_lt_mul₀ r_in s_in
        _ ≤ γ := mod_cast h

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
⊢ ∀ (x : R) (i : Γ₀ˣ), ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(v.ltAddSubgroup i)

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ : Γ₀ˣ
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(v.ltAddSubgroup γ)

case inl
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ : Γ₀ˣ
Hx : v x = 0
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(v.ltAddSubgroup γ)

case inr.intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ γx : Γ₀ˣ
Hx : v x = ↑γx
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(v.ltAddSubgroup γ)

rcases GroupWithZero.eq_zero_or_unit (v x) with (Hx | ⟨γx, Hx⟩)

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
⊢ ∀ (x : R) (i : Γ₀ˣ), ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(v.ltAddSubgroup i)

R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ : Γ₀ˣ
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(v.ltAddSubgroup γ)

case inl
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ : Γ₀ˣ
Hx : v x = 0
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(v.ltAddSubgroup γ)

case inr.intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x : R
γ γx : Γ₀ˣ
Hx : v x = ↑γx
⊢ ∃ j, ↑(v.ltAddSubgroup j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(v.ltAddSubgroup γ)


ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : G.Adj a b
⊢ G.incidenceSet a ∩ G.incidenceSet b = {s(a, b)}

ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : G.Adj a b
⊢ {s(a, b)} ⊆ G.incidenceSet a ∩ G.incidenceSet b

refine (G.incidenceSet_inter_incidenceSet_subset <| h.ne).antisymm ?_

ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
h : G.Adj a b
⊢ s(a, b) ∈ G.incidenceSet a ∩ G.incidenceSet b

exact ⟨G.mk'_mem_incidenceSet_left_iff.2 h, G.mk'_mem_incidenceSet_right_iff.2 h⟩


α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
C✝ : Computation α → Computation β → Prop
R : α → β → Prop
C : Computation α → Computation β → Prop
H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → LiftRelAux R C ca.destruct cb.destruct
ca : Computation α
cb : Computation β
Hc : C ca cb
a : α
ha : a ∈ ca
⊢ LiftRel R ca cb

α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
C✝ : Computation α → Computation β → Prop
R : α → β → Prop
C : Computation α → Computation β → Prop
H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → LiftRelAux R C ca.destruct cb.destruct
ca : Computation α
a : α
ha : a ∈ ca
⊢ ∀ (cb : Computation β), C ca cb → LiftRel R ca cb

case refine_1
α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
C✝ : Computation α → Computation β → Prop
R : α → β → Prop
C : Computation α → Computation β → Prop
H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → LiftRelAux R C ca.destruct cb.destruct
ca : Computation α
a : α
ha : a ∈ ca
cb : Computation β
Hc : C (pure a) cb
h : LiftRelAux R C (pure a).destruct cb.destruct
⊢ LiftRel R (pure a) cb

case refine_2
α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
C✝ : Computation α → Computation β → Prop
R : α → β → Prop
C : Computation α → Computation β → Prop
H : ∀ {ca : Computation α} {cb : Computation β}, C ca cb → LiftRelAux R C ca.destruct cb.destruct
ca : Computation α
a : α
ha : a ∈ ca
ca' : Computation α
IH : (fun ca => ∀ (cb : Computation β), C ca cb → LiftRel R ca cb) ca'
cb : Computation β
Hc : C ca'.think cb
h : LiftRelAux R C ca'.think.destruct cb.destruct
⊢ LiftRel R ca'.think cb

refine memRecOn (C := (fun ca ↦ ∀ (cb : Computation β), C ca cb → LiftRel R ca cb))
    ha ?_ (fun ca' IH => ?_) <;> intro cb Hc <;> have h := H Hc


n : ℕ
r : ℝ
⊢ ↑n ≤ r.toNNReal ↔ ↑n ≤ r ∨ n = 0

simpa [n.cast_nonneg.le_iff_eq] using toNNReal_le_toNNReal_iff' (r := n)


σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : R[X]
h : Coe.coe x = Coe.coe y
⊢ x = y

case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : R[X]
h : Coe.coe x = Coe.coe y
n✝ : ℕ
⊢ x.coeff n✝ = y.coeff n✝

case a
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ x y : R[X]
h : Coe.coe x = Coe.coe y
n✝ : ℕ
⊢ (PowerSeries.coeff R n✝) ↑x = (PowerSeries.coeff R n✝) ↑y


α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝² : Group G
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
s : S
a : G
ha : a ∈ s
⊢ MulOpposite.op a • ↑s = ↑s

case h
α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝² : Group G
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
s : S
a : G
ha : a ∈ s
x✝ : G
⊢ x✝ ∈ MulOpposite.op a • ↑s ↔ x✝ ∈ ↑s

simp [Set.mem_smul_set_iff_inv_smul_mem, mul_mem_cancel_right, ha]


R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
s : ↥S
⊢ 0 /ₒ s = 0

R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
s : ↥S
⊢ ∃ u v, u • 0 = v • 0 ∧ ↑u * ↑1 = v * ↑s


R : Type u_1
inst✝ : CommSemiring R
t : ↥(Submonoid.closure {X})
⊢ IsUnit ((algebraMap R[X] R[T;T⁻¹]) ↑t)

case mk
R : Type u_1
inst✝ : CommSemiring R
t : R[X]
ht : t ∈ Submonoid.closure {X}
⊢ IsUnit ((algebraMap R[X] R[T;T⁻¹]) ↑⟨t, ht⟩)

case mk.intro
R : Type u_1
inst✝ : CommSemiring R
n : ℕ
ht : X ^ n ∈ Submonoid.closure {X}
⊢ IsUnit ((algebraMap R[X] R[T;T⁻¹]) ↑⟨X ^ n, ht⟩)

rcases Submonoid.mem_closure_singleton.mp ht with ⟨n, rfl⟩

simp only [isUnit_T n, algebraMap_eq_toLaurent, Polynomial.toLaurent_X_pow]

R : Type u_1
inst✝ : CommSemiring R
f : R[T;T⁻¹]
⊢ ∃ x, f * (algebraMap R[X] R[T;T⁻¹]) ↑x.2 = (algebraMap R[X] R[T;T⁻¹]) x.1

case Qf
R : Type u_1
inst✝ : CommSemiring R
f : R[X]
n : ℕ
⊢ ∃ x, toLaurent f * T (-↑n) * (algebraMap R[X] R[T;T⁻¹]) ↑x.2 = (algebraMap R[X] R[T;T⁻¹]) x.1

induction' f using LaurentPolynomial.induction_on_mul_T with f n

case Qf
R : Type u_1
inst✝ : CommSemiring R
f : R[X]
n : ℕ
this : X ^ n ∈ Submonoid.closure {X}
⊢ ∃ x, toLaurent f * T (-↑n) * (algebraMap R[X] R[T;T⁻¹]) ↑x.2 = (algebraMap R[X] R[T;T⁻¹]) x.1

have := (Submonoid.closure ({X} : Set R[X])).pow_mem Submonoid.mem_closure_singleton_self n

case Qf
R : Type u_1
inst✝ : CommSemiring R
f : R[X]
n : ℕ
this : X ^ n ∈ Submonoid.closure {X}
⊢ toLaurent f * T (-↑n) * (algebraMap R[X] R[T;T⁻¹]) ↑(f, ⟨X ^ n, this⟩).2 =
    (algebraMap R[X] R[T;T⁻¹]) (f, ⟨X ^ n, this⟩).1

simp only [algebraMap_eq_toLaurent, Polynomial.toLaurent_X_pow, mul_T_assoc,
        add_left_neg, T_zero, mul_one]

R : Type u_1
inst✝ : CommSemiring R
f g : R[X]
⊢ (algebraMap R[X] R[T;T⁻¹]) f = (algebraMap R[X] R[T;T⁻¹]) g → ∃ c, ↑c * f = ↑c * g

R : Type u_1
inst✝ : CommSemiring R
f g : R[X]
⊢ f = g → ∃ c, ↑c * f = ↑c * g

rw [algebraMap_eq_toLaurent, algebraMap_eq_toLaurent, Polynomial.toLaurent_inj]

R : Type u_1
inst✝ : CommSemiring R
f : R[X]
⊢ ∃ c, ↑c * f = ↑c * f


G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ a⁻¹ * b ∈ ker f

G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ f (a⁻¹ * b) = 1


J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
f : j ⟶ j'
w : F.map f x = x'
⊢ colimit.ι F j x = colimit.ι F j' x'


α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ x ∈ toList α

α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ ∃ a, equiv.symm a = x

α : Type u
β : α → Type v
inst✝ : FinEnum α
x : α
⊢ equiv.symm (equiv x) = x


α : Sort u_1
β✝ : Sort u_2
p q : α → Prop
β : α → Sort u_3
⊢ (∀ (a : α), β a → True) ↔ True


𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
y : (i : ι) → E i
x✝ : y ∈ EMetric.ball 0 ⊤
⊢ (∑ i ∈ Finset.range (Fintype.card ι + 1), (f.toFormalMultilinearSeries i) fun x => y) = f (0 + y)

𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
y : (i : ι) → E i
x✝ : y ∈ EMetric.ball 0 ⊤
⊢ ((f.toFormalMultilinearSeries (Fintype.card ι)) fun x => y) = f y

𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E✝ : Type u
inst✝⁶ : NormedAddCommGroup E✝
inst✝⁵ : NormedSpace 𝕜 E✝
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
ι : Type u_2
E : ι → Type u_3
inst✝² : (i : ι) → NormedAddCommGroup (E i)
inst✝¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝ : Fintype ι
f : ContinuousMultilinearMap 𝕜 E F
y : (i : ι) → E i
x✝ : y ∈ EMetric.ball 0 ⊤
⊢ ∀ b ∈ Finset.range (Fintype.card ι + 1), b ≠ Fintype.card ι → ((f.toFormalMultilinearSeries b) fun x => y) = 0

rw [Finset.sum_eq_single_of_mem _ (Finset.self_mem_range_succ _), zero_add]


α : Type u
β : Type v
γ : Type u_1
f✝ g : Ultrafilter α
s t : Set α
p q : α → Prop
f : Ultrafilter α
h₀ : optParam (Injective id) ⋯
⊢ range id ∈ f

α : Type u
β : Type v
γ : Type u_1
f✝ g : Ultrafilter α
s t : Set α
p q : α → Prop
f : Ultrafilter α
h₀ : optParam (Injective id) ⋯
⊢ univ ∈ f


ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter p s }
⊢ p ↑x

ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter (fun x => ¬p x) s }
⊢ ¬p ↑x

ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter p s }
_hx : x ∈ (filter p s).attach
⊢ p ↑x

ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
s : Finset α
p : α → Prop
hp : DecidablePred p
inst✝ : DecidablePred fun x => ¬p x
f : (x : α) → p x → γ
g : (x : α) → ¬p x → γ
h : γ → β
x : { x // x ∈ filter (fun x => ¬p x) s }
_hx : x ∈ (filter (fun x => ¬p x) s).attach
⊢ ¬p ↑x


K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
f : K →+* L
s : Subfield L
h : s ≤ f.fieldRange
⊢ map f (comap f s) = s

simpa only [inf_of_le_left h] using map_comap_eq f s


𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
⊢ ‖u - v‖ = ⨅ w, ‖u - ↑w‖ ↔ ∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0

𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
this : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
⊢ ‖u - v‖ = ⨅ w, ‖u - ↑w‖ ↔ ∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0

letI : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E

𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
⊢ ‖u - v‖ = ⨅ w, ‖u - ↑w‖ ↔ ∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0

letI : Module ℝ E := RestrictScalars.module ℝ 𝕜 E

𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
K' : Submodule ℝ E := Submodule.restrictScalars ℝ K
⊢ ‖u - v‖ = ⨅ w, ‖u - ↑w‖ ↔ ∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0

let K' : Submodule ℝ E := K.restrictScalars ℝ

case mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
K' : Submodule ℝ E := Submodule.restrictScalars ℝ K
⊢ ‖u - v‖ = ⨅ w, ‖u - ↑w‖ → ∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0

case mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
u v : E
hv : v ∈ K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.rclikeToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
K' : Submodule ℝ E := Submodule.restrictScalars ℝ K
⊢ (∀ w ∈ K, ⟪u - v, w⟫_𝕜 = 0) → ‖u - v‖ = ⨅ w, ‖u - ↑w‖


C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
p q : ℤ
hpq : p + n = q
p' : ℤ
hp' : p' + n' = q
⊢ p = p' + a

C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
p q : ℤ
hpq : p + n = q
p' : ℤ
hp' : p' + n' = q
⊢ p' + n' = q

C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
p q : ℤ
hpq : p + n = q
p' : ℤ
hp' : p' + n' = q
⊢ (γ.leftUnshift n hn).v p q hpq =
    (a * n' + a * (a - 1) / 2).negOnePow • (K.shiftFunctorObjXIso a p' p ⋯).inv ≫ γ.v p' q ⋯

C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n' a : ℤ
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
n : ℤ
hn : n + a = n'
p q : ℤ
hpq : p + n = q
hp' : p - a + n' = q
⊢ (γ.leftUnshift n hn).v p q hpq =
    (a * n' + a * (a - 1) / 2).negOnePow • (K.shiftFunctorObjXIso a (p - a) p ⋯).inv ≫ γ.v (p - a) q ⋯


α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p μ
⊢ edist (Memℒp.toLp f hf) 0 = eLpNorm f p μ

case h.e'_3.h.e'_5
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p μ
⊢ f = f - 0

convert edist_toLp_toLp f 0 hf zero_memℒp


R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + ↑n) = ↑↑m + ↑↑n

simp [-Int.natCast_add, ← Int.ofNat_add]

R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + -[n+1]) = ↑↑m + ↑-[n+1]

erw [cast_subNatNat, cast_natCast, cast_negSucc, sub_eq_add_neg]

R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(-[m+1] + ↑n) = ↑-[m+1] + ↑↑n

erw [cast_subNatNat, cast_natCast, cast_negSucc, sub_eq_iff_eq_add, add_assoc,
      eq_neg_add_iff_add_eq, ← Nat.cast_add, ← Nat.cast_add, Nat.add_comm]

R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑-[m + n + 1+1] = ↑-[m+1] + ↑-[n+1]

rw [cast_negSucc, cast_negSucc, cast_negSucc, ← neg_add_rev, ← Nat.cast_add,
        Nat.add_right_comm m n 1, Nat.add_assoc, Nat.add_comm]


simpa using nadd_le_nadd_left (Ordinal.zero_le b) a


ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝² : Fintype ι
inst✝¹ : Fintype κ
inst✝ : CommMonoid α
s : Finset ι
f : ι → α
h : ∀ (i : ι), f i ≠ 1 → i ∈ s
⊢ ∀ x ∈ univ, x ∉ s → f x = 1


α : Type u_1
β : Type u_2
g : β → Set (Set α)
h_pi : ∀ (b : β), IsPiSystem (g b)
t : Set α
h_t : t ∈ generatePiSystem (⋃ b, g b)
⊢ ∃ T f, t = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b

case base
α : Type u_1
β : Type u_2
g : β → Set (Set α)
h_pi : ∀ (b : β), IsPiSystem (g b)
t s : Set α
h_s : s ∈ ⋃ b, g b
⊢ ∃ T f, s = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b

case inter
α : Type u_1
β : Type u_2
g : β → Set (Set α)
h_pi : ∀ (b : β), IsPiSystem (g b)
t s t' : Set α
h_gen_s : generatePiSystem (⋃ b, g b) s
h_gen_t' : generatePiSystem (⋃ b, g b) t'
h_nonempty : (s ∩ t').Nonempty
h_s : ∃ T f, s = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b
h_t' : ∃ T f, t' = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b
⊢ ∃ T f, s ∩ t' = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b

induction' h_t with s h_s s t' h_gen_s h_gen_t' h_nonempty h_s h_t'


C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝ : Φ.functor.IsEquivalence
h : W₂ ≤ W₁.map Φ.functor
⊢ Φ.IsLocalizedEquivalence

C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝ : Φ.functor.IsEquivalence
h : W₂ ≤ W₁.map Φ.functor
this : (Φ.functor ⋙ W₂.Q).IsLocalization W₁
⊢ Φ.IsLocalizedEquivalence

haveI : Functor.IsLocalization (Φ.functor ⋙ MorphismProperty.Q W₂) W₁ := by
    refine Functor.IsLocalization.of_equivalence_source W₂.Q W₂ (Φ.functor ⋙ W₂.Q) W₁
      (Functor.asEquivalence Φ.functor).symm ?_ (Φ.inverts W₂.Q)
      ((Functor.associator _ _ _).symm ≪≫ isoWhiskerRight ((Equivalence.unitIso _).symm) _ ≪≫
        Functor.leftUnitor _)
    erw [W₁.isoClosure.inverseImage_equivalence_functor_eq_map_inverse]
    rw [MorphismProperty.map_isoClosure]
    exact h

exact IsLocalizedEquivalence.of_isLocalization_of_isLocalization Φ W₂.Q


K : Type u_1
g : GenContFract K
n✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
p : Pair K
h : s.head = some p
n : ℕ
⊢ convs'Aux s (n + 1) = p.a / (p.b + convs'Aux s.tail n)


A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ coeSubmodule (FractionRing B) (differentIdeal A B) = 1 / Submodule.traceDual A (FractionRing A) 1

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this : IsIntegralClosure B A (FractionRing B)
⊢ coeSubmodule (FractionRing B) (differentIdeal A B) = 1 / Submodule.traceDual A (FractionRing A) 1

have : IsIntegralClosure B A (FractionRing B) :=
    IsIntegralClosure.of_isIntegrallyClosed _ _ _

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this : IsIntegralClosure B A (FractionRing B)
⊢ 1 / Submodule.traceDual A (FractionRing A) 1 ≤ LinearMap.range (Algebra.linearMap B (FractionRing B))

rw [coeSubmodule, differentIdeal, Submodule.map_comap_eq, inf_eq_right]

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝ : IsIntegralClosure B A (FractionRing B)
this : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
⊢ 1 / Submodule.traceDual A (FractionRing A) 1 ≤ LinearMap.range (Algebra.linearMap B (FractionRing B))

have := FractionalIdeal.dual_inv_le (A := A) (K := FractionRing A)
    (1 : FractionalIdeal B⁰ (FractionRing B))

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
this : (fun a => ↑a) (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ ↑1
⊢ 1 / Submodule.traceDual A (FractionRing A) 1 ≤ LinearMap.range (Algebra.linearMap B (FractionRing B))

have : _ ≤ ((1 : FractionalIdeal B⁰ (FractionRing B)) : Submodule B (FractionRing B)) := this

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
this : ↑(1 / FractionalIdeal.dual A (FractionRing A) 1) ≤ ↑1
⊢ 1 / Submodule.traceDual A (FractionRing A) 1 ≤ LinearMap.range (Algebra.linearMap B (FractionRing B))

simp only [← one_div, FractionalIdeal.val_eq_coe] at this

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
this : ↑1 / Submodule.traceDual A (FractionRing A) ↑1 ≤ ↑1
⊢ 1 / Submodule.traceDual A (FractionRing A) 1 ≤ LinearMap.range (Algebra.linearMap B (FractionRing B))

case hI
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
this : ↑1 / ↑(FractionalIdeal.dual A (FractionRing A) 1) ≤ ↑1
⊢ 1 ≠ 0

A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²² : CommRing A
inst✝²¹ : Field K
inst✝²⁰ : CommRing B
inst✝¹⁹ : Field L
inst✝¹⁸ : Algebra A K
inst✝¹⁷ : Algebra B L
inst✝¹⁶ : Algebra A B
inst✝¹⁵ : Algebra K L
inst✝¹⁴ : Algebra A L
inst✝¹³ : IsScalarTower A K L
inst✝¹² : IsScalarTower A B L
inst✝¹¹ : IsDomain A
inst✝¹⁰ : IsFractionRing A K
inst✝⁹ : IsIntegralClosure B A L
inst✝⁸ : IsFractionRing B L
inst✝⁷ : FiniteDimensional K L
inst✝⁶ : Algebra.IsSeparable K L
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDedekindDomain B
inst✝³ : NoZeroSMulDivisors A B
inst✝² : Algebra.IsIntegral A B
inst✝¹ : Algebra.IsSeparable (FractionRing A) (FractionRing B)
inst✝ : FiniteDimensional (FractionRing A) (FractionRing B)
this✝¹ : IsIntegralClosure B A (FractionRing B)
this✝ : (FractionalIdeal.dual A (FractionRing A) 1)⁻¹ ≤ 1
this : ↑(1 / FractionalIdeal.dual A (FractionRing A) 1) ≤ ↑1
⊢ 1 ≠ 0

rw [FractionalIdeal.coe_div (FractionalIdeal.dual_ne_zero _ _ _),
    FractionalIdeal.coe_dual] at this


α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
⊢ Measurable fun a => (f a).measure

α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
⊢ Measurable fun b => (f b).measure s

refine Measure.measurable_measure.mpr fun s hs ↦ ?_

α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
this : ∀ (a : α), IsProbabilityMeasure (f a).measure
⊢ Measurable fun b => (f b).measure s

have : ∀ a, IsProbabilityMeasure (f a).measure :=
    fun a ↦ (f a).isProbabilityMeasure (hf_bot a) (hf_top a)

case refine_1
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
this : ∀ (a : α), IsProbabilityMeasure (f a).measure
⊢ (fun s => Measurable fun b => (f b).measure s) ∅

case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
this : ∀ (a : α), IsProbabilityMeasure (f a).measure
⊢ ∀ t ∈ range Iic, (fun s => Measurable fun b => (f b).measure s) t

case refine_3
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
this : ∀ (a : α), IsProbabilityMeasure (f a).measure
⊢ ∀ (t : Set ℝ),
    MeasurableSet t →
      (fun s => Measurable fun b => (f b).measure s) t → (fun s => Measurable fun b => (f b).measure s) tᶜ

case refine_4
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α (β × ℝ)
ν✝ : Kernel α β
x✝ : MeasurableSpace β
f✝ : α × β → StieltjesFunction
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α → StieltjesFunction
hf : ∀ (q : ℝ), Measurable fun a => ↑(f a) q
hf_bot : ∀ (a : α), Tendsto (↑(f a)) atBot (𝓝 0)
hf_top : ∀ (a : α), Tendsto (↑(f a)) atTop (𝓝 1)
s : Set ℝ
hs : MeasurableSet s
this : ∀ (a : α), IsProbabilityMeasure (f a).measure
⊢ ∀ (f_1 : ℕ → Set ℝ),
    Pairwise (Disjoint on f_1) →
      (∀ (i : ℕ), MeasurableSet (f_1 i)) →
        (∀ (i : ℕ), (fun s => Measurable fun b => (f b).measure s) (f_1 i)) →
          (fun s => Measurable fun b => (f b).measure s) (⋃ i, f_1 i)

refine MeasurableSpace.induction_on_inter
    (C := fun s ↦ Measurable fun b ↦ StieltjesFunction.measure (f b) s)
    (borel_eq_generateFrom_Iic ℝ) isPiSystem_Iic ?_ ?_ ?_ ?_ hs


R : Type u
inst✝¹ : AddGroupWithOne R
n : ℕ
inst✝ : n.AtLeastTwo
⊢ ↑(OfNat.ofNat n) = OfNat.ofNat n

simpa only [OfNat.ofNat] using AddGroupWithOne.intCast_ofNat (R := R) n


α : Type u_1
le : α → α → Bool
a : α
s' s : Heap α
eq : deleteMin le s = some (a, s')
⊢ s.realSize = s'.realSize + 1

case cons.refl
α : Type u_1
le : α → α → Bool
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ (cons r a c s).realSize =
    (merge le (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).node.toHeap
          ((findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).before
            (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).next)).realSize +
      1

cases s with cases eq | cons r a c s => ?_

case cons.refl
α : Type u_1
le : α → α → Bool
r : Nat
a : α
c : HeapNode α
s : Heap α
this :
  Batteries.BinomialHeap.Imp.FindMin.HasSize
    (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }) (c.realSize + s.realSize + 1)
⊢ (cons r a c s).realSize =
    (merge le (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).node.toHeap
          ((findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).before
            (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).next)).realSize +
      1

have : (s.findMin le (cons r a c) ⟨id, a, c, s⟩).HasSize (c.realSize + s.realSize + 1) :=
    Heap.realSize_findMin (c.realSize + 1) (by simp) (Nat.add_right_comm ..) ⟨0, by simp⟩

case cons.refl
α : Type u_1
le : α → α → Bool
r : Nat
a : α
c : HeapNode α
s : Heap α
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize
      (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }) (c.realSize + s.realSize + 1) →
    (cons r a c s).realSize =
      (merge le (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).node.toHeap
            ((findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).before
              (findMin le (cons r a c) s { before := id, val := a, node := c, next := s }).next)).realSize +
        1

match s.findMin le (cons r a c) ⟨id, a, c, s⟩ with
  | { before, val, node, next } =>
    intro ⟨m, ih₁, ih₂⟩; dsimp only at ih₁ ih₂
    rw [realSize, Nat.add_right_comm, ih₂]
    simp only [realSize_merge, HeapNode.realSize_toHeap, ih₁, Nat.add_assoc, Nat.add_left_comm]


l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ (A.submatrix f ⇑e).rank ≤ A.rank

l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : Fintype m
f : n → m
e : n ≃ m
A : Matrix m m R
⊢ finrank R ↥(Submodule.map (LinearMap.funLeft R R f) (LinearMap.range A.mulVecLin)) ≤
    finrank R ↥(LinearMap.range A.mulVecLin)

rw [rank, rank, mulVecLin_submatrix, LinearMap.range_comp, LinearMap.range_comp,
    show LinearMap.funLeft R R e.symm = LinearEquiv.funCongrLeft R R e.symm from rfl,
    LinearEquiv.range, Submodule.map_top]


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
J' : Type u₂
inst✝¹ : Category.{v₂, u₂} J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J' C

case has_limit
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
J' : Type u₂
inst✝¹ : Category.{v₂, u₂} J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
⊢ autoParam (∀ (F : J' ⥤ C), HasLimit F) _auto✝

case has_limit
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
J' : Type u₂
inst✝¹ : Category.{v₂, u₂} J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
F : J' ⥤ C
⊢ HasLimit F


α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
hs : a ∈ lowerClosure ↑s
ht : a ∈ lowerClosure ↑t
⊢ (s ⊼ t).truncatedSup a = s.truncatedSup a ⊓ t.truncatedSup a

α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
hs : a ∈ lowerClosure ↑s
ht : a ∈ lowerClosure ↑t
⊢ ((filter (fun x => a ≤ x) s ⊼ filter (fun x => a ≤ x) t).sup' ⋯ fun x => id x) =
    (filter (fun b => a ≤ b) s ×ˢ filter (fun b => a ≤ b) t).sup' ⋯ fun i => id i.1 ⊓ id i.2

simp only [truncatedSup_of_mem, hs, ht, infs_aux.2 ⟨hs, ht⟩, sup'_inf_sup', filter_infs_le]

α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
hs : a ∈ lowerClosure ↑s
ht : a ∈ lowerClosure ↑t
⊢ ((image (Function.uncurry fun x x_1 => x ⊓ x_1) (filter (fun x => a ≤ x) s ×ˢ filter (fun x => a ≤ x) t)).sup' ⋯
      fun x => id x) =
    (filter (fun b => a ≤ b) s ×ˢ filter (fun b => a ≤ b) t).sup' ⋯ fun i => id i.1 ⊓ id i.2

α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
hs : a ∈ lowerClosure ↑s
ht : a ∈ lowerClosure ↑t
⊢ (filter (fun x => a ≤ x) s ×ˢ filter (fun x => a ≤ x) t).sup' ⋯
      ((fun x => id x) ∘ Function.uncurry fun x x_1 => x ⊓ x_1) =
    (filter (fun b => a ≤ b) s ×ˢ filter (fun b => a ≤ b) t).sup' ⋯ fun i => id i.1 ⊓ id i.2


M : Type u_1
A : Type u_2
B : Type u_3
N : Type u_4
α : Type u_5
inst✝³ : Monoid M
inst✝² : MulAction M N
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z
⊢ IsScalarTower M N α

case refine_1
M : Type u_1
A : Type u_2
B : Type u_3
N : Type u_4
α : Type u_5
inst✝³ : Monoid M
inst✝² : MulAction M N
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z
x : M
⊢ ∀ (y : N) (z : α), (1 • y) • z = 1 • y • z

case refine_2
M : Type u_1
A : Type u_2
B : Type u_3
N : Type u_4
α : Type u_5
inst✝³ : Monoid M
inst✝² : MulAction M N
inst✝¹ : SMul N α
inst✝ : MulAction M α
s : Set M
htop : Submonoid.closure s = ⊤
hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z
x : M
⊢ ∀ x ∈ s,
    ∀ (y : M),
      (∀ (y_1 : N) (z : α), (y • y_1) • z = y • y_1 • z) → ∀ (y_1 : N) (z : α), ((x * y) • y_1) • z = (x * y) • y_1 • z

refine ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x ?_ ?_⟩


ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
⊢ (update i f b).support = if b = 0 then (erase i f).support else insert i f.support

case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
⊢ j ∈ (update i f b).support ↔ j ∈ if b = 0 then (erase i f).support else insert i f.support

case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : b = 0
⊢ j ∈ (update i f b).support ↔ j ∈ (erase i f).support

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : ¬b = 0
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support


R : Type uR
S : Type uS
A : Type uA
B : Type uB
M : Type uM
N : Type uN
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ adjoin R ↑{X} = ⊤

R : Type uR
S : Type uS
A : Type uA
B : Type uB
M : Type uM
N : Type uN
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ adjoin R {X} = ⊤


R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
s : S
n : ℕ
h : s ∈ Set.range ⇑f
⊢ (monomial n) s ∈ lifts f

case intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (monomial n) (f r) ∈ lifts f

case h
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (mapRingHom f) ((monomial n) r) = (monomial n) (f r)

simp only [coe_mapRingHom, Set.mem_univ, map_monomial, Subsemiring.coe_top, eq_self_iff_true,
    and_self_iff]


γ : Sort u_1
α : Type u_2
β : Type u_3
c : γ
⊢ Sum.elim (const α c) (const β c) = const (α ⊕ β) c

case h
γ : Sort u_1
α : Type u_2
β : Type u_3
c : γ
x : α ⊕ β
⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x


α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ [[a, c]] → c ∈ [[a, b]] → b = c

simpa only [uIcc_comm a] using eq_of_mem_uIcc_of_mem_uIcc


f : ℕ → ℂ
m : ℕ
⊢ abscissaOfAbsConv (logMul^[m] f) = abscissaOfAbsConv f

case zero
f : ℕ → ℂ
⊢ abscissaOfAbsConv (logMul^[0] f) = abscissaOfAbsConv f

case succ
f : ℕ → ℂ
n : ℕ
ih : abscissaOfAbsConv (logMul^[n] f) = abscissaOfAbsConv f
⊢ abscissaOfAbsConv (logMul^[n + 1] f) = abscissaOfAbsConv f


L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
⊢ f.toHom.comp f.symm.toHom = Hom.id L N

rw [← comp_toHom, self_comp_symm, refl_toHom]


simpa only [← Complex.ofReal_natCast, ← Complex.ofReal_neg, Complex.Gamma_ofReal,
    Complex.ofReal_eq_zero] using Complex.Gamma_neg_nat_eq_zero n


a b c : Ordinal.{u_1}
c0 : 0 < c
ha : a < ω ^ c
hb : b < ω
⊢ a * b < ω ^ c

case inl
a b : Ordinal.{u_1}
hb : b < ω
c0 : 0 < 0
ha : a < ω ^ 0
⊢ a * b < ω ^ 0

case inr.inl.intro
a b : Ordinal.{u_1}
hb : b < ω
c : Ordinal.{u_1}
c0 : 0 < succ c
ha : a < ω ^ succ c
⊢ a * b < ω ^ succ c

case inr.inr
a b c : Ordinal.{u_1}
c0 : 0 < c
ha : a < ω ^ c
hb : b < ω
l : c.IsLimit
⊢ a * b < ω ^ c

rcases zero_or_succ_or_limit c with (rfl | ⟨c, rfl⟩ | l)


α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ m f (map₂ n g h) = map₂ n' g (map₂ m' f h)

α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)

exact map₂_assoc fun _ _ _ => h_left_comm _ _ _


G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Inv G✝
inst✝⁴ : ContinuousInv G✝
G : Type u_1
inst✝³ : DivInvMonoid G
inst✝² : TopologicalSpace G
inst✝¹ : ContinuousMul G
inst✝ : ContinuousInv G
x y : G
h : x ⤳ y
n : ℕ
⊢ (x ^ Int.ofNat n) ⤳ (y ^ Int.ofNat n)

G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Inv G✝
inst✝⁴ : ContinuousInv G✝
G : Type u_1
inst✝³ : DivInvMonoid G
inst✝² : TopologicalSpace G
inst✝¹ : ContinuousMul G
inst✝ : ContinuousInv G
x y : G
h : x ⤳ y
n : ℕ
⊢ (x ^ Int.negSucc n) ⤳ (y ^ Int.negSucc n)


α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
hf : LocallyLipschitz f
a : ℝ
⊢ LocallyLipschitz fun x => min a (f x)


α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
S : Set (Set α)
K : DirectedOn (fun x x_1 => x ⊆ x_1) S
H : ∀ s ∈ S, IsPreconnected s
⊢ IsPreconnected (⋃₀ S)

case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ : Set α
S : Set (Set α)
K : DirectedOn (fun x x_1 => x ⊆ x_1) S
H : ∀ s ∈ S, IsPreconnected s
u v : Set α
hu : IsOpen u
hv : IsOpen v
Huv : ⋃₀ S ⊆ u ∪ v
a : α
hau : a ∈ u
s : Set α
hsS : s ∈ S
has : a ∈ s
b : α
hbv : b ∈ v
t : Set α
htS : t ∈ S
hbt : b ∈ t
⊢ (⋃₀ S ∩ (u ∩ v)).Nonempty

rintro u v hu hv Huv ⟨a, ⟨s, hsS, has⟩, hau⟩ ⟨b, ⟨t, htS, hbt⟩, hbv⟩

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ : Set α
S : Set (Set α)
K : DirectedOn (fun x x_1 => x ⊆ x_1) S
H : ∀ s ∈ S, IsPreconnected s
u v : Set α
hu : IsOpen u
hv : IsOpen v
Huv : ⋃₀ S ⊆ u ∪ v
a : α
hau : a ∈ u
s : Set α
hsS : s ∈ S
has : a ∈ s
b : α
hbv : b ∈ v
t : Set α
htS : t ∈ S
hbt : b ∈ t
r : Set α
hrS : r ∈ S
hsr : s ⊆ r
htr : t ⊆ r
⊢ (⋃₀ S ∩ (u ∩ v)).Nonempty

obtain ⟨r, hrS, hsr, htr⟩ : ∃ r ∈ S, s ⊆ r ∧ t ⊆ r := K s hsS t htS

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ : Set α
S : Set (Set α)
K : DirectedOn (fun x x_1 => x ⊆ x_1) S
H : ∀ s ∈ S, IsPreconnected s
u v : Set α
hu : IsOpen u
hv : IsOpen v
Huv : ⋃₀ S ⊆ u ∪ v
a : α
hau : a ∈ u
s : Set α
hsS : s ∈ S
has : a ∈ s
b : α
hbv : b ∈ v
t : Set α
htS : t ∈ S
hbt : b ∈ t
r : Set α
hrS : r ∈ S
hsr : s ⊆ r
htr : t ⊆ r
Hnuv : (r ∩ (u ∩ v)).Nonempty
⊢ (⋃₀ S ∩ (u ∩ v)).Nonempty

have Hnuv : (r ∩ (u ∩ v)).Nonempty :=
    H _ hrS u v hu hv ((subset_sUnion_of_mem hrS).trans Huv) ⟨a, hsr has, hau⟩ ⟨b, htr hbt, hbv⟩

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ : Set α
S : Set (Set α)
K : DirectedOn (fun x x_1 => x ⊆ x_1) S
H : ∀ s ∈ S, IsPreconnected s
u v : Set α
hu : IsOpen u
hv : IsOpen v
Huv : ⋃₀ S ⊆ u ∪ v
a : α
hau : a ∈ u
s : Set α
hsS : s ∈ S
has : a ∈ s
b : α
hbv : b ∈ v
t : Set α
htS : t ∈ S
hbt : b ∈ t
r : Set α
hrS : r ∈ S
hsr : s ⊆ r
htr : t ⊆ r
Hnuv : (r ∩ (u ∩ v)).Nonempty
Kruv : r ∩ (u ∩ v) ⊆ ⋃₀ S ∩ (u ∩ v)
⊢ (⋃₀ S ∩ (u ∩ v)).Nonempty

have Kruv : r ∩ (u ∩ v) ⊆ ⋃₀ S ∩ (u ∩ v) := inter_subset_inter_left _ (subset_sUnion_of_mem hrS)


α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
⊢ r ((p.toFun ∘ Fin.rev) i.succ) ((p.toFun ∘ Fin.rev) i.castSucc)

α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)

α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)

have hi : i.1 + 1 ≤ p.length := by omega

case h.e'_1.h.e'_4
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ i.succ.rev = ⟨p.length - (↑i + 1), ⋯⟩.castSucc

case h.e'_2.h.e'_4
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ i.castSucc.rev = ⟨p.length - (↑i + 1), ⋯⟩.succ

convert p.step ⟨p.length - (i.1 + 1), Nat.sub_lt_self (by omega) hi⟩


xl xr : Type u
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j

xl xr : Type u
x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ x.moveLeft i) ∧
          ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (moveRight 0 j).LeftMoves), (moveRight 0 j).moveLeft i ⧏ x) ∧
          ∀ (j' : x.RightMoves), moveRight 0 j ⧏ x.moveRight j') ↔
    ∃ i, ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j


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


α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁵ : CountablyGenerated γ
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : Countable α
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
x y : α
h : x ∈ measurableAtom y
⊢ (fun a => (κ a).condKernel) x = (fun a => (κ a).condKernel) y

simp [apply_congr_of_mem_measurableAtom _ h]


simpa only [cos_zero] using (cos_periodic.int_mul n).add_antiperiod_eq cos_antiperiodic


t : ℝ
ht : 0 < t
⊢ ‖F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t))

case h.e'_3.h.e'_3
t : ℝ
ht : 0 < t
⊢ F_nat 0 0 t - 1 = F_nat 0 1 t

case h.e'_4.h.e'_5
t : ℝ
ht : 0 < t
⊢ rexp (-π * t) = rexp (-π * 1 ^ 2 * t)

convert F_nat_zero_le zero_le_one ht using 2


C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ kernel.lift f h w ≫ (MonoOver.mk' (kernel.ι f)).arrow = h


a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ a < a + b

rwa [← pos_iff_ne_zero, ← ENNReal.add_lt_add_iff_left ha, add_zero] at hb


α : Type u_1
t : Ordnode α
ht : t.Sized
⊢ t.size = 0 ↔ t = nil


ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
t : Set E
⊢ convexJoin 𝕜 ∅ t = ∅


𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ ContDiffOn 𝕜 ⊤ f s ↔ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s

case mp
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ ContDiffOn 𝕜 ⊤ f s → DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s

case mpr
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → ContDiffOn 𝕜 ⊤ f s


α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
⊢ uniformSpace α γ 𝔖 = uniformSpace α γ 𝔖 ⊓ uniformSpace α γ 𝔖

α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
⊢ ⨅ i, uniformSpace α γ 𝔖 = ⨅ b, bif b then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖

rw [inf_eq_iInf, inf_eq_iInf, UniformOnFun.iInf_eq]

α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
i : Bool
⊢ uniformSpace α γ 𝔖 = bif i then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖


α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
⊢ PolishSpace ↑s

α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s

case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s

case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology s.CompleteCopy
⊢ PolishSpace ↑↑s

have : SecondCountableTopology s.CompleteCopy := inferInstanceAs (SecondCountableTopology s)

exact inferInstanceAs (PolishSpace s.CompleteCopy)


α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
E : Type u_4
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
⊢ NullMeasurableSet {x | f x = g x} μ

α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
E : Type u_4
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
⊢ {x | AEMeasurable.mk f hf x = AEMeasurable.mk g hg x} =ᶠ[ae μ] {x | f x = g x}

apply (measurableSet_eq_fun hf.measurable_mk hg.measurable_mk).nullMeasurableSet.congr

case h
α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
E : Type u_4
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
x : α
hfx : f x = AEMeasurable.mk f hf x
hgx : g x = AEMeasurable.mk g hg x
⊢ {x | AEMeasurable.mk f hf x = AEMeasurable.mk g hg x} x = {x | f x = g x} x

filter_upwards [hf.ae_eq_mk, hg.ae_eq_mk] with x hfx hgx

case h
α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
E : Type u_4
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : AEMeasurable f μ
hg : AEMeasurable g μ
x : α
hfx : f x = AEMeasurable.mk f hf x
hgx : g x = AEMeasurable.mk g hg x
⊢ (AEMeasurable.mk f hf x = AEMeasurable.mk g hg x) = (f x = g x)

change (hf.mk f x = hg.mk g x) = (f x = g x)


ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
⊢ Function.RightInverse (invFun p) (toFun p)

ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
⊢ Function.RightInverse ⇑(piQuotientLift p (pi Set.univ p) single ⋯) ⇑(quotientPiLift p (fun i => (p i).mkQ) ⋯)

ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
⊢ ⇑(quotientPiLift p (fun i => (p i).mkQ) ⋯ ∘ₗ piQuotientLift p (pi Set.univ p) single ⋯) = ⇑LinearMap.id

rw [Function.rightInverse_iff_comp, ← coe_comp, ← @id_coe R]

ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
i : ι
x : Ms i ⧸ p i
x' : Ms i
j : ι
⊢ (quotientPiLift p (fun i => (p i).mkQ) ⋯ ∘ₗ piQuotientLift p (pi Set.univ p) single ⋯)
      (Pi.single i (Quotient.mk'' x')) j =
    LinearMap.id (Pi.single i (Quotient.mk'' x')) j

refine congr_arg _ (pi_ext fun i x => Quotient.inductionOn' x fun x' => funext fun j => ?_)

ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
i : ι
x : Ms i ⧸ p i
x' : Ms i
j : ι
⊢ (fun i_1 => (p i_1).mkQ ((single i) x' i_1)) j = Pi.single i (Quotient.mk x') j

rw [comp_apply, piQuotientLift_single, Quotient.mk''_eq_mk, mapQ_apply,
    quotientPiLift_mk, id_apply]

case pos
ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
i : ι
x : Ms i ⧸ p i
x' : Ms i
j : ι
hij : i = j
⊢ Quotient.mk (Pi.single i x' j) = Pi.single i (Quotient.mk x') j

case neg
ι : Type u_1
R : Type u_2
inst✝⁸ : CommRing R
Ms : ι → Type u_3
inst✝⁷ : (i : ι) → AddCommGroup (Ms i)
inst✝⁶ : (i : ι) → Module R (Ms i)
N : Type u_4
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
Ns : ι → Type u_5
inst✝³ : (i : ι) → AddCommGroup (Ns i)
inst✝² : (i : ι) → Module R (Ns i)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
p : (i : ι) → Submodule R (Ms i)
i : ι
x : Ms i ⧸ p i
x' : Ms i
j : ι
hij : ¬i = j
⊢ Quotient.mk (Pi.single i x' j) = Pi.single i (Quotient.mk x') j

by_cases hij : i = j <;> simp only [mkQ_apply, coe_single]


p : ℕ
hp : Fact (Nat.Prime p)
m n : ℕ
h : m ≤ n
⊢ (ZMod.castHom ⋯ (ZMod (p ^ m))).comp ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate n)) =
    ((zmodEquivTrunc p m).symm.toRingHom.comp (TruncatedWittVector.truncate h)).comp (truncate n)

p : ℕ
hp : Fact (Nat.Prime p)
m n : ℕ
h : m ≤ n
⊢ ((zmodEquivTrunc p m).symm.toRingHom.comp (TruncatedWittVector.truncate h)).comp (truncate n) =
    (zmodEquivTrunc p m).symm.toRingHom.comp (truncate m)


simp only [LSeries, LSeries.term, Pi.zero_apply, zero_div, ite_self, tsum_zero]


C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
⊢ f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂)

case intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
⊢ f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂)

obtain ⟨α, hα⟩ := exists_leftFraction L W f

case intro.intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
β : W.LeftFraction₂ Y Z
hβ₁ : g₁ = β.fst.map L ⋯
hβ₂ : g₂ = β.snd.map L ⋯
⊢ f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂)

obtain ⟨β, hβ₁, hβ₂⟩ := exists_leftFraction₂ L W g₁ g₂

case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
β : W.LeftFraction₂ Y Z
hβ₁ : g₁ = β.fst.map L ⋯
hβ₂ : g₂ = β.snd.map L ⋯
γ : W.LeftFraction₂ α.Y' β.Y'
hγ₁ : (RightFraction₂.mk α.s ⋯ β.f β.f').f ≫ γ.s = (RightFraction₂.mk α.s ⋯ β.f β.f').s ≫ γ.f
hγ₂ : (RightFraction₂.mk α.s ⋯ β.f β.f').f' ≫ γ.s = (RightFraction₂.mk α.s ⋯ β.f β.f').s ≫ γ.f'
⊢ f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂)

obtain ⟨γ, hγ₁, hγ₂⟩ := (RightFraction₂.mk _ α.hs β.f β.f').exists_leftFraction₂

case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
β : W.LeftFraction₂ Y Z
hβ₁ : g₁ = β.fst.map L ⋯
hβ₂ : g₂ = β.snd.map L ⋯
γ : W.LeftFraction₂ α.Y' β.Y'
hγ₁ : β.f ≫ γ.s = α.s ≫ γ.f
hγ₂ : β.f' ≫ γ.s = α.s ≫ γ.f'
⊢ f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂)

case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
β : W.LeftFraction₂ Y Z
hβ₁ : g₁ = β.fst.map L ⋯
hβ₂ : g₂ = β.snd.map L ⋯
γ : W.LeftFraction₂ α.Y' β.Y'
hγ₁ : β.f ≫ γ.s = α.s ≫ γ.f
hγ₂ : β.f' ≫ γ.s = α.s ≫ γ.f'
⊢ (α.comp₀ β.add γ.add).map L ⋯ = (LeftFraction₂.mk (α.f ≫ γ.f) (α.f ≫ γ.f') (β.s ≫ γ.s) ⋯).add.map L ⋯

rw [add'_eq W g₁ g₂ β hβ₁ hβ₂, add'_eq W (f ≫ g₁) (f ≫ g₂)
    (LeftFraction₂.mk (α.f ≫ γ.f) (α.f ≫ γ.f') (β.s ≫ γ.s) (W.comp_mem _ _ β.hs γ.hs))
    (by simpa only [hα, hβ₁] using LeftFraction.map_comp_map_eq_map α β.fst γ.fst hγ₁ L)
    (by simpa only [hα, hβ₂] using LeftFraction.map_comp_map_eq_map α β.snd γ.snd hγ₂ L),
    hα, LeftFraction.map_comp_map_eq_map α β.add γ.add
      (by simp only [add_comp, hγ₁, hγ₂, comp_add])]

case intro.intro.intro.intro.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_3, u_2} D
inst✝² : Preadditive C
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : L.obj X ⟶ L.obj Y
g₁ g₂ : L.obj Y ⟶ L.obj Z
α : W.LeftFraction X Y
hα : f = α.map L ⋯
β : W.LeftFraction₂ Y Z
hβ₁ : g₁ = β.fst.map L ⋯
hβ₂ : g₂ = β.snd.map L ⋯
γ : W.LeftFraction₂ α.Y' β.Y'
hγ₁ : β.f ≫ γ.s = α.s ≫ γ.f
hγ₂ : β.f' ≫ γ.s = α.s ≫ γ.f'
⊢ (LeftFraction.mk (α.f ≫ (γ.f + γ.f')) (β.s ≫ γ.s) ⋯).map L ⋯ =
    (LeftFraction.mk (α.f ≫ γ.f + α.f ≫ γ.f') (β.s ≫ γ.s) ⋯).map L ⋯


R✝ : Type u
S : Type u_1
A✝ : Type v
inst✝⁹ : CommRing R✝
inst✝⁸ : CommRing S
inst✝⁷ : Ring A✝
inst✝⁶ : Algebra R✝ A✝
inst✝⁵ : Algebra R✝ S
inst✝⁴ : Algebra S A✝
inst✝³ : IsScalarTower R✝ S A✝
R : Type u
A : Type v
inst✝² : DivisionRing A
inst✝¹ : Field R
inst✝ : Algebra R A
n : ℚ
⊢ IsAlgebraic R ↑n

R✝ : Type u
S : Type u_1
A✝ : Type v
inst✝⁹ : CommRing R✝
inst✝⁸ : CommRing S
inst✝⁷ : Ring A✝
inst✝⁶ : Algebra R✝ A✝
inst✝⁵ : Algebra R✝ S
inst✝⁴ : Algebra S A✝
inst✝³ : IsScalarTower R✝ S A✝
R : Type u
A : Type v
inst✝² : DivisionRing A
inst✝¹ : Field R
inst✝ : Algebra R A
n : ℚ
⊢ IsAlgebraic R ((algebraMap R A) ↑n)

exact isAlgebraic_algebraMap (Rat.cast n)


𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
⊢ Function.HasTemperateGrowth ⇑f

𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
⊢ Function.HasTemperateGrowth (fderiv ℝ ⇑f)

𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
x : E
⊢ ‖f x‖ ≤ ‖f‖ * (1 + ‖x‖) ^ 1

apply Function.HasTemperateGrowth.of_fderiv ?_ f.differentiable (k := 1) (C := ‖f‖) (fun x ↦ ?_)


X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
p : X → Prop
s : Set X
t : Set ↑s
⊢ Dense t ↔ s ⊆ closure (val '' t)

X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
p : X → Prop
s : Set X
t : Set ↑s
⊢ (∀ (x : X) (h : x ∈ s), ↑⟨x, h⟩ ∈ closure (val '' t)) ↔ s ⊆ closure (val '' t)


X✝ : Type u_1
X : Type u_2
x : FreeAbelianGroup X
⊢ toFreeAbelianGroup (toFinsupp x) = x

rw [← AddMonoidHom.comp_apply, Finsupp.toFreeAbelianGroup_comp_toFinsupp, AddMonoidHom.id_apply]


ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
⊢ Continuous fun a => a ^ 0

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a ^ (k + 1)

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a * a ^ k

exact continuous_id.mul (continuous_pow _)


E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v✝ v : E
⊢ HasFDerivAt (stereoInvFunAux v ∘ Subtype.val) (Submodule.span ℝ {v})ᗮ.subtypeL 0

E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
v✝ v : E
this : HasFDerivAt (stereoInvFunAux v) (ContinuousLinearMap.id ℝ E) ((Submodule.span ℝ {v})ᗮ.subtypeL 0)
⊢ HasFDerivAt (stereoInvFunAux v ∘ Subtype.val) (Submodule.span ℝ {v})ᗮ.subtypeL 0

have : HasFDerivAt (stereoInvFunAux v) (ContinuousLinearMap.id ℝ E) ((ℝ ∙ v)ᗮ.subtypeL 0) :=
    hasFDerivAt_stereoInvFunAux v

convert this.comp (0 : (ℝ ∙ v)ᗮ) (by apply ContinuousLinearMap.hasFDerivAt)