refactor: Lint

HepLean.lean

@@ -125,6 +125,10 @@ import HepLean.Tensors.OverColor.Functors
 import HepLean.Tensors.OverColor.Iso
 import HepLean.Tensors.OverColor.Lift
 import HepLean.Tensors.TensorSpecies.Basic
+import HepLean.Tensors.TensorSpecies.ContractLemmas
+import HepLean.Tensors.TensorSpecies.MetricTensor
+import HepLean.Tensors.TensorSpecies.RepIso
+import HepLean.Tensors.TensorSpecies.UnitTensor
 import HepLean.Tensors.Tree.Basic
 import HepLean.Tensors.Tree.Dot
 import HepLean.Tensors.Tree.Elab

HepLean/Mathematics/Fin.lean

@@ -281,12 +281,12 @@ def finExtractOnePerm (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ
 
 @[simp]
 lemma finExtractOnePerm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ)
-    (x : Fin n.succ) :  finExtractOnePerm i σ x = predAboveI (σ i)
+    (x : Fin n.succ) : finExtractOnePerm i σ x = predAboveI (σ i)
     (σ ((finExtractOne i).symm (Sum.inr x))) := rfl
 
 @[simp]
 lemma finExtractOnePerm_symm_apply (i : Fin n.succ.succ) (σ : Fin n.succ.succ ≃ Fin n.succ.succ)
-    (x : Fin n.succ) :  (finExtractOnePerm i σ).symm x = predAboveI (σ.symm (σ i))
+    (x : Fin n.succ) : (finExtractOnePerm i σ).symm x = predAboveI (σ.symm (σ i))
     (σ.symm ((finExtractOne (σ i)).symm (Sum.inr x))) := rfl
 
 /-- The equivalence of types `Fin n.succ.succ ≃ (Fin 1 ⊕ Fin 1) ⊕ Fin n` extracting

HepLean/Tensors/OverColor/Basic.lean

@@ -296,12 +296,12 @@ lemma β_inv_toEquiv (f : X → C) (g : Y → C) :
   rfl
 
 @[simp]
-lemma whiskeringLeft_toEquiv (f : X → C) (g : Y → C) (h : Z → C) (σ : OverColor.mk f ⟶  OverColor.mk g) :
+lemma whiskeringLeft_toEquiv (f : X → C) (g : Y → C) (h : Z → C)
+    (σ : OverColor.mk f ⟶ OverColor.mk g) :
     Hom.toEquiv (OverColor.mk h ◁ σ) = (Equiv.refl Z).sumCongr (Hom.toEquiv σ) := by
   simp [MonoidalCategory.whiskerLeft]
   rfl
 
-
 end OverColor
 
 end IndexNotation

HepLean/Tensors/OverColor/Discrete.lean

