| import Mathlib |
| import OAI.Algebra.FrobeniusObstruction.MixedForms |
| import OAI.Algebra.FrobeniusObstruction.ExteriorSplit |
| import OAI.Algebra.FrobeniusObstruction.Derivations |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace BoundaryOnly.FormalObstruction.FormsSplit |
| open scoped TensorProduct |
| open Frobenius MixedForms |
| variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] |
| [CommRing k] (ell : ℕ) |
|
|
| abbrev QForms (ι : Type*) [Fintype ι] [DecidableEq ι] := |
| MixedForms.Forms (k := k) (A := Frobenius.Ring (ι := ι) (k := k) ell) (ι := ι) |
|
|
| noncomputable def includeLeft : QForms (k := k) ell ι →ₐ[k] QForms (k := k) ell (ι ⊕ κ) := |
| Algebra.TensorProduct.map (includeVariables ell Sum.inl) |
| (ExteriorAlgebra.map ExteriorSplit.leftVec) |
| noncomputable def includeRight : QForms (k := k) ell κ →ₐ[k] QForms (k := k) ell (ι ⊕ κ) := |
| Algebra.TensorProduct.map (includeVariables ell Sum.inr) |
| (ExteriorAlgebra.map ExteriorSplit.rightVec) |
|
|
| |
| |
| noncomputable def sumEquiv : QForms (k := k) ell (ι ⊕ κ) ≃ₗ[k] |
| QForms (k := k) ell ι ⊗[k] QForms (k := k) ell κ := |
| (TensorProduct.congr (Frobenius.sumEquiv (k := k) (ι := ι) (κ := κ) ell).toLinearEquiv |
| (ExteriorSplit.sumEquiv (k := k) (ι := ι) (κ := κ))).trans |
| (TensorProduct.tensorTensorTensorComm k _ _ _ _) |
|
|
| @[simp] theorem sumEquiv_symm_tmul (x : QForms (k := k) ell ι) |
| (y : QForms (k := k) ell κ) : |
| (sumEquiv (k := k) (ι := ι) (κ := κ) ell).symm (x ⊗ₜ[k] y) = |
| includeLeft ell x * includeRight ell y := by |
| induction x using TensorProduct.inductionOn with |
| | add x x' hx hx' => simp only [TensorProduct.add_tmul, map_add, add_mul, hx, hx'] |
| | tmul a e => |
| induction y using TensorProduct.inductionOn with |
| | add y y' hy hy' => simp only [TensorProduct.tmul_add, map_add, mul_add, hy, hy'] |
| | tmul b f => |
| change (TensorProduct.congr |
| (Frobenius.sumEquiv (k := k) (ι := ι) (κ := κ) ell).toLinearEquiv |
| (ExteriorSplit.sumEquiv (k := k) (ι := ι) (κ := κ))).symm |
| ((TensorProduct.tensorTensorTensorComm k _ _ _ _).symm |
| ((a ⊗ₜ[k] e) ⊗ₜ[k] (b ⊗ₜ[k] f))) = _ |
| rw [TensorProduct.tensorTensorTensorComm_symm, TensorProduct.tensorTensorTensorComm_tmul, TensorProduct.congr_symm, |
| TensorProduct.congr_tmul, ExteriorSplit.sumEquiv_symm_tmul] |
| change merge (k := k) (ι := ι) (κ := κ) ell (a ⊗ₜ[k] b) ⊗ₜ[k] |
| (ExteriorAlgebra.map ExteriorSplit.leftVec e * ExteriorAlgebra.map ExteriorSplit.rightVec f) = _ |
| rw [merge_tmul] |
| simp only [includeLeft, includeRight, Algebra.TensorProduct.map_tmul, |
| Algebra.TensorProduct.tmul_mul_tmul] |
|
|
| omit [Fintype ι] [Fintype κ] in |
| @[simp] theorem exterior_left_gen (i : ι) : |
| ExteriorAlgebra.map (ExteriorSplit.leftVec (k := k) (κ := κ)) (gen i) = |
| gen (Sum.inl i : ι ⊕ κ) := by |
| rw [gen, ExteriorAlgebra.map_apply_ι] |
| congr 1 |
| funext j |
| cases j <;> simp [ExteriorSplit.leftVec, Pi.single_apply] |
| |
| omit [Fintype ι] [Fintype κ] in |
| @[simp] theorem exterior_right_gen (i : κ) : |
| ExteriorAlgebra.map (ExteriorSplit.rightVec (k := k) (ι := ι)) (gen i) = |
| gen (Sum.inr i : ι ⊕ κ) := by |
| rw [gen, ExteriorAlgebra.map_apply_ι] |
| congr 1 |
| funext j |
| cases j <;> simp [ExteriorSplit.rightVec, Pi.single_apply] |
| |
| theorem involute_map {V W : Type*} [AddCommGroup V] [AddCommGroup W] |
| [Module k V] [Module k W] (f : V →ₗ[k] W) (e : ExteriorAlgebra k V) : |
| CliffordAlgebra.involute (ExteriorAlgebra.map f e) = |
| ExteriorAlgebra.map f (CliffordAlgebra.involute e) := by |
| have h : (CliffordAlgebra.involute : ExteriorAlgebra k W →ₐ[k] _).comp |
| (ExteriorAlgebra.map f) = (ExteriorAlgebra.map f).comp CliffordAlgebra.involute := by |
| ext v |
| simp |
| exact AlgHom.congr_fun h e |
|
|
| @[simp] theorem parity_includeLeft (x : QForms (k := k) ell ι) : |
| parity (includeLeft (κ := κ) ell x) = includeLeft ell (parity x) := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simp only [map_add, hx, hy] |
| | tmul a e => simp only [includeLeft, Algebra.TensorProduct.map_tmul, parity_tmul, |
| involute_map] |
|
|
| @[simp] theorem parity_includeRight (x : QForms (k := k) ell κ) : |
| parity (includeRight (ι := ι) ell x) = includeRight ell (parity x) := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simp only [map_add, hx, hy] |
| | tmul a e => simp only [includeRight, Algebra.TensorProduct.map_tmul, parity_tmul, |
| involute_map] |
|
|
| variable [CharP k ell] |
|
|
| @[simp] theorem d_includeLeft (x : QForms (k := k) ell ι) : |
| d (partialDeriv ell) (includeLeft (κ := κ) ell x) = |
| includeLeft ell (d (partialDeriv ell) x) := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simp only [map_add, hx, hy] |
| | tmul a e => |
| simp only [includeLeft, Algebra.TensorProduct.map_tmul, d_tmul, |
| Fintype.sum_sum_type, partial_include_left, partial_include_left_other, |
| TensorProduct.zero_tmul, Finset.sum_const_zero, add_zero, map_sum, map_mul, |
| exterior_left_gen] |
|
|
| @[simp] theorem d_includeRight (x : QForms (k := k) ell κ) : |
| d (partialDeriv ell) (includeRight (ι := ι) ell x) = |
| includeRight ell (d (partialDeriv ell) x) := by |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simp only [map_add, hx, hy] |
| | tmul a e => |
| simp only [includeRight, Algebra.TensorProduct.map_tmul, d_tmul, |
| Fintype.sum_sum_type, partial_include_right, partial_include_right_other, |
| TensorProduct.zero_tmul, Finset.sum_const_zero, zero_add, map_sum, map_mul, |
| exterior_right_gen] |
|
|
| omit [CharP k ell] in |
| @[simp] theorem includeLeft_coeff (a : Ring (ι := ι) (k := k) ell) : |
| includeLeft (κ := κ) ell (coeff a) = coeff (includeVariables ell Sum.inl a) := by |
| simp only [includeLeft, coeff_apply, Algebra.TensorProduct.map_tmul, map_one] |
| omit [CharP k ell] in |
| @[simp] theorem includeRight_coeff (a : Ring (ι := κ) (k := k) ell) : |
| includeRight (ι := ι) ell (coeff a) = coeff (includeVariables ell Sum.inr a) := by |
| simp only [includeRight, coeff_apply, Algebra.TensorProduct.map_tmul, map_one] |
|
|
| @[simp] theorem gradient_include_left (a : Ring (ι := ι) (k := k) ell) : |
| gradient (partialDeriv ell) (includeVariables ell (Sum.inl : ι → ι ⊕ κ) a) = |
| includeLeft ell (gradient (partialDeriv ell) a) := by |
| change d (partialDeriv ell) (coeff (includeVariables ell Sum.inl a)) = _ |
| rw [← includeLeft_coeff, d_includeLeft, d_coeff] |
|
|
| @[simp] theorem gradient_include_right (a : Ring (ι := κ) (k := k) ell) : |
| gradient (partialDeriv ell) (includeVariables ell (Sum.inr : κ → ι ⊕ κ) a) = |
| includeRight ell (gradient (partialDeriv ell) a) := by |
| change d (partialDeriv ell) (coeff (includeVariables ell Sum.inr a)) = _ |
| rw [← includeRight_coeff, d_includeRight, d_coeff] |
|
|
| theorem gradient_add {A : Type*} [CommRing A] [Algebra k A] |
| (pd : ι → Derivation k A A) (a b : A) : |
| gradient pd (a + b) = gradient pd a + gradient pd b := by |
| simp only [MixedForms.gradient, TensorProduct.add_tmul, map_add] |
|
|
| |
| |
| theorem delta_product (Q : Ring (ι := ι) (k := k) ell) |
| (R : Ring (ι := κ) (k := k) ell) (x : QForms (k := k) ell ι) |
| (y : QForms (k := k) ell κ) : |
| delta (partialDeriv ell) (includeVariables ell Sum.inl Q + includeVariables ell Sum.inr R) |
| (includeLeft ell x * includeRight ell y) = |
| includeLeft ell (delta (partialDeriv ell) Q x) * includeRight ell y + |
| includeLeft ell (parity x) * includeRight ell (delta (partialDeriv ell) R y) := by |
| rw [delta_apply, gradient_add, gradient_include_left, gradient_include_right, add_mul] |
| congr 1 |
| · rw [delta_apply, map_mul, mul_assoc] |
| · rw [← gradient_include_right, ← mul_assoc, gradient_supercommute, parity_includeLeft, |
| mul_assoc, delta_apply, map_mul, gradient_include_right] |
|
|
| end BoundaryOnly.FormalObstruction.FormsSplit |
|
|
| namespace BoundaryOnly.FormalObstruction.GlobalForms |
| open Frobenius MixedForms |
| open scoped TensorProduct |
| variable {k : Type*} [CommRing k] |
|
|
| |
| abbrev Coordinates : (n : ℕ) → (Fin n → Type) → Type |
| | 0, _ => PEmpty |
| | n + 1, V => V 0 ⊕ Coordinates n (fun i => V i.succ) |
|
|
| instance coordinatesFintype : ∀ (n : ℕ) (V : Fin n → Type) [∀ i, Fintype (V i)], |
| Fintype (Coordinates n V) |
| | 0, _, _ => inferInstanceAs (Fintype PEmpty) |
| | n + 1, V, _ => by |
| letI := coordinatesFintype n (fun i => V i.succ) |
| exact inferInstanceAs (Fintype (V 0 ⊕ Coordinates n (fun i => V i.succ))) |
|
|
| instance coordinatesDecidableEq : ∀ (n : ℕ) (V : Fin n → Type) [∀ i, DecidableEq (V i)], |
| DecidableEq (Coordinates n V) |
| | 0, _, _ => inferInstanceAs (DecidableEq PEmpty) |
| | n + 1, V, _ => by |
| letI := coordinatesDecidableEq n (fun i => V i.succ) |
| exact inferInstanceAs (DecidableEq (V 0 ⊕ Coordinates n (fun i => V i.succ))) |
|
|
| abbrev consIndex (n : ℕ) : Unit ⊕ Fin n ≃ Fin (n + 1) where |
| toFun := Sum.elim (fun _ => 0) Fin.succ |
| invFun := Fin.cases (Sum.inl ()) Sum.inr |
| left_inv := by intro i; cases i with |
| | inl u => cases u; rfl |
| | inr i => rfl |
| right_inv := by intro i; refine Fin.cases ?_ (fun j => ?_) i <;> rfl |
| |
| @[simp] theorem consIndex_zero (n : ℕ) : consIndex n (.inl ()) = 0 := rfl |
| @[simp] theorem consIndex_succ (n : ℕ) (i : Fin n) : consIndex n (.inr i) = i.succ := rfl |
|
|
| |
| def tensorCons {n : ℕ} (V : Fin (n + 1) → Type*) [∀ i, AddCommGroup (V i)] |
| [∀ i, Module k (V i)] : (⨂[k] i, V i) ≃ₗ[k] V 0 ⊗[k] (⨂[k] i : Fin n, V i.succ) := |
| ((PiTensorProduct.reindex k V (consIndex n).symm).trans |
| (PiTensorProduct.tmulEquivDep k (fun j => V (consIndex n j))).symm).trans |
| (TensorProduct.congr (PiTensorProduct.subsingletonEquiv ()) (LinearEquiv.refl _ _)) |
|
|
| @[simp] theorem tensorCons_tprod {n : ℕ} (V : Fin (n + 1) → Type*) |
| [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)] (v : ∀ i, V i) : |
| tensorCons (k := k) V (PiTensorProduct.tprod k v) = |
| v 0 ⊗ₜ[k] PiTensorProduct.tprod k (fun i : Fin n => v i.succ) := by |
| simp only [tensorCons, LinearEquiv.trans_apply, PiTensorProduct.reindex_tprod, |
| PiTensorProduct.tmulEquivDep_symm_apply, Equiv.symm_symm] |
| change (TensorProduct.congr |
| (PiTensorProduct.subsingletonEquiv (R := k) (s := fun _ : Unit => V 0) ()) |
| (LinearEquiv.refl k (⨂[k] i : Fin n, V i.succ))) |
| ((PiTensorProduct.tprod k (fun _ : Unit => v 0)) ⊗ₜ[k] |
| PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) = _ |
| rw [TensorProduct.congr_tmul, PiTensorProduct.subsingletonEquiv_apply_tprod] |
| rfl |
|
|
| def emptyCoefficients (ell : ℕ) (hell : 0 < ell) : |
| Ring (ι := PEmpty) (k := k) ell ≃ₐ[k] k := |
| AlgEquiv.ofAlgHom |
| { constantHom ell hell with commutes' := constantHom_algebraMap ell hell } |
| (Algebra.ofId k _) |
| (by ext) |
| (by apply algHom_ext; intro i; exact PEmpty.elim i) |
| |
| def emptyExterior : ExteriorAlgebra k (PEmpty.{1} → k) ≃ₐ[k] k := |
| AlgEquiv.ofAlgHom (ExteriorAlgebra.lift k ⟨0, by simp⟩) (Algebra.ofId k _) |
| (by ext) |
| (by apply ExteriorAlgebra.hom_ext |
| apply LinearMap.ext |
| intro v |
| have hv : v = 0 := Subsingleton.elim _ _ |
| rw [hv] |
| simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply] |
| rw [show (ExteriorAlgebra.ι k) (0 : PEmpty.{1} → k) = 0 from |
| (ExteriorAlgebra.ι k).map_zero] |
| simp) |
|
|
| abbrev QForms (ell : ℕ) (ι : Type) [Fintype ι] [DecidableEq ι] := |
| MixedForms.Forms (k := k) (A := Ring (ι := ι) (k := k) ell) (ι := ι) |
|
|
| def emptyForms (ell : ℕ) (hell : 0 < ell) : QForms (k := k) ell PEmpty ≃ₗ[k] k := |
| (TensorProduct.congr (emptyCoefficients (k := k) ell hell).toLinearEquiv |
| (emptyExterior (k := k)).toLinearEquiv).trans (TensorProduct.lid k k) |
|
|
| |
| noncomputable def blockEquiv (ell : ℕ) (hell : 0 < ell) : |
| ∀ (n : ℕ) (V : Fin n → Type) [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)], |
| QForms (k := k) ell (Coordinates n V) ≃ₗ[k] (⨂[k] i, QForms (k := k) ell (V i)) |
| | 0, _, _, _ => (emptyForms ell hell).trans (PiTensorProduct.isEmptyEquiv (Fin 0)).symm |
| | n + 1, V, _, _ => |
| ((FormsSplit.sumEquiv (k := k) (ι := V 0) (κ := Coordinates n (fun i => V i.succ)) ell).trans |
| (TensorProduct.congr (LinearEquiv.refl k (QForms (k := k) ell (V 0))) |
| (blockEquiv ell hell n (fun i => V i.succ)))).trans |
| (tensorCons (k := k) (fun i => QForms (k := k) ell (V i))).symm |
|
|
| end BoundaryOnly.FormalObstruction.GlobalForms |
|
|
| end |
|
|
| end OAI |
|
|
