[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
⊢ IsClosed ↑U
[PROOFSTEP]
apply isOpen_compl_iff.1
[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
⊢ IsOpen (↑U)ᶜ
[PROOFSTEP]
refine' isOpen_iff_forall_mem_open.2 fun x hx => ⟨(fun y => y * x⁻¹) ⁻¹' U, _, _, _⟩
[GOAL]
case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
⊢ (fun y => y * x⁻¹) ⁻¹' ↑U ⊆ (↑U)ᶜ
[PROOFSTEP]
refine' fun u hux hu => hx _
[GOAL]
case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
u : G
hux : u ∈ (fun y => y * x⁻¹) ⁻¹' ↑U
hu : u ∈ ↑U
⊢ x ∈ ↑U
[PROOFSTEP]
simp only [Set.mem_preimage, SetLike.mem_coe] at hux hu ⊢
[GOAL]
case refine'_1
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
u : G
hux : u * x⁻¹ ∈ U
hu : u ∈ U
⊢ x ∈ U
[PROOFSTEP]
convert U.mul_mem (U.inv_mem hux) hu
[GOAL]
case a
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
u : G
hux : u * x⁻¹ ∈ U
hu : u ∈ U
⊢ x ∈ U ↔ (u * x⁻¹)⁻¹ * u ∈ ↑U
[PROOFSTEP]
simp
[GOAL]
case refine'_2
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
⊢ IsOpen ((fun y => y * x⁻¹) ⁻¹' ↑U)
[PROOFSTEP]
exact U.isOpen.preimage (continuous_mul_right _)
[GOAL]
case refine'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
U✝ V : OpenSubgroup G
g : G
inst✝ : ContinuousMul G
U : OpenSubgroup G
x : G
hx : x ∈ (↑U)ᶜ
⊢ x ∈ (fun y => y * x⁻¹) ⁻¹' ↑U
[PROOFSTEP]
simp [one_mem]
[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
⊢ IsOpen ↑H
[PROOFSTEP]
refine' isOpen_iff_mem_nhds.2 fun x hx => _
[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
⊢ ↑H ∈ 𝓝 x
[PROOFSTEP]
have hg' : g ∈ H := SetLike.mem_coe.1 (mem_of_mem_nhds hg)
[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
⊢ ↑H ∈ 𝓝 x
[PROOFSTEP]
have : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g) :=
  (continuous_id.mul continuous_const).tendsto' _ _ (mul_inv_cancel_left _ _)
[GOAL]
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousMul G
H : Subgroup G
g : G
hg : ↑H ∈ 𝓝 g
x : G
hx : x ∈ ↑H
hg' : g ∈ H
this : Filter.Tendsto (fun y => y * (x⁻¹ * g)) (𝓝 x) (𝓝 g)
⊢ ↑H ∈ 𝓝 x
[PROOFSTEP]
simpa only [SetLike.mem_coe, Filter.mem_map', H.mul_mem_cancel_right (H.mul_mem (H.inv_mem hx) hg')] using this hg


[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
j j' : J
f : j ⟶ j'
⊢ ((Functor.const J).obj (limit F)).map f ≫ (fun j => Hom.mk (limit.π (F ⋙ forget C) j)) j' =
    (fun j => Hom.mk (limit.π (F ⋙ forget C) j)) j ≫ F.map f
[PROOFSTEP]
ext
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
j j' : J
f : j ⟶ j'
⊢ (((Functor.const J).obj (limit F)).map f ≫ (fun j => Hom.mk (limit.π (F ⋙ forget C) j)) j').hom =
    ((fun j => Hom.mk (limit.π (F ⋙ forget C) j)) j ≫ F.map f).hom
[PROOFSTEP]
exact (limit.cone (F ⋙ Mon_.forget C)).π.naturality f
[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
⊢ ∀ (j : J),
    NatTrans.app ((forget C).mapCone (limitCone F)).π j =
      (Iso.refl ((forget C).mapCone (limitCone F)).pt).hom ≫ NatTrans.app (limit.cone (F ⋙ forget C)).π j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
⊢ s.pt.mul ≫ limit.lift (F ⋙ forget C) ((forget C).mapCone s) =
    MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
        (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
      (limitCone F).pt.mul
[PROOFSTEP]
dsimp
[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
⊢ s.pt.mul ≫ limit.lift (F ⋙ forget C) ((forget C).mapCone s) =
    MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
        (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
      (limit F).mul
[PROOFSTEP]
ext
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
⊢ (s.pt.mul ≫ limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫ limit.π (F ⋙ forget C) j✝ =
    (MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
          (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
        (limit F).mul) ≫
      limit.π (F ⋙ forget C) j✝
[PROOFSTEP]
simp
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
⊢ MonoidalCategory.tensorHom (NatTrans.app s.π j✝).hom (NatTrans.app s.π j✝).hom ≫ (F.obj j✝).mul =
    MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
        (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
      MonoidalCategory.tensorHom (limit.π (F ⋙ forget C) j✝) (limit.π (F ⋙ forget C) j✝) ≫ (F.obj j✝).mul
[PROOFSTEP]
slice_rhs 1 2 => rw [← MonoidalCategory.tensor_comp, limit.lift_π]
[GOAL]
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
      (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
    MonoidalCategory.tensorHom (limit.π (F ⋙ forget C) j✝) (limit.π (F ⋙ forget C) j✝)
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| (F.obj j✝).mul
[PROOFSTEP]
rw [← MonoidalCategory.tensor_comp, limit.lift_π]
[GOAL]
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
      (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
    MonoidalCategory.tensorHom (limit.π (F ⋙ forget C) j✝) (limit.π (F ⋙ forget C) j✝)
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| (F.obj j✝).mul
[PROOFSTEP]
rw [← MonoidalCategory.tensor_comp, limit.lift_π]
[GOAL]
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| MonoidalCategory.tensorHom (limit.lift (F ⋙ forget C) ((forget C).mapCone s))
      (limit.lift (F ⋙ forget C) ((forget C).mapCone s)) ≫
    MonoidalCategory.tensorHom (limit.π (F ⋙ forget C) j✝) (limit.π (F ⋙ forget C) j✝)
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
j✝ : J
| (F.obj j✝).mul
[PROOFSTEP]
rw [← MonoidalCategory.tensor_comp, limit.lift_π]
[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
h : J
⊢ (fun s => Hom.mk (limit.lift (F ⋙ forget C) ((forget C).mapCone s))) s ≫ NatTrans.app (limitCone F).π h =
    NatTrans.app s.π h
[PROOFSTEP]
ext
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
h : J
⊢ ((fun s => Hom.mk (limit.lift (F ⋙ forget C) ((forget C).mapCone s))) s ≫ NatTrans.app (limitCone F).π h).hom =
    (NatTrans.app s.π h).hom
[PROOFSTEP]
simp
[GOAL]
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone F).π j = NatTrans.app s.π j
⊢ m = (fun s => Hom.mk (limit.lift (F ⋙ forget C) ((forget C).mapCone s))) s
[PROOFSTEP]
ext1
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone F).π j = NatTrans.app s.π j
⊢ m.hom = ((fun s => Hom.mk (limit.lift (F ⋙ forget C) ((forget C).mapCone s))) s).hom
[PROOFSTEP]
refine' limit.hom_ext (fun j => _)
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone F).π j = NatTrans.app s.π j
j : J
⊢ m.hom ≫ limit.π (MonFunctorCategoryEquivalence.inverse.obj F).X j =
    ((fun s => Hom.mk (limit.lift (F ⋙ forget C) ((forget C).mapCone s))) s).hom ≫
      limit.π (MonFunctorCategoryEquivalence.inverse.obj F).X j
[PROOFSTEP]
dsimp
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone F).π j = NatTrans.app s.π j
j : J
⊢ m.hom ≫ limit.π (F ⋙ forget C) j = limit.lift (F ⋙ forget C) ((forget C).mapCone s) ≫ limit.π (F ⋙ forget C) j
[PROOFSTEP]
simp only [Mon_.forget_map, limit.lift_π, Functor.mapCone_π_app]
[GOAL]
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone F).π j = NatTrans.app s.π j
j : J
⊢ m.hom ≫ limit.π (F ⋙ forget C) j = (NatTrans.app s.π j).hom
[PROOFSTEP]
exact congr_arg Mon_.Hom.hom (w j)


[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ List.NodupKeys (List.map Prod.toSigma (Finset.toList (graph f)))
[PROOFSTEP]
rw [List.NodupKeys, List.keys, List.map_map, Prod.fst_comp_toSigma, List.nodup_map_iff_inj_on]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ ∀ (x : α × M), x ∈ Finset.toList (graph f) → ∀ (y : α × M), y ∈ Finset.toList (graph f) → x.fst = y.fst → x = y
[PROOFSTEP]
rintro ⟨b, m⟩ hb ⟨c, n⟩ hc (rfl : b = c)
[GOAL]
case mk.mk
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
b : α
m : M
hb : (b, m) ∈ Finset.toList (graph f)
n : M
hc : (b, n) ∈ Finset.toList (graph f)
⊢ (b, m) = (b, n)
[PROOFSTEP]
rw [Finset.mem_toList, Finsupp.mem_graph_iff] at hb hc
[GOAL]
case mk.mk
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
b : α
m : M
hb : ↑f (b, m).fst = (b, m).snd ∧ (b, m).snd ≠ 0
n : M
hc : ↑f (b, n).fst = (b, n).snd ∧ (b, n).snd ≠ 0
⊢ (b, m) = (b, n)
[PROOFSTEP]
dsimp at hb hc
[GOAL]
case mk.mk
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
b : α
m : M
hb : ↑f b = m ∧ ¬m = 0
n : M
hc : ↑f b = n ∧ ¬n = 0
⊢ (b, m) = (b, n)
[PROOFSTEP]
rw [← hc.1, hb.1]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ List.Nodup (Finset.toList (graph f))
[PROOFSTEP]
apply Finset.nodup_toList
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
⊢ List.toFinset (AList.keys (toAList f)) = f.support
[PROOFSTEP]
ext
[GOAL]
case a
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
a✝ : α
⊢ a✝ ∈ List.toFinset (AList.keys (toAList f)) ↔ a✝ ∈ f.support
[PROOFSTEP]
simp [toAList, AList.mem_keys, AList.keys, List.keys]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
x : α
⊢ x ∈ toAList f ↔ ↑f x ≠ 0
[PROOFSTEP]
classical rw [AList.mem_keys, ← List.mem_toFinset, toAList_keys_toFinset, mem_support_iff]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
x : α
⊢ x ∈ toAList f ↔ ↑f x ≠ 0
[PROOFSTEP]
rw [AList.mem_keys, ← List.mem_toFinset, toAList_keys_toFinset, mem_support_iff]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
⊢ Finset α
[PROOFSTEP]
haveI := Classical.decEq α
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
this : DecidableEq α
⊢ Finset α
[PROOFSTEP]
haveI := Classical.decEq M
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
this✝ : DecidableEq α
this : DecidableEq M
⊢ Finset α
[PROOFSTEP]
exact (l.1.filter fun x => Sigma.snd x ≠ 0).keys.toFinset
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
a : α
⊢ a ∈ toFinset (List.keys (filter (fun x => decide (x.snd ≠ 0)) l.entries)) ↔
    (fun a => Option.getD (lookup a l) 0) a ≠ 0
[PROOFSTEP]
classical
simp_rw [@mem_toFinset _ _, List.mem_keys, List.mem_filter, ← mem_lookup_iff]
cases lookup a l <;> simp
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
a : α
⊢ a ∈ toFinset (List.keys (filter (fun x => decide (x.snd ≠ 0)) l.entries)) ↔
    (fun a => Option.getD (lookup a l) 0) a ≠ 0
[PROOFSTEP]
simp_rw [@mem_toFinset _ _, List.mem_keys, List.mem_filter, ← mem_lookup_iff]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
a : α
⊢ (∃ b, b ∈ lookup a l ∧ decide (b ≠ 0) = true) ↔ Option.getD (lookup a l) 0 ≠ 0
[PROOFSTEP]
cases lookup a l
[GOAL]
case none
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
a : α
⊢ (∃ b, b ∈ none ∧ decide (b ≠ 0) = true) ↔ Option.getD none 0 ≠ 0
[PROOFSTEP]
simp
[GOAL]
case some
α : Type u_1
M : Type u_2
inst✝ : Zero M
l : AList fun _x => M
a : α
val✝ : M
⊢ (∃ b, b ∈ some val✝ ∧ decide (b ≠ 0) = true) ↔ Option.getD (some val✝) 0 ≠ 0
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ ↑(lookupFinsupp l) a = Option.getD (lookup a l) 0
[PROOFSTEP]
simp only [lookupFinsupp, ne_eq, Finsupp.coe_mk]
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ Option.getD (lookup a l) 0 = Option.getD (lookup a l) 0
[PROOFSTEP]
congr
[GOAL]
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (lookupFinsupp l).support = toFinset (List.keys (filter (fun x => decide (x.snd ≠ 0)) l.entries))
[PROOFSTEP]
simp only [lookupFinsupp, ne_eq, Finsupp.coe_mk]
[GOAL]
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ toFinset (List.keys (filter (fun x => decide ¬x.snd = 0) l.entries)) =
    toFinset (List.keys (filter (fun x => decide ¬x.snd = 0) l.entries))
[PROOFSTEP]
congr
[GOAL]
case h.e_2.h
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (fun a b => Classical.decEq α a b) = fun a b => inst✝¹ a b
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
case h.e_3.h.e_a.e_p
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (fun x => decide ¬x.snd = 0) = fun x => decide ¬x.snd = 0
[PROOFSTEP]
funext
[GOAL]
case h.e_3.h.e_a.e_p.h
α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
x✝ : (_ : α) × M
⊢ (decide ¬x✝.snd = 0) = decide ¬x✝.snd = 0
[PROOFSTEP]
congr
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
⊢ ↑(lookupFinsupp l) a = x ↔ x ∈ lookup a l
[PROOFSTEP]
rw [lookupFinsupp_apply]
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
⊢ Option.getD (lookup a l) 0 = x ↔ x ∈ lookup a l
[PROOFSTEP]
cases' lookup a l with m
[GOAL]
case none
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
⊢ Option.getD none 0 = x ↔ x ∈ none
[PROOFSTEP]
simp [hx.symm]
[GOAL]
case some
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
m : M
⊢ Option.getD (some m) 0 = x ↔ x ∈ some m
[PROOFSTEP]
simp [hx.symm]
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ ↑(lookupFinsupp l) a = 0 ↔ ¬a ∈ l ∨ 0 ∈ lookup a l
[PROOFSTEP]
rw [lookupFinsupp_apply, ← lookup_eq_none]
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ Option.getD (lookup a l) 0 = 0 ↔ lookup a l = none ∨ 0 ∈ lookup a l
[PROOFSTEP]
cases' lookup a l with m
[GOAL]
case none
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
⊢ Option.getD none 0 = 0 ↔ none = none ∨ 0 ∈ none
[PROOFSTEP]
simp
[GOAL]
case some
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
⊢ Option.getD (some m) 0 = 0 ↔ some m = none ∨ 0 ∈ some m
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
⊢ lookupFinsupp ∅ = 0
[PROOFSTEP]
classical
ext
simp
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
⊢ lookupFinsupp ∅ = 0
[PROOFSTEP]
ext
[GOAL]
case h
α : Type u_1
M : Type u_2
inst✝ : Zero M
a✝ : α
⊢ ↑(lookupFinsupp ∅) a✝ = ↑0 a✝
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
⊢ lookupFinsupp (insert a m l) = Finsupp.update (lookupFinsupp l) a m
[PROOFSTEP]
ext b
[GOAL]
case h
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
b : α
⊢ ↑(lookupFinsupp (insert a m l)) b = ↑(Finsupp.update (lookupFinsupp l) a m) b
[PROOFSTEP]
by_cases h : b = a
[GOAL]
case pos
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
b : α
h : b = a
⊢ ↑(lookupFinsupp (insert a m l)) b = ↑(Finsupp.update (lookupFinsupp l) a m) b
[PROOFSTEP]
simp [h]
[GOAL]
case neg
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
m : M
b : α
h : ¬b = a
⊢ ↑(lookupFinsupp (insert a m l)) b = ↑(Finsupp.update (lookupFinsupp l) a m) b
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
a : α
m : M
⊢ lookupFinsupp (singleton a m) = Finsupp.single a m
[PROOFSTEP]
classical
  -- porting note: was `simp [←AList.insert_empty]` but timeout issuessimp only [← AList.insert_empty,
  insert_lookupFinsupp, empty_lookupFinsupp, Finsupp.zero_update]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
a : α
m : M
⊢ lookupFinsupp (singleton a m) = Finsupp.single a m
[PROOFSTEP]
simp only [← AList.insert_empty, insert_lookupFinsupp, empty_lookupFinsupp, Finsupp.zero_update]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
⊢ lookupFinsupp (Finsupp.toAList f) = f
[PROOFSTEP]
ext a
[GOAL]
case h
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
classical
by_cases h : f a = 0
· suffices f.toAList.lookup a = none by simp [h, this]
  · simp [lookup_eq_none, h]
· suffices f.toAList.lookup a = some (f a) by simp [h, this]
  · apply mem_lookup_iff.2
    simpa using h
[GOAL]
case h
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
by_cases h : f a = 0
[GOAL]
case pos
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ↑f a = 0
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
suffices f.toAList.lookup a = none by simp [h, this]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ↑f a = 0
this : lookup a (Finsupp.toAList f) = none
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
simp [h, this]
[GOAL]
case pos
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ↑f a = 0
⊢ lookup a (Finsupp.toAList f) = none
[PROOFSTEP]
simp [lookup_eq_none, h]
[GOAL]
case neg
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ¬↑f a = 0
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
suffices f.toAList.lookup a = some (f a) by simp [h, this]
[GOAL]
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ¬↑f a = 0
this : lookup a (Finsupp.toAList f) = some (↑f a)
⊢ ↑(lookupFinsupp (Finsupp.toAList f)) a = ↑f a
[PROOFSTEP]
simp [h, this]
[GOAL]
case neg
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ¬↑f a = 0
⊢ lookup a (Finsupp.toAList f) = some (↑f a)
[PROOFSTEP]
apply mem_lookup_iff.2
[GOAL]
case neg
α : Type u_1
M : Type u_2
inst✝ : Zero M
f : α →₀ M
a : α
h : ¬↑f a = 0
⊢ { fst := a, snd := ↑f a } ∈ (Finsupp.toAList f).entries
[PROOFSTEP]
simpa using h


[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
src✝ : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
T S : Module.End R (n → R)
⊢ AddHom.toFun src✝.toAddHom ⁅T, S⁆ = ⁅AddHom.toFun src✝.toAddHom T, AddHom.toFun src✝.toAddHom S⁆
[PROOFSTEP]
let f := @LinearMap.toMatrix' R _ n n _ _
[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
src✝ : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
T S : Module.End R (n → R)
f : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
⊢ AddHom.toFun src✝.toAddHom ⁅T, S⁆ = ⁅AddHom.toFun src✝.toAddHom T, AddHom.toFun src✝.toAddHom S⁆
[PROOFSTEP]
change f (T.comp S - S.comp T) = f T * f S - f S * f T
[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
src✝ : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
T S : Module.End R (n → R)
f : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
⊢ ↑f (LinearMap.comp T S - LinearMap.comp S T) = ↑f T * ↑f S - ↑f S * ↑f T
[PROOFSTEP]
have h : ∀ T S : Module.End R _, f (T.comp S) = f T * f S := LinearMap.toMatrix'_comp
[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
src✝ : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
T S : Module.End R (n → R)
f : ((n → R) →ₗ[R] n → R) ≃ₗ[R] Matrix n n R := LinearMap.toMatrix'
h : ∀ (T S : Module.End R (n → R)), ↑f (LinearMap.comp T S) = ↑f T * ↑f S
⊢ ↑f (LinearMap.comp T S - LinearMap.comp S T) = ↑f T * ↑f S - ↑f S * ↑f T
[PROOFSTEP]
rw [LinearEquiv.map_sub, h, h]
[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ ↑(lieConj P h) A = P * A * P⁻¹
[PROOFSTEP]
simp [LinearEquiv.conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp, LinearMap.toMatrix'_toLin']
[GOAL]
R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ ↑(LieEquiv.symm (lieConj P h)) A = P⁻¹ * A * P
[PROOFSTEP]
simp [LinearEquiv.symm_conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp, LinearMap.toMatrix'_toLin']
[GOAL]
R : Type u
inst✝⁴ : CommRing R
n : Type w
inst✝³ : DecidableEq n
inst✝² : Fintype n
m : Type w₁
inst✝¹ : DecidableEq m
inst✝ : Fintype m
e : n ≃ m
src✝ : Matrix n n R ≃ₗ[R] Matrix m m R := reindexLinearEquiv R R e e
x✝¹ x✝ : Matrix n n R
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := ↑(reindex e e),
              map_add' :=
                (_ :
                  ∀ (x y : Matrix n n R),
                    AddHom.toFun src✝.toAddHom (x + y) = AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : Matrix n n R),
                AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      ⁅x✝¹, x✝⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              { toFun := ↑(reindex e e),
                map_add' :=
                  (_ :
                    ∀ (x y : Matrix n n R),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : Matrix n n R),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x✝¹,
      AddHom.toFun
        {
            toAddHom :=
              { toFun := ↑(reindex e e),
                map_add' :=
                  (_ :
                    ∀ (x y : Matrix n n R),
                      AddHom.toFun src✝.toAddHom (x + y) =
                        AddHom.toFun src✝.toAddHom x + AddHom.toFun src✝.toAddHom y) },
            map_smul' :=
              (_ :
                ∀ (r : R) (x : Matrix n n R),
                  AddHom.toFun src✝.toAddHom (r • x) = ↑(RingHom.id R) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        x✝⁆
[PROOFSTEP]
simp only [LieRing.of_associative_ring_bracket, Matrix.reindex_apply, Matrix.submatrix_mul_equiv, Matrix.submatrix_sub,
  Pi.sub_apply]


[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ≅ h
⊢ f ◁ η.hom ≫ f ◁ η.inv = 𝟙 (f ≫ g)
[PROOFSTEP]
rw [← whiskerLeft_comp, hom_inv_id, whiskerLeft_id]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ≅ g
h : b ⟶ c
⊢ η.hom ▷ h ≫ η.inv ▷ h = 𝟙 (f ≫ h)
[PROOFSTEP]
rw [← comp_whiskerRight, hom_inv_id, id_whiskerRight]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ≅ h
⊢ f ◁ η.inv ≫ f ◁ η.hom = 𝟙 (f ≫ h)
[PROOFSTEP]
rw [← whiskerLeft_comp, inv_hom_id, whiskerLeft_id]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ≅ g
h : b ⟶ c
⊢ η.inv ▷ h ≫ η.hom ▷ h = 𝟙 (g ≫ h)
[PROOFSTEP]
rw [← comp_whiskerRight, inv_hom_id, id_whiskerRight]
[GOAL]
B : Type u
inst✝¹ : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ⟶ h
inst✝ : IsIso η
⊢ inv (f ◁ η) = f ◁ inv η
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case hom_inv_id
B : Type u
inst : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ⟶ h
inst_1 : IsIso η
⊢ f ◁ η ≫ f ◁ inv η = 𝟙 (f ≫ g)
[PROOFSTEP]
simp only [← whiskerLeft_comp, whiskerLeft_id, IsIso.hom_inv_id]
[GOAL]
B : Type u
inst✝¹ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
h : b ⟶ c
inst✝ : IsIso η
⊢ inv (η ▷ h) = inv η ▷ h
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case hom_inv_id
B : Type u
inst : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
h : b ⟶ c
inst_1 : IsIso η
⊢ η ▷ h ≫ inv η ▷ h = 𝟙 (f ≫ h)
[PROOFSTEP]
simp only [← comp_whiskerRight, id_whiskerRight, IsIso.hom_inv_id]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i) =
    inv ((α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom = f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv
[PROOFSTEP]
rw [← cancel_epi (f ◁ (α_ g h i).inv), ← cancel_mono (α_ (f ≫ g) h i).inv]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom) ≫ (α_ (f ≫ g) h i).inv =
    (f ◁ (α_ g h i).inv ≫ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv) ≫ (α_ (f ≫ g) h i).inv
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i ≫ (α_ f (g ≫ h) i).hom) =
    inv ((α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv = (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i
[PROOFSTEP]
simp [← cancel_epi (f ◁ (α_ g h i).inv)]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ (f ≫ g) h i).hom ≫ (α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv) =
    inv ((α_ f g h).hom ▷ i ≫ (α_ f (g ≫ h) i).hom)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv = (α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i
[PROOFSTEP]
rw [← cancel_epi (α_ f g (h ≫ i)).inv, ← cancel_mono ((α_ f g h).inv ▷ i)]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ ((α_ f g (h ≫ i)).inv ≫ (α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv) ≫ (α_ f g h).inv ▷ i =
    ((α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i) ≫ (α_ f g h).inv ▷ i
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ f (g ≫ h) i).hom ≫ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv) =
    inv ((α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom ≫ (α_ f g (h ≫ i)).hom = (α_ f (g ≫ h) i).hom ≫ f ◁ (α_ g h i).hom
[PROOFSTEP]
simp [← cancel_epi ((α_ f g h).hom ▷ i)]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i) =
    inv (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (α_ f (𝟙 b) g).inv ≫ (ρ_ f).hom ▷ g = f ◁ (λ_ g).hom
[PROOFSTEP]
rw [← triangle, inv_hom_id_assoc]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ f).inv ▷ g ≫ (α_ f (𝟙 b) g).hom = f ◁ (λ_ g).inv
[PROOFSTEP]
simp [← cancel_mono (f ◁ (λ_ g).hom)]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ f ◁ (λ_ g).inv ≫ (α_ f (𝟙 b) g).inv = (ρ_ f).inv ▷ g
[PROOFSTEP]
simp [← cancel_mono ((ρ_ f).hom ▷ g)]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h ≫ (α_ f' g h).hom = (α_ f g h).hom ≫ η ▷ (g ≫ h)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ (g ≫ h) ≫ (α_ f' g h).inv = (α_ f g h).inv ≫ η ▷ g ▷ h
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h = (α_ f g h).hom ≫ η ▷ (g ≫ h) ≫ (α_ f' g h).inv
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g g' : b ⟶ c
η : g ⟶ g'
h : c ⟶ d
⊢ (f ◁ η) ▷ h ≫ (α_ f g' h).hom = (α_ f g h).hom ≫ f ◁ η ▷ h
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g g' : b ⟶ c
η : g ⟶ g'
h : c ⟶ d
⊢ f ◁ η ▷ h ≫ (α_ f g' h).inv = (α_ f g h).inv ≫ (f ◁ η) ▷ h
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g g' : b ⟶ c
η : g ⟶ g'
h : c ⟶ d
⊢ f ◁ η ▷ h = (α_ f g h).inv ≫ (f ◁ η) ▷ h ≫ (α_ f g' h).hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ (f ≫ g) ◁ η ≫ (α_ f g h').hom = (α_ f g h).hom ≫ f ◁ g ◁ η
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ f ◁ g ◁ η ≫ (α_ f g h').inv = (α_ f g h).inv ≫ (f ≫ g) ◁ η
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ f ◁ g ◁ η = (α_ f g h).inv ≫ (f ≫ g) ◁ η ≫ (α_ f g h').hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ 𝟙 a ◁ η ≫ (λ_ g).hom = (λ_ f).hom ≫ η
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η ≫ (λ_ g).inv = (λ_ f).inv ≫ 𝟙 a ◁ η
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η ▷ 𝟙 b ≫ (ρ_ g).hom = (ρ_ f).hom ≫ η
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η ≫ (ρ_ g).inv = (ρ_ f).inv ≫ η ▷ 𝟙 b
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η = (ρ_ f).inv ≫ η ▷ 𝟙 b ≫ (ρ_ g).hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η θ : f ⟶ g
⊢ 𝟙 a ◁ η = 𝟙 a ◁ θ ↔ η = θ
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η θ : f ⟶ g
⊢ η ▷ 𝟙 b = θ ▷ 𝟙 b ↔ η = θ
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ f).hom ▷ g = (α_ (𝟙 a) f g).hom ≫ (λ_ (f ≫ g)).hom
[PROOFSTEP]
rw [← whiskerLeft_iff, whiskerLeft_comp, ← cancel_epi (α_ _ _ _).hom, ← cancel_epi ((α_ _ _ _).hom ▷ _), pentagon_assoc,
  triangle, ← associator_naturality_middle, ← comp_whiskerRight_assoc, triangle, associator_naturality_left]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ inv ((λ_ f).inv ▷ g) = inv ((λ_ (f ≫ g)).inv ≫ (α_ (𝟙 a) f g).inv)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ f ◁ (ρ_ g).hom = (α_ f g (𝟙 c)).inv ≫ (ρ_ (f ≫ g)).hom
[PROOFSTEP]
rw [← whiskerRight_iff, comp_whiskerRight, ← cancel_epi (α_ _ _ _).inv, ← cancel_epi (f ◁ (α_ _ _ _).inv),
  pentagon_inv_assoc, triangle_assoc_comp_right, ← associator_inv_naturality_middle, ← whiskerLeft_comp_assoc,
  triangle_assoc_comp_right, associator_inv_naturality_right]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ inv (f ◁ (ρ_ g).inv) = inv ((ρ_ (f ≫ g)).inv ≫ (α_ f g (𝟙 c)).hom)
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ (f ≫ g)).hom = (α_ (𝟙 a) f g).inv ≫ (λ_ f).hom ▷ g
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ (f ≫ g)).inv = (λ_ f).inv ▷ g ≫ (α_ (𝟙 a) f g).hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ (f ≫ g)).hom = (α_ f g (𝟙 c)).hom ≫ f ◁ (ρ_ g).hom
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ (f ≫ g)).inv = f ◁ (ρ_ g).inv ≫ (α_ f g (𝟙 c)).inv
[PROOFSTEP]
simp
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
⊢ (λ_ (𝟙 a)).hom = (ρ_ (𝟙 a)).hom
[PROOFSTEP]
rw [← whiskerLeft_iff, ← cancel_epi (α_ _ _ _).hom, ← cancel_mono (ρ_ _).hom, triangle, ← rightUnitor_comp,
  rightUnitor_naturality]
[GOAL]
B : Type u
inst✝ : Bicategory B
a b c d e : B
⊢ (λ_ (𝟙 a)).inv = (ρ_ (𝟙 a)).inv
[PROOFSTEP]
simp [Iso.inv_eq_inv]