@@ -117,10 +117,10 @@ lemma pairIsoSep_inv_tprod {c1 c2 : C} (fx : (i : (𝟭 Type).obj (OverColor.mk
   simp [pairIsoSep]
   erw [lift.map_tprod]
   erw [lift.μIso_inv_tprod]
-  change (((forgetLiftApp F c1).hom.hom  (((lift.obj F).map (mkIso _).inv).hom
+  change (((forgetLiftApp F c1).hom.hom (((lift.obj F).map (mkIso _).inv).hom
     ((PiTensorProduct.tprod k) fun i =>
     (lift.discreteFunctorMapEqIso F _) (fx ((Hom.toEquiv fin2Iso.hom).symm (Sum.inl i)))))) ⊗ₜ[k]
-    (forgetLiftApp F c2).hom.hom ( ((lift.obj F).map (mkIso _).inv).hom ((PiTensorProduct.tprod k)
+    (forgetLiftApp F c2).hom.hom (((lift.obj F).map (mkIso _).inv).hom ((PiTensorProduct.tprod k)
     fun i =>
     (lift.discreteFunctorMapEqIso F _) (fx ((Hom.toEquiv fin2Iso.hom).symm (Sum.inr i)))))) = _
   congr 1
@@ -152,25 +152,30 @@ lemma pairIsoSep_inv_tprod {c1 c2 : C} (fx : (i : (𝟭 Type).obj (OverColor.mk
 open HepLean.Fin
 
 /-! TODO: Find a better place for this. -/
-lemma pairIsoSep_β_perm_cond (c1 c2 : C) :  ∀ (x : Fin (Nat.succ 0).succ), ![c2, c1] x =
-   (![c1, c2] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x:= by
+lemma pairIsoSep_β_perm_cond (c1 c2 : C) : ∀ (x : Fin (Nat.succ 0).succ), ![c2, c1] x =
+    (![c1, c2] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x:= by
   intro x
   fin_cases x
   · rfl
   · rfl
 
-lemma pairIsoSep_β {c1 c2 : C} (x : ↑(F.obj { as := c1 } ⊗ F.obj { as := c2 }).V ) :
+lemma pairIsoSep_β {c1 c2 : C} (x : ↑(F.obj { as := c1 } ⊗ F.obj { as := c2 }).V) :
     (Discrete.pairIsoSep F).hom.hom ((β_ (F.obj (Discrete.mk c1)) _).hom.hom x) =
-    ((lift.obj F).map ((OverColor.equivToHomEq (finMapToEquiv ![1, 0] ![1, 0]) (pairIsoSep_β_perm_cond c1 c2)))).hom
+    ((lift.obj F).map ((OverColor.equivToHomEq (finMapToEquiv ![1, 0] ![1, 0])
+    (pairIsoSep_β_perm_cond c1 c2)))).hom
     ((Discrete.pairIsoSep F).hom.hom x) := by
-  have h1 : (Discrete.pairIsoSep F).hom.hom ∘ₗ (β_ (F.obj (Discrete.mk c1)) (F.obj (Discrete.mk c2))).hom.hom
-    = ((lift.obj F).map ((OverColor.equivToHomEq (finMapToEquiv ![1, 0] ![1, 0]) (pairIsoSep_β_perm_cond c1 c2)))).hom ∘ₗ (Discrete.pairIsoSep F).hom.hom := by
+  have h1 : (Discrete.pairIsoSep F).hom.hom ∘ₗ
+      (β_ (F.obj (Discrete.mk c1)) (F.obj (Discrete.mk c2))).hom.hom
+      = ((lift.obj F).map ((OverColor.equivToHomEq
+      (finMapToEquiv ![1, 0] ![1, 0]) (pairIsoSep_β_perm_cond c1 c2)))).hom ∘ₗ
+      (Discrete.pairIsoSep F).hom.hom := by
     apply TensorProduct.ext'
     intro x y
     simp only [Nat.succ_eq_add_one, Nat.reduceAdd, Equivalence.symm_inverse,
       Action.functorCategoryEquivalence_functor, Action.FunctorCategoryEquivalence.functor_obj_obj,
       Action.instMonoidalCategory_tensorObj_V, LinearMap.coe_comp, Function.comp_apply, Fin.isValue]
-    change (Discrete.pairIsoSep F).hom.hom (y ⊗ₜ x) =  ((lift.obj F).map ((OverColor.equivToHomEq (_) (pairIsoSep_β_perm_cond c1 c2)))).hom
+    change (Discrete.pairIsoSep F).hom.hom (y ⊗ₜ x) = ((lift.obj F).map
+      ((OverColor.equivToHomEq _ (pairIsoSep_β_perm_cond c1 c2)))).hom
       ((Discrete.pairIsoSep F).hom.hom (x ⊗ₜ y))
     rw [Discrete.pairIsoSep_tmul, Discrete.pairIsoSep_tmul]
     erw [OverColor.lift.map_tprod]
@@ -181,8 +186,7 @@ lemma pairIsoSep_β {c1 c2 : C} (x : ↑(F.obj { as := c1 } ⊗ F.obj { as := c2
       rfl
     · simp [lift.discreteFunctorMapEqIso]
       rfl
-  exact congrFun (congrArg (fun f => f.toFun) h1)  _
-
+  exact congrFun (congrArg (fun f => f.toFun) h1) _
 
 /-- The isomorphism between
   `F.obj (Discrete.mk c1) ⊗ F.obj (Discrete.mk c2) ⊗ F.obj (Discrete.mk c3)` and

HepLean/Tensors/OverColor/Iso.lean

@@ -71,7 +71,7 @@ lemma mkIso_refl_hom {c : X → C} : (mkIso (by rfl : c =c)).hom = 𝟙 _ := by
   rfl
 
 lemma mkIso_hom_hom_left {c1 c2 : X → C} (h : c1 = c2) : (mkIso h).hom.hom.left =
-    (Equiv.refl X).toFun  := by
+    (Equiv.refl X).toFun := by
   rw [mkIso]
   rfl
 
@@ -104,8 +104,8 @@ lemma equivToHomEq_hom_left {c : X → C} {c1 : Y → C} (e : X ≃ Y)
   rfl
 
 @[simp]
-lemma equivToHomEq_toEquiv  {c : X → C} {c1 : Y → C} (e : X ≃ Y)
-    (h : ∀ x, c1 x = (c ∘ e.symm) x := by decide)  : Hom.toEquiv (equivToHomEq e h) = e := by
+lemma equivToHomEq_toEquiv {c : X → C} {c1 : Y → C} (e : X ≃ Y)
+    (h : ∀ x, c1 x = (c ∘ e.symm) x := by decide) : Hom.toEquiv (equivToHomEq e h) = e := by
     rfl
 
 /-- The isomorphism splitting a `mk c` for `Fin 2 → C` into the tensor product of
@@ -193,7 +193,8 @@ def extractTwo {n : ℕ} (i : Fin n.succ.succ) (j : Fin n.succ)
 @[simp]
 lemma extractTwo_hom_left_apply {n : ℕ} (i : Fin n.succ.succ.succ) (j : Fin n.succ.succ)
     {c1 c2 : Fin n.succ.succ.succ → C} (σ : mk c1 ⟶ mk c2) (x : Fin n.succ) :
-    (extractTwo i j σ).hom.left x = (finExtractOnePerm ((finExtractOnePerm ((Hom.toEquiv σ).symm i) (Hom.toEquiv σ)).symm j)
+    (extractTwo i j σ).hom.left x =
+      (finExtractOnePerm ((finExtractOnePerm ((Hom.toEquiv σ).symm i) (Hom.toEquiv σ)).symm j)
       (finExtractOnePerm ((Hom.toEquiv σ).symm i) (Hom.toEquiv σ))) x := by
   simp only [extractTwo, extractOne]
   rfl

HepLean/Tensors/TensorSpecies/ContractLemmas.lean

@@ -34,7 +34,7 @@ lemma contr_two_two_inner_tprod (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
       CoeSort.coe (S.FD.obj { as := (OverColor.mk ![S.τ c, S.τ c]).hom i }))
     (hx : x = PiTensorProduct.tprod S.k fx)
     (hy : y = PiTensorProduct.tprod S.k fy) :
-    {x | μ ν ⊗ y| ν ρ}ᵀ.tensor =  (S.F.map (OverColor.mkIso (by
+    {x | μ ν ⊗ y| ν ρ}ᵀ.tensor = (S.F.map (OverColor.mkIso (by
       funext x
       fin_cases x <;> rfl)).hom).hom ((OverColor.Discrete.pairIsoSep S.FD).hom.hom
     (((S.FD.obj (Discrete.mk c)) ◁ (λ_ (S.FD.obj (Discrete.mk (S.τ c)))).hom).hom
@@ -45,13 +45,14 @@ lemma contr_two_two_inner_tprod (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
     ((α_ (S.FD.obj (Discrete.mk (c))) (S.FD.obj (Discrete.mk (c)))
       (S.FD.obj (Discrete.mk (S.τ c)) ⊗ S.FD.obj (Discrete.mk (S.τ c)))).hom.hom
     (((OverColor.Discrete.pairIsoSep S.FD).inv.hom x ⊗ₜ
-    (OverColor.Discrete.pairIsoSep S.FD).inv.hom y))))))):= by
+    (OverColor.Discrete.pairIsoSep S.FD).inv.hom y))))))) := by
   subst hx
   subst hy
   rw [Discrete.pairIsoSep_inv_tprod S.FD fx, Discrete.pairIsoSep_inv_tprod S.FD fy]
   change _ = (S.F.map (OverColor.mkIso _).hom).hom ((OverColor.Discrete.pairIsoSep S.FD).hom.hom
-    ((fx (0 : Fin 2) ⊗ₜ[S.k]  (λ_ (S.FD.obj { as := S.τ c }).V).hom
-      ((S.contr.app { as := c }).hom (fx (1 : Fin 2) ⊗ₜ[S.k] fy (0 : Fin 2)) ⊗ₜ[S.k] fy (1 : Fin 2)))))
+    ((fx (0 : Fin 2) ⊗ₜ[S.k] (λ_ (S.FD.obj { as := S.τ c }).V).hom
+      ((S.contr.app { as := c }).hom (fx (1 : Fin 2)
+      ⊗ₜ[S.k] fy (0 : Fin 2)) ⊗ₜ[S.k] fy (1 : Fin 2)))))
   simp only [F_def, Functor.id_obj, mk_hom, Action.instMonoidalCategory_tensorObj_V,
     Equivalence.symm_inverse, Action.functorCategoryEquivalence_functor,
     Action.FunctorCategoryEquivalence.functor_obj_obj, Monoidal.tensorUnit_obj,
@@ -86,7 +87,7 @@ lemma contr_two_two_inner_tprod (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
       Functor.id_obj, instMonoidalCategoryStruct_tensorObj_hom, LinearEquiv.ofLinear_apply]
       rfl
   /- The tensor. -/
-  · rw (config := { transparency := .instances })  [Discrete.pairIsoSep_tmul,
+  · rw (config := { transparency := .instances }) [Discrete.pairIsoSep_tmul,
       OverColor.lift.map_tprod]
     apply congrArg
     funext k
@@ -97,7 +98,7 @@ lemma contr_two_two_inner_tprod (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
 /-- Expands the inner contraction of two 2-tensors in terms of basic categorical
   constructions and fields of the tensor species. -/
 lemma contr_two_two_inner (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
-    (y : S.F.obj (OverColor.mk ![(S.τ c), (S.τ c)])):
+    (y : S.F.obj (OverColor.mk ![(S.τ c), (S.τ c)])) :
     {x | μ ν ⊗ y| ν ρ}ᵀ.tensor = (S.F.map (OverColor.mkIso (by
       funext x
       fin_cases x <;> rfl)).hom).hom ((OverColor.Discrete.pairIsoSep S.FD).hom.hom
@@ -109,7 +110,7 @@ lemma contr_two_two_inner (c : S.C) (x : S.F.obj (OverColor.mk ![c, c]))
     ((α_ (S.FD.obj (Discrete.mk (c))) (S.FD.obj (Discrete.mk (c)))
       (S.FD.obj (Discrete.mk (S.τ c)) ⊗ S.FD.obj (Discrete.mk (S.τ c)))).hom.hom
     (((OverColor.Discrete.pairIsoSep S.FD).inv.hom x ⊗ₜ
-    (OverColor.Discrete.pairIsoSep S.FD).inv.hom y))))))):= by
+    (OverColor.Discrete.pairIsoSep S.FD).inv.hom y))))))) := by
   simp only [Nat.reduceAdd, Fin.isValue, contr_tensor, prod_tensor, Functor.id_obj, mk_hom,
     Action.instMonoidalCategory_tensorObj_V, Equivalence.symm_inverse,
     Action.functorCategoryEquivalence_functor, Action.FunctorCategoryEquivalence.functor_obj_obj,

HepLean/Tensors/TensorSpecies/MetricTensor.lean

@@ -33,22 +33,22 @@ def metricTensor (S : TensorSpecies) (c : S.C) : S.F.obj (OverColor.mk ![c, c])
 variable {S : TensorSpecies}
 
 lemma metricTensor_congr {c c' : S.C} (h : c = c') : {S.metricTensor c | μ ν}ᵀ.tensor =
-    (perm  (OverColor.equivToHomEq (Equiv.refl _) (fun x => by subst h; fin_cases x <;> rfl ))
+    (perm (OverColor.equivToHomEq (Equiv.refl _) (fun x => by subst h; fin_cases x <;> rfl))
     {S.metricTensor c' | μ ν}ᵀ).tensor := by
   subst h
   change _ = (S.F.map (𝟙 _)).hom (S.metricTensor c)
   simp
 
-
 lemma pairIsoSep_inv_metricTensor (c : S.C) :
     (Discrete.pairIsoSep S.FD).inv.hom (S.metricTensor c) =
     (S.metric.app (Discrete.mk c)).hom (1 : S.k) := by
-  simp [metricTensor]
+  simp only [Action.instMonoidalCategory_tensorObj_V, Nat.succ_eq_add_one, Nat.reduceAdd,
+    metricTensor, Monoidal.tensorUnit_obj, Action.instMonoidalCategory_tensorUnit_V]
   erw [Discrete.rep_iso_inv_hom_apply]
 
 /-- Contraction of a metric tensor with a metric tensor gives the unit.
   Like `S.contr_metric` but with the braiding appearing on the side of the unit. -/
-lemma contr_metric_braid_unit (c : S.C) :  (((S.FD.obj (Discrete.mk c)) ◁
+lemma contr_metric_braid_unit (c : S.C) : (((S.FD.obj (Discrete.mk c)) ◁
     (λ_ (S.FD.obj (Discrete.mk (S.τ c)))).hom).hom
     (((S.FD.obj (Discrete.mk c)) ◁ ((S.contr.app (Discrete.mk c)) ▷
     (S.FD.obj (Discrete.mk (S.τ c))))).hom
@@ -63,12 +63,13 @@ lemma contr_metric_braid_unit (c : S.C) :  (((S.FD.obj (Discrete.mk c)) ◁
   apply (β_ _ _).toLinearEquiv.toEquiv.injective
   rw [pairIsoSep_inv_metricTensor, pairIsoSep_inv_metricTensor]
   erw [S.contr_metric c]
-  change  _ = (β_  (S.FD.obj { as := S.τ c }) (S.FD.obj { as := c })).inv.hom
+  change _ = (β_ (S.FD.obj { as := S.τ c }) (S.FD.obj { as := c })).inv.hom
     ((β_ (S.FD.obj { as := S.τ c }) (S.FD.obj { as := c })).hom.hom _)
   rw [Discrete.rep_iso_inv_hom_apply]
 
 lemma metricTensor_contr_dual_metricTensor_perm_cond (c : S.C) : ∀ (x : Fin (Nat.succ 0).succ),
-    ((Sum.elim ![c, c] ![S.τ c, S.τ c] ∘ ⇑finSumFinEquiv.symm) ∘ Fin.succAbove 1 ∘ Fin.succAbove 1) x =
+    ((Sum.elim ![c, c] ![S.τ c, S.τ c] ∘ ⇑finSumFinEquiv.symm) ∘
+    Fin.succAbove 1 ∘ Fin.succAbove 1) x =
     (![S.τ c, c] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x := by
   intro x
   fin_cases x
@@ -81,12 +82,12 @@ lemma metricTensor_contr_dual_metricTensor_eq_unit (c : S.C) :
     perm (OverColor.equivToHomEq (finMapToEquiv ![1, 0] ![1, 0])
       (metricTensor_contr_dual_metricTensor_perm_cond c))).tensor := by
   rw [contr_two_two_inner, contr_metric_braid_unit, Discrete.pairIsoSep_β]
-  change (S.F.map _ ≫ S.F.map _ ).hom _ = _
+  change (S.F.map _ ≫ S.F.map _).hom _ = _
   rw [← S.F.map_comp]
   rfl
 
 /-- The contraction of a metric tensor with its dual via the outer indices gives the unit. -/
-lemma metricTensor_contr_dual_metricTensor_outer_eq_unit  (c : S.C) :
+lemma metricTensor_contr_dual_metricTensor_outer_eq_unit (c : S.C) :
     {S.metricTensor c | ν μ ⊗ S.metricTensor (S.τ c) | ρ ν}ᵀ.tensor = ({S.unitTensor c | μ ρ}ᵀ |>
     perm (OverColor.equivToHomEq
       (finMapToEquiv ![1, 0] ![1, 0]) (fun x => by fin_cases x <;> rfl))).tensor := by

HepLean/Tensors/TensorSpecies/UnitTensor.lean

@@ -31,21 +31,21 @@ open TensorTree
 
 /-- The relation between two units of colors which are equal. -/
 lemma unitTensor_congr {c c' : S.C} (h : c = c') : {S.unitTensor c | μ ν}ᵀ.tensor =
-    (perm  (OverColor.equivToHomEq (Equiv.refl _) (fun x => by subst h; fin_cases x <;> rfl ))
+    (perm (OverColor.equivToHomEq (Equiv.refl _) (fun x => by subst h; fin_cases x <;> rfl))
     {S.unitTensor c' | μ ν}ᵀ).tensor := by
   subst h
   change _ = (S.F.map (𝟙 _)).hom (S.unitTensor c)
   simp
 
 lemma unitTensor_eq_dual_perm_eq (c : S.C) : ∀ (x : Fin (Nat.succ 0).succ),
-   ![S.τ c, c] x = (![S.τ (S.τ c), S.τ c] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x := fun x => by
+    ![S.τ c, c] x = (![S.τ (S.τ c), S.τ c] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x := fun x => by
   fin_cases x
   · rfl
   · exact (S.τ_involution c).symm
 
 /-- The unit tensor is equal to a permutation of indices of the dual tensor. -/
 lemma unitTensor_eq_dual_perm (c : S.C) : {S.unitTensor c | μ ν}ᵀ.tensor =
-    (perm  (OverColor.equivToHomEq (finMapToEquiv ![1,0] ![1, 0]) (unitTensor_eq_dual_perm_eq c))
+    (perm (OverColor.equivToHomEq (finMapToEquiv ![1,0] ![1, 0]) (unitTensor_eq_dual_perm_eq c))
     {S.unitTensor (S.τ c) | ν μ }ᵀ).tensor := by
   simp [unitTensor, tensorNode_tensor, perm_tensor]
   have h1 := S.unit_symm c
@@ -85,7 +85,7 @@ lemma unitTensor_eq_dual_perm (c : S.C) : {S.unitTensor c | μ ν}ᵀ.tensor =
       Nat.succ_eq_add_one, Nat.reduceAdd, lift.discreteFunctorMapEqIso, Functor.mapIso_hom,
       eqToIso.hom, Functor.mapIso_inv, eqToIso.inv, LinearEquiv.ofLinear_apply]
       rfl
-  exact congrFun (congrArg (fun f => f.toFun) hg)  _
+  exact congrFun (congrArg (fun f => f.toFun) hg) _
 
 lemma dual_unitTensor_eq_perm_eq (c : S.C) : ∀ (x : Fin (Nat.succ 0).succ),
     ![S.τ (S.τ c), S.τ c] x = (![S.τ c, c] ∘ ⇑(finMapToEquiv ![1, 0] ![1, 0]).symm) x := fun x => by

HepLean/Tensors/Tree/NodeIdentities/PermProd.lean

@@ -36,8 +36,8 @@ def permProdRight := (equivToIso finSumFinEquiv).inv ≫ OverColor.mk c2 ◁ σ
   ≫ (equivToIso finSumFinEquiv).hom
 
 @[simp]
-lemma permProdRight_toEquiv : Hom.toEquiv (permProdRight c2 σ) =  finSumFinEquiv.symm.trans
-    (((Equiv.refl (Fin n2)).sumCongr (Hom.toEquiv σ)).trans finSumFinEquiv)  := by
+lemma permProdRight_toEquiv : Hom.toEquiv (permProdRight c2 σ) = finSumFinEquiv.symm.trans
+    (((Equiv.refl (Fin n2)).sumCongr (Hom.toEquiv σ)).trans finSumFinEquiv) := by
   simp [permProdRight]
 
 /-- When a `prod` acts on a `perm` node in the left entry, the `perm` node can be moved through