DibyashanuPati/PhysLean
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: Replace FDiscrete with FD

Browse source
This commit is contained in:
jstoobysmith 2024-11-05 14:37:10 +00:00
parent bfaaf36485
commit 5acf22c479
9 changed files with 223 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

22
HepLean/Tensors/Tree/NodeIdentities/Basic.lean
View file

@ -304,29 +304,29 @@ lemma action_id {n : ℕ} {c : Fin n → S.C} (t : TensorTree S c) :
simp only [action_tensor, map_one, LinearMap.one_apply]
lemma action_constTwoNode {c1 c2 : S.C}
(v : 𝟙_ (Rep S.k S.G) ⟶ S.FDiscrete.obj (Discrete.mk c1) ⊗ S.FDiscrete.obj (Discrete.mk c2))
(v : 𝟙_ (Rep S.k S.G) ⟶ S.FD.obj (Discrete.mk c1) ⊗ S.FD.obj (Discrete.mk c2))
(g : S.G) : (action g (constTwoNode v)).tensor = (constTwoNode v).tensor := by
simp only [Nat.succ_eq_add_one, Nat.reduceAdd, action_tensor, constTwoNode_tensor,
Action.instMonoidalCategory_tensorObj_V, Action.instMonoidalCategory_tensorUnit_V]
change ((Discrete.pairIsoSep S.FDiscrete).hom.hom ≫ (S.F.obj (OverColor.mk ![c1, c2])).ρ g)
change ((Discrete.pairIsoSep S.FD).hom.hom ≫ (S.F.obj (OverColor.mk ![c1, c2])).ρ g)
((v.hom _)) = _
erw [← (Discrete.pairIsoSep S.FDiscrete).hom.comm g]
change ((v.hom ≫ (S.FDiscrete.obj { as := c1 } ⊗ S.FDiscrete.obj { as := c2 }).ρ g) ≫
(Discrete.pairIsoSep S.FDiscrete).hom.hom) _ =_
erw [← (Discrete.pairIsoSep S.FD).hom.comm g]
change ((v.hom ≫ (S.FD.obj { as := c1 } ⊗ S.FD.obj { as := c2 }).ρ g) ≫
(Discrete.pairIsoSep S.FD).hom.hom) _ =_
erw [← v.comm g]
simp
lemma action_constThreeNode {c1 c2 c3 : S.C}
(v : 𝟙_ (Rep S.k S.G) ⟶ S.FDiscrete.obj (Discrete.mk c1) ⊗ S.FDiscrete.obj (Discrete.mk c2) ⊗
S.FDiscrete.obj (Discrete.mk c3))
(v : 𝟙_ (Rep S.k S.G) ⟶ S.FD.obj (Discrete.mk c1) ⊗ S.FD.obj (Discrete.mk c2) ⊗
S.FD.obj (Discrete.mk c3))
(g : S.G) : (action g (constThreeNode v)).tensor = (constThreeNode v).tensor := by
simp only [Nat.succ_eq_add_one, Nat.reduceAdd, action_tensor, constThreeNode_tensor,
Action.instMonoidalCategory_tensorObj_V, Action.instMonoidalCategory_tensorUnit_V]
change ((Discrete.tripleIsoSep S.FDiscrete).hom.hom ≫ (S.F.obj (OverColor.mk ![c1, c2, c3])).ρ g)
change ((Discrete.tripleIsoSep S.FD).hom.hom ≫ (S.F.obj (OverColor.mk ![c1, c2, c3])).ρ g)
((v.hom _)) = _
erw [← (Discrete.tripleIsoSep S.FDiscrete).hom.comm g]
change ((v.hom ≫ (S.FDiscrete.obj { as := c1 } ⊗ S.FDiscrete.obj { as := c2 } ⊗
S.FDiscrete.obj { as := c3 }).ρ g) ≫ (Discrete.tripleIsoSep S.FDiscrete).hom.hom) _ =_
erw [← (Discrete.tripleIsoSep S.FD).hom.comm g]
change ((v.hom ≫ (S.FD.obj { as := c1 } ⊗ S.FD.obj { as := c2 } ⊗
S.FD.obj { as := c3 }).ρ g) ≫ (Discrete.tripleIsoSep S.FD).hom.hom) _ =_
erw [← v.comm g]
simp

