| import Mathlib.LinearAlgebra.FiniteDimensional.Basic |
| import Mathlib.LinearAlgebra.Prod |
| import Mathlib.RingTheory.TensorProduct.Finite |
| import Mathlib.RingTheory.TensorProduct.Basic |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
| noncomputable section |
| open scoped TensorProduct |
| namespace LittleFinitistic.OrdinarySimulation |
| universe u |
| variable (k : Type u) [Field k] (l : ℕ) |
|
|
| / |
| Arrow i goes from i to i+1, with the manuscript's right-projective convention. -/ |
| def ChainAlgebra := (Fin (l+1) → k) × (Fin l → k) |
| namespace ChainAlgebra |
| instance : AddCommGroup (ChainAlgebra k l) := |
| inferInstanceAs (AddCommGroup ((Fin (l+1) → k) × (Fin l → k))) |
| instance : Module k (ChainAlgebra k l) := |
| inferInstanceAs (Module k ((Fin (l+1) → k) × (Fin l → k))) |
| instance : FiniteDimensional k (ChainAlgebra k l) := |
| inferInstanceAs (FiniteDimensional k ((Fin (l+1) → k) × (Fin l → k))) |
| |
| @[simp] theorem zero_eq : (0 : ChainAlgebra k l) = (0,0) := rfl |
| @[simp] theorem add_eq (x y : ChainAlgebra k l) : x+y = (x.1+y.1,x.2+y.2) := rfl |
| @[simp] theorem smul_eq (c : k) (x : ChainAlgebra k l) : c • x = (c • x.1,c • x.2) := rfl |
| |
| def diagonal (x : ChainAlgebra k l) := x.1 |
| def radical (x : ChainAlgebra k l) := x.2 |
| |
| def mul (x y : ChainAlgebra k l) : ChainAlgebra k l := |
| (fun i => x.1 i * y.1 i, |
| fun i => x.1 i.succ * y.2 i + x.2 i * y.1 i.castSucc) |
| def unit : ChainAlgebra k l := (fun _ => 1, fun _ => 0) |
| |
| instance : Ring (ChainAlgebra k l) where |
| __ := (inferInstance : AddCommGroup (ChainAlgebra k l)) |
| mul := mul k l |
| one := unit k l |
| mul_assoc x y z := by |
| change mul k l (mul k l x y) z = mul k l x (mul k l y z) |
| apply Prod.ext <;> funext i <;> simp only [mul] <;> ring |
| one_mul x := by |
| change mul k l (unit k l) x = x |
| apply Prod.ext <;> funext i <;> simp [mul, unit] |
| mul_one x := by |
| change mul k l x (unit k l) = x |
| apply Prod.ext <;> funext i <;> simp [mul, unit] |
| left_distrib x y z := by |
| change mul k l x (y+z) = mul k l x y + mul k l x z |
| rw [add_eq k l (mul k l x y) (mul k l x z), add_eq k l y z] |
| apply Prod.ext <;> funext i <;> simp only [mul, Pi.add_apply] <;> ring |
| right_distrib x y z := by |
| change mul k l (x+y) z = mul k l x z + mul k l y z |
| rw [add_eq k l (mul k l x z) (mul k l y z), add_eq k l x y] |
| apply Prod.ext <;> funext i <;> simp only [mul, Pi.add_apply] <;> ring |
| zero_mul x := by |
| change mul k l 0 x = 0 |
| apply Prod.ext <;> funext i <;> simp [mul, zero_eq] |
| mul_zero x := by |
| change mul k l x 0 = 0 |
| apply Prod.ext <;> funext i <;> simp [mul, zero_eq] |
| |
| instance : Algebra k (ChainAlgebra k l) where |
| algebraMap := |
| { toFun := fun c => (fun _ => c, fun _ => 0) |
| map_one' := rfl |
| map_mul' := by |
| intro x y |
| change ( ((fun _ => x*y), (0 : Fin l → k)) : ChainAlgebra k l) = mul k l (fun _ => x, 0) (fun _ => y, 0) |
| apply Prod.ext <;> funext i <;> simp [mul] |
| map_zero' := rfl |
| map_add' := by |
| intro x y |
| change ((fun _ => x+y), (0 : Fin l → k)) = ((fun _ => x)+(fun _ => y), (0 : Fin l → k)+(0 : Fin l → k)) |
| apply Prod.ext <;> funext i <;> simp } |
| commutes' c x := by |
| apply Prod.ext <;> funext i |
| · exact mul_comm c (x.1 i) |
| · change c * x.2 i + 0 * x.1 i.castSucc = x.1 i.succ * 0 + x.2 i * c |
| ring |
| smul_def' c x := by |
| apply Prod.ext <;> funext i |
| · rfl |
| · change c * x.2 i = c * x.2 i + 0 * x.1 i.castSucc |
| ring |
|
|
| @[simp] theorem mul_diagonal (x y : ChainAlgebra k l) (i : Fin (l+1)) : |
| (x*y).1 i = x.1 i * y.1 i := rfl |
| @[simp] theorem mul_radical (x y : ChainAlgebra k l) (i : Fin l) : |
| (x*y).2 i = x.1 i.succ * y.2 i + x.2 i * y.1 i.castSucc := rfl |
|
|
| def vertex (i : Fin (l+1)) : ChainAlgebra k l := (Pi.single i 1, 0) |
| def arrow (i : Fin l) : ChainAlgebra k l := (0, Pi.single i 1) |
|
|
| @[simp] theorem vertex_idempotent (i : Fin (l+1)) : |
| vertex k l i * vertex k l i = vertex k l i := by |
| apply Prod.ext <;> funext j |
| · change ((Pi.single i 1 : _ → k) j) * ((Pi.single i 1 : _ → k) j) = (Pi.single i 1 : _ → k) j |
| by_cases h : j = i <;> simp [h] |
| · change (mul k l (vertex k l i) (vertex k l i)).2 j = 0 |
| simp [mul, vertex] |
|
|
| @[simp] theorem arrow_mul_arrow (i j : Fin l) : |
| arrow k l i * arrow k l j = 0 := by |
| change mul k l (arrow k l i) (arrow k l j) = 0 |
| apply Prod.ext <;> funext a <;> simp [mul, arrow, zero_eq] |
|
|
| @[simp] theorem vertex_target_arrow (i : Fin l) : |
| vertex k l i.succ * arrow k l i = arrow k l i := by |
| apply Prod.ext <;> funext j |
| · change (Pi.single i.succ 1 : Fin (l+1) → k) j * 0 = 0 |
| simp |
| · change (Pi.single i.succ 1 : _ → k) j.succ * (Pi.single i 1 : _ → k) j + 0 * 0 = (Pi.single i 1 : _ → k) j |
| by_cases h : j = i <;> simp [h, Fin.succ_inj] |
|
|
| @[simp] theorem arrow_vertex_source (i : Fin l) : |
| arrow k l i * vertex k l i.castSucc = arrow k l i := by |
| apply Prod.ext <;> funext j |
| · change (0:k) * (Pi.single i.castSucc 1 : Fin (l+1) → k) j = 0 |
| simp |
| · change 0 * 0 + (Pi.single i 1 : _ → k) j * (Pi.single i.castSucc 1 : _ → k) j.castSucc = (Pi.single i 1 : _ → k) j |
| by_cases h : j = i <;> simp [h, Fin.castSucc_inj] |
|
|
| / |
| def terminalCharacter : ChainAlgebra k l →ₐ[k] k where |
| toFun x := x.1 (Fin.last l) |
| map_one' := rfl |
| map_mul' _ _ := rfl |
| map_zero' := rfl |
| map_add' _ _ := rfl |
| commutes' _ := rfl |
| end ChainAlgebra |
|
|
| variable (B : Type u) [Ring B] [Algebra k B] |
| / |
| abbrev AlgebraD := B × (B ⊗[k] ChainAlgebra k l) |
| instance finiteDimensionalD [FiniteDimensional k B] : |
| FiniteDimensional k (AlgebraD k l B) := inferInstance |
| end LittleFinitistic.OrdinarySimulation |
| |
| end |
| |
| end OAI |
| |
