| import Mathlib |
| import OAI.Algebra.FiniteTensor.FormalEvaluation |
|
|
| namespace OAI |
|
|
| /-! Relative derivations, graph evaluation and top exterior coefficients. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace PD4Tensor.FiniteCoordinates |
| noncomputable section |
| variable (R σ : Type*) [CommRing R] |
| (p : ℕ) [CharP R p] |
|
|
| theorem pderiv_mem_uniform (i : σ) (f : MvPolynomial σ R) |
| (hf : f∈ideal R σ (fun _ => p)) : MvPolynomial.pderiv i f∈ideal R σ (fun _ => p) := by |
| induction hf using Submodule.span_induction with |
| | mem f hf => |
| obtain ⟨j,rfl⟩ := hf |
| simp only [MvPolynomial.pderiv_pow,CharP.cast_eq_zero,zero_mul] |
| exact Ideal.zero_mem _ |
| | zero => simp |
| | add f g hf hg ihf ihg => simpa only [map_add] using (ideal R σ (fun _ => p)).add_mem ihf ihg |
| | smul a f hf ih => |
| rw [smul_eq_mul,MvPolynomial.pderiv_mul] |
| exact (ideal R σ (fun _ => p)).add_mem ((ideal R σ (fun _ => p)).mul_mem_left _ hf) |
| ((ideal R σ (fun _ => p)).mul_mem_left _ ih) |
|
|
| |
|
|
| def relativeDeriv (i : σ) : Ring R σ (fun _ => p) →ₗ[R] Ring R σ (fun _ => p) := |
| ((ideal R σ (fun _ => p)).restrictScalars R).liftQ |
| ((Ideal.Quotient.mkₐ R (ideal R σ (fun _ => p))).toLinearMap.comp |
| (MvPolynomial.pderiv i).toLinearMap) (by |
| intro f hf |
| change Ideal.Quotient.mk (ideal R σ (fun _ => p)) (MvPolynomial.pderiv i f)=0 |
| exact Ideal.Quotient.eq_zero_iff_mem.mpr (pderiv_mem_uniform R σ p i f hf)) |
|
|
| @[simp] theorem partial_mk (i : σ) (f : MvPolynomial σ R) : |
| relativeDeriv R σ p i (Ideal.Quotient.mk (ideal R σ (fun _ => p)) f)= |
| Ideal.Quotient.mk (ideal R σ (fun _ => p)) (MvPolynomial.pderiv i f) := rfl |
|
|
| @[simp] theorem partial_coord [DecidableEq σ] (i j : σ) : |
| relativeDeriv R σ p i (coord R σ (fun _ => p) j)=if i=j then 1 else 0 := by |
| rw [coord,partial_mk,MvPolynomial.pderiv_X] |
| by_cases h : i=j |
| · subst j; simp |
| · simp [Ne.symm h,h] |
|
|
| @[simp] theorem partial_scalar (i : σ) (a : R) : |
| relativeDeriv R σ p i (algebraMap R (Ring R σ (fun _ => p)) a)=0 := by |
| change relativeDeriv R σ p i (Ideal.Quotient.mk (ideal R σ (fun _ => p)) (MvPolynomial.C a))=0 |
| rw [partial_mk,MvPolynomial.pderiv_C,map_zero] |
|
|
| theorem partial_mul (i : σ) (a b : Ring R σ (fun _ => p)) : |
| relativeDeriv R σ p i (a*b)=relativeDeriv R σ p i a*b+a*relativeDeriv R σ p i b := by |
| obtain ⟨a,rfl⟩ := Ideal.Quotient.mk_surjective a |
| obtain ⟨b,rfl⟩ := Ideal.Quotient.mk_surjective b |
| rw [←map_mul,partial_mk,MvPolynomial.pderiv_mul] |
| simp only [map_add,map_mul,partial_mk] |
|
|
| private theorem pderiv_commute (i j : σ) (f : MvPolynomial σ R) : |
| MvPolynomial.pderiv i (MvPolynomial.pderiv j f)= |
| MvPolynomial.pderiv j (MvPolynomial.pderiv i f) := by |
| classical |
| by_cases hij : i=j |
| · subst j; rfl |
| induction f using MvPolynomial.induction_on with |
| | C a => simp |
| | add f g hf hg => simp [hf,hg] |
| | mul_X f k hf => |
| by_cases hi : k=i <;> by_cases hj : k=j <;> |
| simp [MvPolynomial.pderiv_X,hi,hj,hij,Ne.symm hij,eq_comm,hf] <;> ring |
|
|
| theorem partial_commute (i j : σ) (a : Ring R σ (fun _ => p)) : |
| relativeDeriv R σ p i (relativeDeriv R σ p j a)=relativeDeriv R σ p j (relativeDeriv R σ p i a) := by |
| obtain ⟨a,rfl⟩ := Ideal.Quotient.mk_surjective a |
| simp only [partial_mk,pderiv_commute] |
|
|
| def partialDerivation (i : σ) : Derivation R (Ring R σ (fun _ => p)) (Ring R σ (fun _ => p)) where |
| toLinearMap := relativeDeriv R σ p i |
| map_one_eq_zero' := by |
| rw [←map_one (algebraMap R (Ring R σ (fun _ => p))),partial_scalar] |
| leibniz' a b := by |
| simpa only [smul_eq_mul,mul_comm,add_comm] using partial_mul R σ p i a b |
|
|
| |
|
|
| theorem partial_nilEval [Fintype σ] (i : σ) (q : MvPowerSeries σ R) : |
| relativeDeriv R σ p i (nilEval R (coord R σ (fun _ => p)) (fun j => ⟨p,coord_pow _ _ _ j⟩) q)= |
| nilEval R (coord R σ (fun _ => p)) (fun j => ⟨p,coord_pow _ _ _ j⟩) |
| (MvPowerSeries.pderiv i q) := by |
| classical |
| exact nilEval_pderiv (coord R σ (fun _ => p)) (fun j => ⟨p,coord_pow _ _ _ j⟩) |
| i (partialDerivation R σ p i) (partial_coord R σ p i) q |
|
|
| end |
| end PD4Tensor.FiniteCoordinates |
|
|
| namespace PD4Tensor |
| noncomputable section |
| variable {R A σ τ : Type*} [CommRing R] [CommRing A] [Algebra R A] |
| [Finite σ] [Finite τ] |
|
|
| @[simp] theorem nilEval_rename (f : σ → τ) (v : τ → A) (hv : ∀ j, IsNilpotent (v j)) |
| (q : MvPowerSeries σ R) : |
| nilEval R v hv (MvPowerSeries.rename f q)=nilEval R (v ∘ f) (fun i => hv (f i)) q := by |
| rw [MvPowerSeries.rename_eq_subst,nilEval_subst (MvPowerSeries.X ∘ f) (MvPowerSeries.HasSubst.X_comp f)] |
| simp only [Function.comp_apply,nilEval_X] |
| rfl |
|
|
| |
|
|
| theorem ideal_span_range_map {B ι : Type*} [CommRing B] [Fintype ι] |
| (f : A →+* B) (a : A) (v : ι → A) (ha : a∈Ideal.span (Set.range v)) : |
| f a∈Ideal.span (Set.range (fun i => f (v i))) := by |
| obtain ⟨b,hb⟩ := Ideal.mem_span_range_iff_exists_fun.mp ha |
| refine Ideal.mem_span_range_iff_exists_fun.mpr ⟨fun i => f (b i),?_⟩ |
| rw [←hb] |
| simp only [map_sum,map_mul] |
|
|
| variable {p : ℕ} |
| {B : Type*} [CommRing B] [Algebra R B] |
|
|
| |
|
|
| theorem graph_eval (H : σ → MvPowerSeries τ R) (hH : MvPowerSeries.HasSubst H) |
| (v : τ → B) (hv : ∀ j, IsNilpotent (v j)) |
| (r : FiniteCoordinates.Ring R σ (fun _ => p) →ₐ[R] B) |
| (hr : ∀ i, r (FiniteCoordinates.coord R σ (fun _ => p) i)=nilEval R v hv (H i)) |
| (q : MvPowerSeries σ R) : |
| r (nilEval R (FiniteCoordinates.coord R σ (fun _ => p)) |
| (fun i => ⟨p,FiniteCoordinates.coord_pow _ _ _ i⟩) q)= |
| nilEval R v hv (MvPowerSeries.subst H q) := by |
| calc |
| r (nilEval R (FiniteCoordinates.coord R σ (fun _ => p)) |
| (fun i => ⟨p,FiniteCoordinates.coord_pow _ _ _ i⟩) q) = |
| nilEval R (fun i => r (FiniteCoordinates.coord R σ (fun _ => p) i)) |
| (fun i => (show IsNilpotent (FiniteCoordinates.coord R σ (fun _ => p) i) from |
| ⟨p,FiniteCoordinates.coord_pow _ _ _ i⟩).map r) q := |
| nilEval_map r _ _ q |
| _ = _ := by |
| conv_rhs => rw [nilEval_subst H hH] |
| simp only [hr] |
|
|
| end |
| end PD4Tensor |
|
|
| namespace PD4Tensor.Forms |
| noncomputable section |
| open scoped TensorProduct BigOperators |
| variable (K A : Type*) [Field K] [CommRing A] [Algebra K A] (N : ℕ) |
|
|
| |
| def topExterior : E K (Fin N) →ₗ[K] K := |
| ExteriorAlgebra.liftAlternating (fun r => |
| if h : r=N then h.symm ▸ (Matrix.detRowAlternating : (Fin N → K) [⋀^Fin N]→ₗ[K] K) |
| else 0) |
|
|
| @[simp] theorem topExterior_ιMulti (v : Fin N → Fin N → K) : |
| topExterior K N (ExteriorAlgebra.ιMulti K N v) = Matrix.det v := by |
| simp only [topExterior, ExteriorAlgebra.liftAlternating_apply_ιMulti] |
| rfl |
|
|
| |
| def topCoefficient : Ω K A (Fin N) →ₗ[A] A := |
| (TensorProduct.AlgebraTensorModule.rid K A A).toLinearMap.comp |
| (TensorProduct.AlgebraTensorModule.map (LinearMap.id : A →ₗ[A] A) (topExterior K N)) |
|
|
| @[simp] theorem topCoefficient_tmul (a : A) (e : E K (Fin N)) : |
| topCoefficient K A N (a ⊗ₜ[K] e) = topExterior K N e • a := by |
| rfl |
|
|
| |
| def oneFormLinear : (Fin N → A) →ₗ[A] Ω K A (Fin N) where |
| toFun := oneForm K A (Fin N) |
| map_add' := by |
| intro v w |
| simp only [oneForm, Pi.add_apply, TensorProduct.add_tmul, Finset.sum_add_distrib] |
| map_smul' := by |
| intro a v |
| simp only [oneForm, Pi.smul_apply, Finset.smul_sum, TensorProduct.smul_tmul'] |
| rfl |
| |
| variable [Invertible (2 : K)] |
| def exteriorScalarExtension : ExteriorAlgebra A (Fin N → A) →ₐ[A] Ω K A (Fin N) := |
| ExteriorAlgebra.lift A ⟨oneFormLinear K A N, fun v => oneForm_sq_zero v⟩ |
| |
| @[simp] theorem exteriorScalarExtension_ι (v : Fin N → A) : |
| exteriorScalarExtension K A N (ExteriorAlgebra.ι A v) = oneForm K A (Fin N) v := by |
| exact ExteriorAlgebra.lift_ι_apply A (oneFormLinear K A N) _ v |
| |
| @[simp] theorem exteriorScalarExtension_ιMulti {r : ℕ} (v : Fin r → Fin N → A) : |
| exteriorScalarExtension K A N (ExteriorAlgebra.ιMulti A r v) = |
| (List.ofFn (fun i => oneForm K A (Fin N) (v i))).prod := by |
| simp only [ExteriorAlgebra.ιMulti_apply, map_list_prod, List.map_ofFn] |
| congr 2 |
| funext i |
| exact exteriorScalarExtension_ι K A N (v i) |
| |
| |
| theorem topCoefficient_oneForm_product (v : Fin N → Fin N → A) : |
| topCoefficient K A N (List.ofFn (fun i => oneForm K A (Fin N) (v i))).prod = Matrix.det v := by |
| let f : (Fin N → A) [⋀^Fin N]→ₗ[A] A := |
| ((topCoefficient K A N).comp (exteriorScalarExtension K A N).toLinearMap).compAlternatingMap |
| (ExteriorAlgebra.ιMulti A N) |
| have hf (v : Fin N → Fin N → A) : f v = |
| topCoefficient K A N (List.ofFn (fun i => oneForm K A (Fin N) (v i))).prod := by |
| exact congrArg (topCoefficient K A N) (exteriorScalarExtension_ιMulti K A N v) |
| have hstd (i : Fin N) : oneForm K A (Fin N) (Pi.basisFun A (Fin N) i) = |
| (1 : A) ⊗ₜ[K] dx K (Fin N) i := by |
| simp only [oneForm, Pi.basisFun_apply] |
| rw [Finset.sum_eq_single i] |
| · simp |
| · intro j _ hji; simp [hji] |
| · simp |
| have hprod : (List.ofFn (fun i => oneForm K A (Fin N) (Pi.basisFun A (Fin N) i))).prod = |
| (1 : A) ⊗ₜ[K] ExteriorAlgebra.ιMulti K N (Pi.basisFun K (Fin N)) := by |
| simp only [hstd, ExteriorAlgebra.ιMulti_apply] |
| have hg : (List.ofFn (fun i => (1 : A) ⊗ₜ[K] dx K (Fin N) i)).prod = |
| (1 : A) ⊗ₜ[K] (List.ofFn (fun i => dx K (Fin N) i)).prod := by |
| have h := (Algebra.TensorProduct.includeRight : E K (Fin N) →ₐ[K] Ω K A (Fin N)).map_list_prod |
| (List.ofFn (fun i => dx K (Fin N) i)) |
| change (1 : A) ⊗ₜ[K] (List.ofFn (fun i => dx K (Fin N) i)).prod = |
| (List.map (fun e : E K (Fin N) => (1 : A) ⊗ₜ[K] e) |
| (List.ofFn (fun i => dx K (Fin N) i))).prod at h |
| rw [List.map_ofFn] at h |
| exact h.symm |
| convert hg using 1 |
| simp only [dx, Pi.basisFun_apply] |
| have he : f (Pi.basisFun A (Fin N)) = 1 := by |
| rw [hf, hprod, topCoefficient_tmul, topExterior_ιMulti] |
| have hdet : Matrix.det (fun i => Pi.basisFun K (Fin N) i)=1 := by |
| have h := (Pi.basisFun K (Fin N)).det_self |
| change Matrix.detRowAlternating (Pi.basisFun K (Fin N))=1 |
| simpa only [Pi.basisFun_det] using h |
| rw [hdet, one_smul] |
| have h := f.eq_smul_basis_det (Pi.basisFun A (Fin N)) |
| rw [he, one_smul] at h |
| rw [← hf, h, Pi.basisFun_det] |
| rfl |
| |
| end |
| end PD4Tensor.Forms |
| end |
| |
| end OAI |
| |
