| import Mathlib |
| import OAI.NumberTheory.PiExponent.Jets.NormalBasisRigidity |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PiExponent.NormalBasisRigidity |
| open Module |
|
|
| variable {K : Type*} [Field K] (m : ℕ) (y : K) (hy : y ≠ 0) |
|
|
| def frameEquiv : (Fin (m + 1) → K) ≃ₗ[K] (Fin (m + 1) → K) where |
| toFun c := Fin.cases (y * c 0) (fun i => c i.succ + c 0) |
| invFun t := Fin.cases (t 0 / y) (fun i => t i.succ - t 0 / y) |
| left_inv c := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [hy] |
| · simp [hy] |
| right_inv t := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · change y * (t 0 / y) = t 0 |
| field_simp |
| · simp |
| map_add' c d := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [mul_add] |
| · simp only [Pi.add_apply, Fin.cases_succ] |
| ring |
| map_smul' a c := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp only [Pi.smul_apply, Fin.cases_zero, smul_eq_mul, RingHom.id_apply] |
| ring |
| · simp [mul_add] |
|
|
| def frameBasis : Basis (Fin (m + 1)) K (Fin (m + 1) → K) := |
| (Pi.basisFun K _).map (frameEquiv m y hy) |
|
|
| @[simp] lemma frameBasis_repr_zero (t : Fin (m + 1) → K) : |
| (frameBasis m y hy).repr t 0 = t 0 / y := by |
| change (Pi.basisFun K _).repr ((frameEquiv m y hy).symm t) 0 = _ |
| rw [Pi.basisFun_repr] |
| rfl |
|
|
| @[simp] lemma frameBasis_repr_succ (t : Fin (m + 1) → K) (i : Fin m) : |
| (frameBasis m y hy).repr t i.succ = t i.succ - t 0 / y := by |
| change (Pi.basisFun K _).repr ((frameEquiv m y hy).symm t) i.succ = _ |
| rw [Pi.basisFun_repr] |
| rfl |
|
|
| @[simp] lemma frameBasis_succ (i : Fin m) : |
| frameBasis m y hy i.succ = Pi.basisFun K _ i.succ := by |
| ext j |
| refine Fin.cases ?_ (fun k => ?_) j |
| · simp [frameBasis, frameEquiv, Pi.basisFun_apply] |
| · simp [frameBasis, frameEquiv, Pi.basisFun_apply, Pi.single_apply] |
|
|
| @[simp] lemma frameBasis_zero_zero : frameBasis m y hy 0 0 = y := by |
| simp [frameBasis, frameEquiv, Pi.basisFun_apply] |
|
|
| @[simp] lemma frameBasis_zero_succ (i : Fin m) : frameBasis m y hy 0 i.succ = 1 := by |
| simp [frameBasis, frameEquiv, Pi.basisFun_apply] |
|
|
| variable {V : Type*} [AddCommGroup V] [Module K V] |
|
|
| lemma mandatory_logarithmic_differential (q : (Fin (m + 1) → K) →ₗ[K] V) |
| (hq : Submodule.span K (Set.range (fun j => q (frameBasis m y hy j))) = ⊤) |
| (i : Fin m) |
| (hi : ∀ A, IsNormalBasis (K := K) (fun j => q (frameBasis m y hy j)) A → i.succ ∈ A) |
| (t : Fin (m + 1) → K) (ht : q t = 0) : t i.succ = t 0 / y := by |
| have h := mandatory_coordinate_eq_zero (frameBasis m y hy) q hq i.succ hi t ht |
| rw [frameBasis_repr_succ] at h |
| exact sub_eq_zero.mp h |
|
|
| lemma span_mapped_basis_eq_top {ι U : Type*} [Fintype ι] |
| [AddCommGroup U] [Module K U] (b : Basis ι K U) (q : U →ₗ[K] V) |
| (hq : Function.Surjective q) : |
| Submodule.span K (Set.range (fun j => q (b j))) = ⊤ := by |
| apply top_unique |
| intro x _ |
| obtain ⟨t, rfl⟩ := hq x |
| rw [← b.sum_repr t, map_sum] |
| apply Submodule.sum_mem |
| intro i _ |
| rw [map_smul] |
| exact Submodule.smul_mem _ _ (Submodule.subset_span (Set.mem_range_self i)) |
|
|
| theorem normal_basis_differential_dichotomy |
| (q : (Fin (m + 1) → K) →ₗ[K] V) (hq : Function.Surjective q) (hq0 : q ≠ 0) |
| (hexclude : ∀ A B : Finset (Fin (m + 1)), |
| IsNormalBasis (K := K) (fun j => q (Pi.basisFun K _ j)) A → |
| IsNormalBasis (K := K) (fun j => q (frameBasis m y hy j)) B → |
| ∀ i, i ≠ 0 → i ∈ A → i ∉ B → |
| (∀ j, i < j → (j ∈ A ↔ j ∈ B)) → False) : |
| (∀ t, q t = 0 → t 0 = 0) ∨ |
| ∃ i : Fin m, ∀ t, q t = 0 → t i.succ = t 0 / y := by |
| classical |
| let b := Pi.basisFun K (Fin (m + 1)) |
| let S := Finset.univ.filter (fun i : Fin (m + 1) => i ≠ 0 ∧ q (b i) ≠ 0) |
| by_cases hS : S.Nonempty |
| · let i := S.max' hS |
| have hiS : i ∈ S := Finset.max'_mem _ _ |
| have hi := (Finset.mem_filter.mp hiS).2 |
| have hlarge : ∀ j, i < j → q (b j) = 0 := by |
| intro j hj |
| by_contra hjq |
| have hj0 : j ≠ 0 := by |
| intro hz |
| subst j |
| exact (not_lt_of_ge (Fin.zero_le _)) hj |
| have hjS : j ∈ S := Finset.mem_filter.mpr ⟨Finset.mem_univ _, hj0, hjq⟩ |
| exact (not_lt_of_ge (Finset.le_max' _ _ hjS)) hj |
| have hvu : ∀ j : Fin (m + 1), j ≠ 0 → q (frameBasis m y hy j) = q (b j) := by |
| intro j |
| refine Fin.cases ?_ (fun k _ => ?_) j |
| · intro hz |
| exact (hz rfl).elim |
| · rw [frameBasis_succ] |
| have hmand : ∀ B, IsNormalBasis (K := K) (fun j => q (frameBasis m y hy j)) B → i ∈ B := |
| largest_nontangent_mandatory (fun j => q (b j)) |
| (fun j => q (frameBasis m y hy j)) (span_mapped_basis_eq_top b q hq) |
| hvu hexclude i hi.1 hi.2 hlarge |
| rcases Fin.eq_zero_or_eq_succ i with hz | ⟨j, hj⟩ |
| · exact (hi.1 hz).elim |
| · right |
| refine ⟨j, ?_⟩ |
| intro t ht |
| apply mandatory_logarithmic_differential m y hy q |
| (span_mapped_basis_eq_top (frameBasis m y hy) q hq) j ?_ t ht |
| intro B hB |
| rw [← hj] |
| exact hmand B hB |
| · have hpos : ∀ j : Fin m, q (b j.succ) = 0 := by |
| intro j |
| by_contra hj |
| exact hS ⟨j.succ, Finset.mem_filter.mpr ⟨Finset.mem_univ _, Fin.succ_ne_zero _, hj⟩⟩ |
| have he0 : q (b 0) ≠ 0 := by |
| intro he |
| apply hq0 |
| apply b.ext |
| intro j |
| refine Fin.cases ?_ (fun k => ?_) j |
| · exact he |
| · exact hpos k |
| have hqform (t : Fin (m + 1) → K) : q t = t 0 • q (b 0) := by |
| calc |
| q t = q (∑ j, b.repr t j • b j) := congrArg q (b.sum_repr t).symm |
| _ = ∑ j, b.repr t j • q (b j) := by simp only [map_sum, map_smul] |
| _ = t 0 • q (b 0) := by |
| rw [Fin.sum_univ_succ] |
| simp only [hpos, smul_zero, Finset.sum_const_zero, add_zero] |
| simp only [b, Pi.basisFun_repr] |
| left |
| intro t ht |
| rw [hqform] at ht |
| exact (smul_eq_zero.mp ht).resolve_right he0 |
|
|
| end PiExponent.NormalBasisRigidity |
|
|
| end |
|
|
| end OAI |
|
|
