| import OAI.Algebra.AuslanderReiten.Algebras.BaseAlgebra |
| import Mathlib.Algebra.Module.Projective |
| import Mathlib.Algebra.CharP.Two |
| import Mathlib.Algebra.Exact.Basic |
|
|
| namespace OAI |
|
|
| namespace ArExplicit.Resolution |
|
|
| open ArExplicit.Letter ArExplicit.BaseAlgebra |
|
|
| variable {k : Type*} [Field k] (q : k) |
|
|
| local notation "C" => BaseAlgebra k q |
|
|
| def fixedRight (p : C) : Submodule C C where |
| carrier := {a | a * p = a} |
| zero_mem' := zero_mul p |
| add_mem' {a b} ha hb := by |
| change a * p = a at ha |
| change b * p = b at hb |
| change (a + b) * p = a + b |
| rw [add_mul, ha, hb] |
| smul_mem' c a ha := by |
| change (c * a) * p = c * a |
| rw [mul_assoc, ha] |
|
|
| def rightMultiply (p : C) : C →ₗ[C] C where |
| toFun a := a * p |
| map_add' a b := add_mul a b p |
| map_smul' c a := mul_assoc c a p |
|
|
| def projection (p : C) (hp : p * p = p) : C →ₗ[C] fixedRight q p where |
| toFun a := ⟨a * p, by change (a * p) * p = a * p; rw [mul_assoc, hp]⟩ |
| map_add' a b := Subtype.ext (add_mul a b p) |
| map_smul' c a := Subtype.ext (mul_assoc c a p) |
|
|
| theorem projection_surjective (p : C) (hp : p * p = p) : |
| Function.Surjective (projection q p hp) := by |
| intro a |
| exact ⟨a, Subtype.ext a.property⟩ |
|
|
| theorem projective_fixedRight (p : C) (hp : p * p = p) : |
| Module.Projective C (fixedRight q p) := by |
| apply Module.Projective.of_split (fixedRight q p).subtype (projection q p hp) |
| apply LinearMap.ext |
| intro a |
| exact Subtype.ext a.property |
|
|
| theorem finite_fixedRight (p : C) (hp : p * p = p) : |
| Module.Finite k (fixedRight q p) := |
| Module.Finite.of_surjective ((projection q p hp).restrictScalars k) |
| (projection_surjective q p hp) |
|
|
| abbrev E : Submodule C C := fixedRight q (basisVector q e) |
|
|
| abbrev F : Submodule C C := fixedRight q (basisVector q f) |
|
|
| instance : Module.Projective C (E q) := |
| projective_fixedRight q _ (by simpa [multiplicationTable] using basis_mul q e e) |
| instance : Module.Projective C (F q) := |
| projective_fixedRight q _ (by simpa [multiplicationTable] using basis_mul q f f) |
|
|
| instance : Module.Finite k (E q) := |
| finite_fixedRight q _ (by simpa [multiplicationTable] using basis_mul q e e) |
| instance : Module.Finite k (F q) := |
| finite_fixedRight q _ (by simpa [multiplicationTable] using basis_mul q f f) |
|
|
| def rightBetween (p r z : C) (hz : z * r = z) : |
| fixedRight q p →ₗ[C] fixedRight q r where |
| toFun a := ⟨(a : C) * z, by change ((a : C) * z) * r = (a : C) * z; rw [mul_assoc, hz]⟩ |
| map_add' a b := Subtype.ext (add_mul (a : C) (b : C) z) |
| map_smul' c a := Subtype.ext (mul_assoc c (a : C) z) |
|
|
| def ell (r : k) : C := basisVector q x + r • basisVector q y |
|
|
| @[simp] theorem ell_right_e (r : k) : ell q r * basisVector q e = ell q r := by |
| simp [ell, add_mul, basis_mul, multiplicationTable] |
|
|
| def dU : E q →ₗ[C] F q := |
| rightBetween q _ _ (basisVector q u) |
| (by simpa [multiplicationTable] using basis_mul q u f) |
|
|
| def dEll (r : k) : E q →ₗ[C] E q := rightBetween q _ _ (ell q r) (ell_right_e q r) |
|
|
| @[simp] theorem coe_dU (a : E q) : (dU q a : C) = (a : C) * basisVector q u := rfl |
| @[simp] theorem coe_dEll (r : k) (a : E q) : (dEll q r a : C) = (a : C) * ell q r := rfl |
|
|
| private theorem E_coeff_zero (a : E q) (i : Letter) |
| (hi : i = u ∨ i = v ∨ i = f ∨ i = n) : (a : C).coeff i = 0 := by |
| have h := congrArg (fun b : C => b.coeff i) a.property |
| rcases hi with rfl | rfl | rfl | rfl <;> simpa [product] using h.symm |
|
|
| @[simp] theorem E_coeff_u (a : E q) : (a : C).coeff u = 0 := E_coeff_zero q a u (by simp) |
| @[simp] theorem E_coeff_v (a : E q) : (a : C).coeff v = 0 := E_coeff_zero q a v (by simp) |
| @[simp] theorem E_coeff_f (a : E q) : (a : C).coeff f = 0 := E_coeff_zero q a f (by simp) |
| @[simp] theorem E_coeff_n (a : E q) : (a : C).coeff n = 0 := E_coeff_zero q a n (by simp) |
|
|
| theorem E_expand (a : E q) : (a : C) = |
| (a : C).coeff e • basisVector q e + (a : C).coeff x • basisVector q x + |
| (a : C).coeff y • basisVector q y + (a : C).coeff z • basisVector q z + |
| (a : C).coeff t • basisVector q t + (a : C).coeff j • basisVector q j := by |
| ext i |
| cases i <;> simp |
|
|
| theorem mul_u_formula (a : E q) : (a : C) * basisVector q u = |
| (a : C).coeff e • basisVector q u + |
| ((a : C).coeff x + (a : C).coeff y) • basisVector q v + |
| ((1 + q) * (a : C).coeff t) • basisVector q n := by |
| ext i |
| cases i <;> simp [product] |
|
|
| theorem mul_ell_formula (r : k) (a : E q) : (a : C) * ell q r = |
| (a : C).coeff e • ell q r + |
| (q * r * (a : C).coeff x + (a : C).coeff y) • basisVector q z + |
| ((1 + q ^ 2 * r) * (a : C).coeff t) • basisVector q j := by |
| ext i |
| cases i <;> simp [product, ell] <;> ring |
|
|
| section CharacteristicTwo |
|
|
| variable [CharP k 2] |
|
|
| theorem mul_u_eq_zero_iff (hq : 1 + q ≠ 0) (a : E q) : |
| (a : C) * basisVector q u = 0 ↔ |
| (a : C).coeff e = 0 ∧ (a : C).coeff t = 0 ∧ (a : C).coeff y = (a : C).coeff x := by |
| rw [mul_u_formula] |
| constructor |
| · intro h |
| have he := congrArg (fun b : C => b.coeff u) h |
| have ht := congrArg (fun b : C => b.coeff n) h |
| have hy := congrArg (fun b : C => b.coeff v) h |
| simp only [coeff_add, coeff_smul, coeff_basisVector, coeff_zero] at he ht hy |
| simp only [reduceCtorEq, ↓reduceIte, mul_zero, mul_one, add_zero, zero_add] at he ht hy |
| exact ⟨he, (mul_eq_zero.mp ht).resolve_left hq, (CharTwo.add_eq_zero.mp hy).symm⟩ |
| · rintro ⟨he, ht, hy⟩ |
| simp [he, ht, hy, CharTwo.add_self_eq_zero] |
|
|
| theorem mul_ell_eq_zero_iff (r : k) (hr : 1 + q ^ 2 * r ≠ 0) (a : E q) : |
| (a : C) * ell q r = 0 ↔ |
| (a : C).coeff e = 0 ∧ (a : C).coeff t = 0 ∧ |
| (a : C).coeff y = q * r * (a : C).coeff x := by |
| rw [mul_ell_formula] |
| constructor |
| · intro h |
| have he := congrArg (fun b : C => b.coeff x) h |
| have ht := congrArg (fun b : C => b.coeff j) h |
| have hy := congrArg (fun b : C => b.coeff z) h |
| simp [ell] at he ht hy |
| exact ⟨he, ht.resolve_left hr, (CharTwo.add_eq_zero.mp hy).symm⟩ |
| · rintro ⟨he, ht, hy⟩ |
| simp [he, ht, hy, CharTwo.add_self_eq_zero] |
|
|
| end CharacteristicTwo |
|
|
| def ellPreimage (r α β γ : k) : E q := |
| ⟨α • basisVector q e + β • basisVector q y + (γ / (1 + q ^ 2 * r)) • basisVector q t, by |
| change (_ : C) * basisVector q e = _ |
| simp [add_mul, basis_mul, multiplicationTable]⟩ |
|
|
| theorem ellPreimage_spec (r α β γ : k) (hr : 1 + q ^ 2 * r ≠ 0) : |
| (ellPreimage q r α β γ : C) * ell q r = |
| α • ell q r + β • basisVector q z + γ • basisVector q j := by |
| rw [mul_ell_formula] |
| have hγ : (1 + q ^ 2 * r) * (γ / (1 + q ^ 2 * r)) = γ := by |
| rw [mul_comm, div_mul_cancel₀ γ hr] |
| simp [ellPreimage, hγ] |
|
|
| section Exactness |
|
|
| variable [CharP k 2] |
|
|
| theorem uKernel_expand (hq : 1 + q ≠ 0) (a : E q) |
| (ha : (a : C) * basisVector q u = 0) : |
| (a : C) = (a : C).coeff x • ell q 1 + |
| (a : C).coeff z • basisVector q z + (a : C).coeff j • basisVector q j := by |
| obtain ⟨he, ht, hy⟩ := (mul_u_eq_zero_iff q hq a).mp ha |
| ext i |
| cases i <;> simp [ell, he, ht, hy] |
|
|
| theorem ellKernel_expand (r : k) (hr : 1 + q ^ 2 * r ≠ 0) (a : E q) |
| (ha : (a : C) * ell q r = 0) : |
| (a : C) = (a : C).coeff x • ell q (q * r) + |
| (a : C).coeff z • basisVector q z + (a : C).coeff j • basisVector q j := by |
| obtain ⟨he, ht, hy⟩ := (mul_ell_eq_zero_iff q r hr a).mp ha |
| ext i |
| cases i <;> simp [ell, he, ht, hy] |
| ring |
|
|
| @[simp] theorem ell_one_mul_u : ell q 1 * basisVector q u = 0 := by |
| ext i |
| cases i <;> simp [ell, product, CharTwo.add_self_eq_zero] |
|
|
| @[simp] theorem ell_successor_mul (r : k) : ell q (q * r) * ell q r = 0 := by |
| ext i |
| cases i <;> simp [ell, product, CharTwo.add_self_eq_zero] |
|
|
| theorem dU_comp_dEll_one : (dU q).comp (dEll q 1) = 0 := by |
| apply LinearMap.ext |
| intro a |
| apply Subtype.ext |
| change ((a : C) * ell q 1) * basisVector q u = 0 |
| rw [mul_assoc, ell_one_mul_u, mul_zero] |
|
|
| theorem dEll_comp_successor (r : k) : (dEll q r).comp (dEll q (q * r)) = 0 := by |
| apply LinearMap.ext |
| intro a |
| apply Subtype.ext |
| change ((a : C) * ell q (q * r)) * ell q r = 0 |
| rw [mul_assoc, ell_successor_mul, mul_zero] |
|
|
| theorem exact_dU (hq : 1 + q ≠ 0) (hq2 : 1 + q ^ 2 ≠ 0) : |
| Function.Exact (dEll q 1) (dU q) := by |
| intro a |
| constructor |
| · intro ha |
| have ha' : (a : C) * basisVector q u = 0 := congrArg Subtype.val ha |
| refine ⟨ellPreimage q 1 ((a : C).coeff x) ((a : C).coeff z) ((a : C).coeff j), ?_⟩ |
| apply Subtype.ext |
| change (_ : C) * ell q 1 = (a : C) |
| rw [ellPreimage_spec q 1 _ _ _ (by simpa using hq2)] |
| exact (uKernel_expand q hq a ha').symm |
| · rintro ⟨b, rfl⟩ |
| exact DFunLike.congr_fun (dU_comp_dEll_one q) b |
|
|
| theorem exact_dEll (r : k) (hr : 1 + q ^ 2 * r ≠ 0) |
| (hnext : 1 + q ^ 2 * (q * r) ≠ 0) : |
| Function.Exact (dEll q (q * r)) (dEll q r) := by |
| intro a |
| constructor |
| · intro ha |
| have ha' : (a : C) * ell q r = 0 := congrArg Subtype.val ha |
| refine ⟨ellPreimage q (q * r) ((a : C).coeff x) ((a : C).coeff z) ((a : C).coeff j), ?_⟩ |
| apply Subtype.ext |
| change (_ : C) * ell q (q * r) = (a : C) |
| rw [ellPreimage_spec q (q * r) _ _ _ hnext] |
| exact (ellKernel_expand q r hr a ha').symm |
| · rintro ⟨b, rfl⟩ |
| exact DFunLike.congr_fun (dEll_comp_successor q r) b |
|
|
| end Exactness |
|
|
| end ArExplicit.Resolution |
|
|
| end OAI |
|
|