28
HepLean/Tensors/Tree/NodeIdentities/ContrContr.lean
View file

@ -158,18 +158,18 @@ def contrSwapHom : (OverColor.mk ((c ∘ q.swap.i.succAbove ∘ q.swap.j.succAbo
(mkIso (funext fun x => congrArg c (swap_map_eq q x))).hom
lemma contrSwapHom_contrMapSnd_tprod (x : (i : (𝟭 Type).obj (OverColor.mk c).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c).hom i })) :
((lift.obj S.FDiscrete).map q.contrSwapHom).hom
CoeSort.coe (S.FD.obj { as := (OverColor.mk c).hom i })) :
((lift.obj S.FD).map q.contrSwapHom).hom
(q.swap.contrMapSnd.hom ((PiTensorProduct.tprod S.k) fun k =>
x (q.swap.i.succAbove (q.swap.j.succAbove k)))) = ((S.castToField
((S.contr.app { as := (c ∘ q.swap.i.succAbove ∘ q.swap.j.succAbove) q.swap.k }).hom
(x (q.swap.i.succAbove (q.swap.j.succAbove q.swap.k)) ⊗ₜ[S.k]
(S.FDiscrete.map (Discrete.eqToHom q.swap.hkl)).hom
(S.FD.map (Discrete.eqToHom q.swap.hkl)).hom
(x (q.swap.i.succAbove (q.swap.j.succAbove (q.swap.k.succAbove q.swap.l))))))) •
((lift.obj S.FDiscrete).map q.contrSwapHom).hom ((PiTensorProduct.tprod S.k) fun k =>
((lift.obj S.FD).map q.contrSwapHom).hom ((PiTensorProduct.tprod S.k) fun k =>
x (q.swap.i.succAbove (q.swap.j.succAbove (q.swap.k.succAbove (q.swap.l.succAbove k)))))) := by
rw [contrMapSnd,TensorSpecies.contrMap_tprod]
change ((lift.obj S.FDiscrete).map q.contrSwapHom).hom
change ((lift.obj S.FD).map q.contrSwapHom).hom
(_ • ((PiTensorProduct.tprod S.k) fun k =>
x (q.swap.i.succAbove (q.swap.j.succAbove
(q.swap.k.succAbove (q.swap.l.succAbove k)))) :
@ -179,10 +179,10 @@ lemma contrSwapHom_contrMapSnd_tprod (x : (i : (𝟭 Type).obj (OverColor.mk c).
rfl
lemma contrSwapHom_tprod (x : (i : (𝟭 Type).obj (OverColor.mk c).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c).hom i })) :
CoeSort.coe (S.FD.obj { as := (OverColor.mk c).hom i })) :
((PiTensorProduct.tprod S.k)
fun k => x (q.i.succAbove (q.j.succAbove (q.k.succAbove (q.l.succAbove k))))) =
((lift.obj S.FDiscrete).map q.contrSwapHom).hom
((lift.obj S.FD).map q.contrSwapHom).hom
((PiTensorProduct.tprod S.k) fun k =>
x (q.swap.i.succAbove (q.swap.j.succAbove (q.swap.k.succAbove (q.swap.l.succAbove k))))) := by
rw [lift.map_tprod]
@ -190,9 +190,9 @@ lemma contrSwapHom_tprod (x : (i : (𝟭 Type).obj (OverColor.mk c).left) →
funext i
simp only [Nat.succ_eq_add_one, mk_hom, Function.comp_apply]
rw [lift.discreteFunctorMapEqIso]
change _ = (S.FDiscrete.map (Discrete.eqToIso _).hom).hom _
change _ = (S.FD.map (Discrete.eqToIso _).hom).hom _
have h1' {a b : Fin n.succ.succ.succ.succ} (h : a = b) :
x b = (S.FDiscrete.map (Discrete.eqToIso (by rw [h])).hom).hom (x a) := by
x b = (S.FD.map (Discrete.eqToIso (by rw [h])).hom).hom (x a) := by
subst h
simp
exact h1' (q.swap_map_eq i)
@ -223,7 +223,7 @@ lemma contrMapFst_contrMapSnd_swap :
q.contrMapSnd.hom ((PiTensorProduct.tprod S.k) fun k => x (q.i.succAbove (q.j.succAbove k))) =
S.castToField
_ •
((lift.obj S.FDiscrete).map q.contrSwapHom).hom
((lift.obj S.FD).map q.contrSwapHom).hom
(q.swap.contrMapSnd.hom ((PiTensorProduct.tprod S.k)
fun k => x (q.swap.i.succAbove (q.swap.j.succAbove k))))
rw [contrMapSnd, TensorSpecies.contrMap_tprod, q.contrSwapHom_contrMapSnd_tprod]
@ -235,8 +235,8 @@ lemma contrMapFst_contrMapSnd_swap :
· congr 3
have h1' {a b d: Fin n.succ.succ.succ.succ} (hbd : b = d) (h : c d = S.τ (c a))
(h' : c b = S.τ (c a)) :
(S.FDiscrete.map (Discrete.eqToHom (h))).hom (x d) =
(S.FDiscrete.map (Discrete.eqToHom h')).hom (x b) := by
(S.FD.map (Discrete.eqToHom (h))).hom (x d) =
(S.FD.map (Discrete.eqToHom h')).hom (x b) := by
subst hbd
rfl
refine h1' ?_ ?_ ?_
@ -251,9 +251,9 @@ lemma contrMapFst_contrMapSnd_swap :
have h' {a a' b b' : Fin n.succ.succ.succ.succ} (hab : c b = S.τ (c a))
(hab' : c b' = S.τ (c a')) (ha : a = a') (hb : b= b') :
(S.contr.app { as := c a }).hom
(x a ⊗ₜ[S.k] (S.FDiscrete.map (Discrete.eqToHom hab)).hom (x b)) =
(x a ⊗ₜ[S.k] (S.FD.map (Discrete.eqToHom hab)).hom (x b)) =
(S.contr.app { as := c a' }).hom (x a' ⊗ₜ[S.k]
(S.FDiscrete.map (Discrete.eqToHom hab')).hom (x b')) := by
(S.FD.map (Discrete.eqToHom hab')).hom (x b')) := by
subst ha hb
rfl
apply h'

14
HepLean/Tensors/Tree/NodeIdentities/ContrSwap.lean
View file

@ -93,8 +93,8 @@ lemma contrMap_swap : q.contrMap = q.swap.contrMap ≫ S.F.map q.contrSwapHom :=
· apply congrArg
erw [S.contr_tmul_symm]
have h1' : ∀ {a a' b c b' c'} (haa' : a = a')
(_ : b = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(_ : b = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(S.contr.app a).hom (b ⊗ₜ[S.k] c) = (S.contr.app a').hom (b' ⊗ₜ[S.k] c') := by
intro a a' b c b' c' haa' hbc hcc
subst haa'
@ -103,14 +103,14 @@ lemma contrMap_swap : q.contrMap = q.swap.contrMap ≫ S.F.map q.contrSwapHom :=
· simp only [Discrete.mk.injEq]
exact Eq.symm (swapI_color q)
· rfl
· change _ = ((S.FDiscrete.map (Discrete.eqToHom _)) ≫ S.FDiscrete.map (Discrete.eqToHom _)).hom
· change _ = ((S.FD.map (Discrete.eqToHom _)) ≫ S.FD.map (Discrete.eqToHom _)).hom
(x (q.swap.i.succAbove q.swap.j))
rw [← S.FDiscrete.map_comp]
rw [← S.FD.map_comp]
simp only [Nat.succ_eq_add_one, mk_hom, Discrete.functor_obj_eq_as, Function.comp_apply,
eqToHom_trans]
have h1nn' {a b d: Fin n.succ.succ} (hbd : b = d) (h : c d = S.τ (S.τ (c a))) :
(S.FDiscrete.map (Discrete.eqToHom (h))).hom (x d) =
(S.FDiscrete.map (eqToHom (by
(S.FD.map (Discrete.eqToHom (h))).hom (x d) =
(S.FD.map (eqToHom (by
subst hbd
simp_all only [Nat.succ_eq_add_one, forall_true_left, Discrete.functor_obj_eq_as,
Function.comp_apply, Monoidal.tensorUnit_obj, Action.instMonoidalCategory_tensorUnit_V,
@ -127,7 +127,7 @@ lemma contrMap_swap : q.contrMap = q.swap.contrMap ≫ S.F.map q.contrSwapHom :=
apply congrArg
funext k
have h1' {a b : Fin n.succ.succ} (h : a = b) :
x b = (S.FDiscrete.map (Discrete.eqToIso (by rw [h])).hom).hom (x a) := by
x b = (S.FD.map (Discrete.eqToIso (by rw [h])).hom).hom (x a) := by
subst h
simp only [Nat.succ_eq_add_one, mk_hom, eqToIso_refl, Iso.refl_hom, Discrete.functor_map_id,
Action.id_hom, ModuleCat.id_apply]

18
HepLean/Tensors/Tree/NodeIdentities/PermContr.lean
View file

@ -32,13 +32,13 @@ lemma contrFin1Fin1_naturality {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
= (S.contrFin1Fin1 c ((Hom.toEquiv σ).symm i)
((HepLean.Fin.finExtractOnePerm ((Hom.toEquiv σ).symm i) (Hom.toEquiv σ)).symm j)
(perm_contr_cond S h σ)).hom.hom
≫ ((Discrete.pairτ S.FDiscrete S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
≫ ((Discrete.pairτ S.FD S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
(Discrete.mk (c ((Hom.toEquiv σ).symm i))) ⟶ (Discrete.mk (c1 i)))).hom := by
have h1 : (S.F.map (extractTwoAux' i j σ)) ≫ (S.contrFin1Fin1 c1 i j h).hom
= (S.contrFin1Fin1 c ((Hom.toEquiv σ).symm i)
((HepLean.Fin.finExtractOnePerm ((Hom.toEquiv σ).symm i) (Hom.toEquiv σ)).symm j)
(perm_contr_cond S h σ)).hom
≫ ((Discrete.pairτ S.FDiscrete S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
≫ ((Discrete.pairτ S.FD S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
(Discrete.mk (c ((Hom.toEquiv σ).symm i))) ⟶ (Discrete.mk (c1 i)))) := by
erw [← CategoryTheory.Iso.eq_comp_inv]
rw [CategoryTheory.Category.assoc]
@ -51,7 +51,7 @@ lemma contrFin1Fin1_naturality {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
Functor.comp_obj, Discrete.functor_obj_eq_as, Function.comp_apply, CategoryStruct.comp,
extractOne_homToEquiv, Action.Hom.comp_hom, LinearMap.coe_comp]
trans (S.F.map (extractTwoAux' i j σ)).hom (PiTensorProduct.tprod S.k (fun k =>
match k with | Sum.inl 0 => x | Sum.inr 0 => (S.FDiscrete.map
match k with | Sum.inl 0 => x | Sum.inr 0 => (S.FD.map
(eqToHom (by
simp only [Nat.succ_eq_add_one, Discrete.functor_obj_eq_as, Function.comp_apply,
extractOne_homToEquiv, Fin.isValue, mk_hom, finExtractTwo_symm_inl_inr_apply,
@ -72,10 +72,10 @@ lemma contrFin1Fin1_naturality {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
| Sum.inl 0 => rfl
| Sum.inr 0 => rfl
change _ = (S.contrFin1Fin1 c1 i j h).inv.hom
((S.FDiscrete.map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i))).hom x ⊗ₜ[S.k]
(S.FDiscrete.map (Discrete.eqToHom (congrArg S.τ (Hom.toEquiv_comp_inv_apply σ i)))).hom y)
((S.FD.map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i))).hom x ⊗ₜ[S.k]
(S.FD.map (Discrete.eqToHom (congrArg S.τ (Hom.toEquiv_comp_inv_apply σ i)))).hom y)
rw [contrFin1Fin1_inv_tmul]
change ((lift.obj S.FDiscrete).map (extractTwoAux' i j σ)).hom _ = _
change ((lift.obj S.FD).map (extractTwoAux' i j σ)).hom _ = _
rw [lift.map_tprod]
apply congrArg
funext i
@ -86,8 +86,8 @@ lemma contrFin1Fin1_naturality {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
extractOne_homToEquiv, lift.discreteFunctorMapEqIso, Functor.mapIso_hom, eqToIso.hom,
Functor.mapIso_inv, eqToIso.inv, Functor.id_obj, Discrete.functor_obj_eq_as,
LinearEquiv.ofLinear_apply]
change ((S.FDiscrete.map (eqToHom _)) ≫ S.FDiscrete.map (eqToHom _)).hom y =
((S.FDiscrete.map (eqToHom _)) ≫ S.FDiscrete.map (eqToHom _)).hom y
change ((S.FD.map (eqToHom _)) ≫ S.FD.map (eqToHom _)).hom y =
((S.FD.map (eqToHom _)) ≫ S.FD.map (eqToHom _)).hom y
rw [← Functor.map_comp, ← Functor.map_comp]
simp only [Fin.isValue, Nat.succ_eq_add_one, Discrete.functor_obj_eq_as, Function.comp_apply,
eqToHom_trans]
@ -154,7 +154,7 @@ lemma contrIso_comm_aux_3 {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
/-- A helper function used to proof the relation between perm and contr. -/
def contrIsoComm {n : ℕ} {c c1 : Fin n.succ.succ → S.C}
{i : Fin n.succ.succ} {j : Fin n.succ} (σ : (OverColor.mk c) ⟶ (OverColor.mk c1)) :=
(((Discrete.pairτ S.FDiscrete S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
(((Discrete.pairτ S.FD S.τ).map (Discrete.eqToHom (Hom.toEquiv_comp_inv_apply σ i) :
(Discrete.mk (c ((Hom.toEquiv σ).symm i))) ⟶
(Discrete.mk (c1 i)))) ⊗ (S.F.map (extractTwo i j σ)))

8
HepLean/Tensors/Tree/NodeIdentities/ProdComm.lean
View file

@ -56,15 +56,15 @@ theorem prod_comm (t : TensorTree S c) (t2 : TensorTree S c2) :
apply congrArg
apply congrArg
change _ = (β_ (S.F.obj (OverColor.mk c2)) (S.F.obj (OverColor.mk c))).hom.hom
((inv (lift.μ S.FDiscrete (OverColor.mk c2) (OverColor.mk c)).hom).hom
((lift.μ S.FDiscrete (OverColor.mk c2) (OverColor.mk c)).hom.hom (t2.tensor ⊗ₜ[S.k] t.tensor)))
((inv (lift.μ S.FD (OverColor.mk c2) (OverColor.mk c)).hom).hom
((lift.μ S.FD (OverColor.mk c2) (OverColor.mk c)).hom.hom (t2.tensor ⊗ₜ[S.k] t.tensor)))
simp only [Action.instMonoidalCategory_tensorObj_V, Equivalence.symm_inverse,
Action.functorCategoryEquivalence_functor, Action.FunctorCategoryEquivalence.functor_obj_obj,
lift.objObj'_V_carrier, instMonoidalCategoryStruct_tensorObj_left,
instMonoidalCategoryStruct_tensorObj_hom, mk_hom, IsIso.Iso.inv_hom]
change _ = (β_ (S.F.obj (OverColor.mk c2)) (S.F.obj (OverColor.mk c))).hom.hom
(((lift.μ S.FDiscrete (OverColor.mk c2) (OverColor.mk c)).hom ≫
(lift.μ S.FDiscrete (OverColor.mk c2) (OverColor.mk c)).inv).hom ((t2.tensor ⊗ₜ[S.k] t.tensor)))
(((lift.μ S.FD (OverColor.mk c2) (OverColor.mk c)).hom ≫
(lift.μ S.FD (OverColor.mk c2) (OverColor.mk c)).inv).hom ((t2.tensor ⊗ₜ[S.k] t.tensor)))
simp only [Action.instMonoidalCategory_tensorObj_V, Iso.hom_inv_id, Action.id_hom,
Equivalence.symm_inverse, Action.functorCategoryEquivalence_functor,
Action.FunctorCategoryEquivalence.functor_obj_obj, lift.objObj'_V_carrier, mk_hom,

76
HepLean/Tensors/Tree/NodeIdentities/ProdContr.lean
View file

@ -146,14 +146,14 @@ lemma contrMap_prod_tprod_aux
(h : Sum.elim c c1 l' = Sum.elim (c ∘ q.i.succAbove ∘ q.j.succAbove) c1 l)
(h' : l' = (Sum.map (q.i.succAbove ∘ q.j.succAbove) id l))
(p : (i : (𝟭 Type).obj (OverColor.mk c).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c).hom i }))
CoeSort.coe (S.FD.obj { as := (OverColor.mk c).hom i }))
(q' : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c1).hom i })) :
(lift.discreteSumEquiv S.FDiscrete l)
CoeSort.coe (S.FD.obj { as := (OverColor.mk c1).hom i })) :
(lift.discreteSumEquiv S.FD l)
(HepLean.PiTensorProduct.elimPureTensor
(fun k => p (q.i.succAbove (q.j.succAbove k))) q' l) =
(S.FDiscrete.map (eqToHom (by simp [h]))).hom
((lift.discreteSumEquiv S.FDiscrete l')
(S.FD.map (eqToHom (by simp [h]))).hom
((lift.discreteSumEquiv S.FD l')
(HepLean.PiTensorProduct.elimPureTensor p q' l')) := by
subst h'
match l with
@ -168,9 +168,9 @@ lemma contrMap_prod_tprod_aux
rfl
lemma contrMap_prod_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c).hom i }))
CoeSort.coe (S.FD.obj { as := (OverColor.mk c).hom i }))
(q' : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c1).hom i })) :
CoeSort.coe (S.FD.obj { as := (OverColor.mk c1).hom i })) :
(S.F.map (equivToIso finSumFinEquiv).hom).hom
((S.F.μ (OverColor.mk (c ∘ q.i.succAbove ∘ q.j.succAbove)) (OverColor.mk c1)).hom
((q.contrMap.hom (PiTensorProduct.tprod S.k p)) ⊗ₜ[S.k] (PiTensorProduct.tprod S.k) q'))
@ -185,25 +185,25 @@ lemma contrMap_prod_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c).left) →
conv_rhs => rw [lift.obj_μ_tprod_tmul]
simp only [TensorProduct.smul_tmul, TensorProduct.tmul_smul, map_smul]
conv_lhs => rw [lift.obj_μ_tprod_tmul]
change _ = ((lift.obj S.FDiscrete).map (mkIso _).hom).hom
change _ = ((lift.obj S.FD).map (mkIso _).hom).hom
(q.leftContr.contrMap.hom
(((lift.obj S.FDiscrete).map (equivToIso leftContrEquivSuccSucc).hom).hom
(((lift.obj S.FDiscrete).map (equivToIso finSumFinEquiv).hom).hom
(((lift.obj S.FD).map (equivToIso leftContrEquivSuccSucc).hom).hom
(((lift.obj S.FD).map (equivToIso finSumFinEquiv).hom).hom
((PiTensorProduct.tprod S.k) _))))
conv_rhs => rw [lift.map_tprod]
change _ = ((lift.obj S.FDiscrete).map (mkIso _).hom).hom
change _ = ((lift.obj S.FD).map (mkIso _).hom).hom
(q.leftContr.contrMap.hom
(((lift.obj S.FDiscrete).map (equivToIso leftContrEquivSuccSucc).hom).hom
(((lift.obj S.FD).map (equivToIso leftContrEquivSuccSucc).hom).hom
(((PiTensorProduct.tprod S.k) _))))
conv_rhs => rw [lift.map_tprod]
change _ = ((lift.obj S.FDiscrete).map (mkIso _).hom).hom
change _ = ((lift.obj S.FD).map (mkIso _).hom).hom
(q.leftContr.contrMap.hom
((PiTensorProduct.tprod S.k) _))
conv_rhs => rw [contrMap, TensorSpecies.contrMap_tprod]
simp only [TensorProduct.smul_tmul, TensorProduct.tmul_smul, map_smul]
have hL (a : Fin n.succ.succ) {b : Fin (n + 1 + 1) ⊕ Fin n1}
(h : b = Sum.inl a) : p a = (S.FDiscrete.map (Discrete.eqToHom (by rw [h]; simp))).hom
((lift.discreteSumEquiv S.FDiscrete b)
(h : b = Sum.inl a) : p a = (S.FD.map (Discrete.eqToHom (by rw [h]; simp))).hom
((lift.discreteSumEquiv S.FD b)
(HepLean.PiTensorProduct.elimPureTensor p q' b)) := by
subst h
simp only [Nat.succ_eq_add_one, mk_hom, instMonoidalCategoryStruct_tensorObj_hom,
@ -220,8 +220,8 @@ lemma contrMap_prod_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c).left) →
Iso.refl_hom, Action.id_hom, Iso.refl_inv, Functor.id_obj,
instMonoidalCategoryStruct_tensorObj_hom, LinearEquiv.ofLinear_apply]
have h1' : ∀ {a a' b c b' c'} (haa' : a = a')
(_ : b = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(_ : b = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(S.contr.app a).hom (b ⊗ₜ[S.k] c) = (S.contr.app a').hom (b' ⊗ₜ[S.k] c') := by
intro a a' b c b' c' haa' hbc hcc
subst haa'
@ -236,15 +236,15 @@ lemma contrMap_prod_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c).left) →
exact Eq.symm ((fun f => (Equiv.apply_eq_iff_eq_symm_apply f).mp) finSumFinEquiv rfl)
· simp only [Discrete.functor_obj_eq_as, Function.comp_apply, AddHom.toFun_eq_coe,
LinearMap.coe_toAddHom, equivToIso_homToEquiv]
change _ = (S.FDiscrete.map (Discrete.eqToHom _) ≫
S.FDiscrete.map (Discrete.eqToHom _)).hom _
rw [← S.FDiscrete.map_comp]
change _ = (S.FD.map (Discrete.eqToHom _) ≫
S.FD.map (Discrete.eqToHom _)).hom _
rw [← S.FD.map_comp]
simp only [eqToHom_trans]
have h1 {a d : Fin n.succ.succ} {b : Fin (n + 1 + 1) ⊕ Fin n1}
(h1' : b = Sum.inl a) (h2' : c a = S.τ (c d)) :
(S.FDiscrete.map (Discrete.eqToHom h2')).hom (p a) =
(S.FDiscrete.map (eqToHom (by subst h1'; simpa using h2'))).hom
((lift.discreteSumEquiv S.FDiscrete b)
(S.FD.map (Discrete.eqToHom h2')).hom (p a) =
(S.FD.map (eqToHom (by subst h1'; simpa using h2'))).hom
((lift.discreteSumEquiv S.FD b)
(HepLean.PiTensorProduct.elimPureTensor p q' b)) := by
subst h1'
rfl
@ -401,9 +401,9 @@ lemma sum_inr_succAbove_rightContrI_rightContrJ (k : Fin n) : (@finSumFinEquiv n
simp
lemma prod_contrMap_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c1).hom i }))
CoeSort.coe (S.FD.obj { as := (OverColor.mk c1).hom i }))
(q' : (i : (𝟭 Type).obj (OverColor.mk c).left) →
CoeSort.coe (S.FDiscrete.obj { as := (OverColor.mk c).hom i })) :
CoeSort.coe (S.FD.obj { as := (OverColor.mk c).hom i })) :
(S.F.map (equivToIso finSumFinEquiv).hom).hom
((S.F.μ (OverColor.mk c1) (OverColor.mk (c ∘ q.i.succAbove ∘ q.j.succAbove))).hom
((PiTensorProduct.tprod S.k) p ⊗ₜ[S.k] (q.contrMap.hom (PiTensorProduct.tprod S.k q')))) =
@ -431,8 +431,8 @@ lemma prod_contrMap_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
Iso.refl_hom, Action.id_hom, Iso.refl_inv, Functor.id_obj,
instMonoidalCategoryStruct_tensorObj_hom, LinearEquiv.ofLinear_apply]
have h1' : ∀ {a a' b c b' c'} (haa' : a = a')
(_ : b = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FDiscrete.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(_ : b = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom b')
(_ : c = (S.FD.map (Discrete.eqToHom (by rw [haa']))).hom c'),
(S.contr.app a).hom (b ⊗ₜ[S.k] c) = (S.contr.app a').hom (b' ⊗ₜ[S.k] c') := by
intro a a' b c b' c' haa' hbc hcc
subst haa'
@ -444,8 +444,8 @@ lemma prod_contrMap_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
simp only [Nat.add_eq, AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, equivToIso_homToEquiv,
LinearEquiv.coe_coe]
have hL (a : Fin n.succ.succ) {b : Fin n1 ⊕ Fin n.succ.succ}
(h : b = Sum.inr a) : q' a = (S.FDiscrete.map (Discrete.eqToHom (by rw [h]; simp))).hom
((lift.discreteSumEquiv S.FDiscrete b)
(h : b = Sum.inr a) : q' a = (S.FD.map (Discrete.eqToHom (by rw [h]; simp))).hom
((lift.discreteSumEquiv S.FD b)
(HepLean.PiTensorProduct.elimPureTensor p q' b)) := by
subst h
simp only [Nat.succ_eq_add_one, mk_hom, instMonoidalCategoryStruct_tensorObj_hom,
@ -457,15 +457,15 @@ lemma prod_contrMap_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
finSumFinEquiv_symm_apply_natAdd]
· simp only [Discrete.functor_obj_eq_as, Function.comp_apply, AddHom.toFun_eq_coe,
LinearMap.coe_toAddHom, equivToIso_homToEquiv]
change _ = (S.FDiscrete.map (Discrete.eqToHom _) ≫
S.FDiscrete.map (Discrete.eqToHom _)).hom _
rw [← S.FDiscrete.map_comp]
change _ = (S.FD.map (Discrete.eqToHom _) ≫
S.FD.map (Discrete.eqToHom _)).hom _
rw [← S.FD.map_comp]
simp only [Nat.add_eq, eqToHom_trans]
have h1 {a d : Fin n.succ.succ} {b : Fin n1 ⊕ Fin (n + 1 + 1) }
(h1' : b = Sum.inr a) (h2' : c a = S.τ (c d)) :
(S.FDiscrete.map (Discrete.eqToHom h2')).hom (q' a) =
(S.FDiscrete.map (eqToHom (by subst h1'; simpa using h2'))).hom
((lift.discreteSumEquiv S.FDiscrete b)
(S.FD.map (Discrete.eqToHom h2')).hom (q' a) =
(S.FD.map (eqToHom (by subst h1'; simpa using h2'))).hom
((lift.discreteSumEquiv S.FD b)
(HepLean.PiTensorProduct.elimPureTensor p q' b)) := by
subst h1'
rfl
@ -489,11 +489,11 @@ lemma prod_contrMap_tprod (p : (i : (𝟭 Type).obj (OverColor.mk c1).left) →
(l' :Fin n1 ⊕ Fin n.succ.succ)
(h : Sum.elim c1 c l' = Sum.elim c1 (c ∘ q.i.succAbove ∘ q.j.succAbove) l)
(h' : l' = (Sum.map id (q.i.succAbove ∘ q.j.succAbove) l)) :
(lift.discreteSumEquiv S.FDiscrete l)
(lift.discreteSumEquiv S.FD l)
(HepLean.PiTensorProduct.elimPureTensor p
(fun k => q' (q.i.succAbove (q.j.succAbove k))) l) =
(S.FDiscrete.map (eqToHom (by simp [h]))).hom
((lift.discreteSumEquiv S.FDiscrete l')
(S.FD.map (eqToHom (by simp [h]))).hom
((lift.discreteSumEquiv S.FD l')
(HepLean.PiTensorProduct.elimPureTensor p q' l')) := by
subst h'
match l with