| import Mathlib |
| import OAI.Algebra.FrobeniusObstruction.Obstruction |
| import OAI.Algebra.AlgebraicObstruction.CorrectionOperator |
| import OAI.Algebra.AlgebraicObstruction.TaylorRemainder |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace BoundaryOnly.FormalObstruction.FormalCorrection |
| open MvPowerSeries Matrix |
| open scoped Classical |
| variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ] |
|
|
| def shiftedGraph (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) : |
| (α ⊕ ι) → MvPowerSeries σ R := |
| Sum.elim (fun a => x (.inl a)) (fun i => x (.inr i) + δ i) |
|
|
| omit [Fintype α] [Fintype ι] [Finite σ] in |
| theorem extended_centered [Fintype α] [Fintype ι] [Finite σ] |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) : |
| ∀ j, constantCoeff (Sum.elim x δ j) = 0 := by |
| intro j; cases j with |
| | inl j => exact hx j |
| | inr j => exact hδ j |
|
|
| omit [Fintype α] [Fintype ι] [Finite σ] in |
| theorem shiftedGraph_centered [Fintype α] [Fintype ι] [Finite σ] |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) : |
| ∀ j, constantCoeff (shiftedGraph x δ j) = 0 := by |
| intro j; cases j <;> simp [shiftedGraph, hx, hδ] |
|
|
| theorem subst_extended_base (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) |
| (f : MvPowerSeries (α ⊕ ι) R) : |
| subst (Sum.elim x δ) (subst (baseArguments (R := R)) f) = subst x f := by |
| let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ) |
| rw [subst_comp_subst_apply (R := R) (hasSubst_of_constantCoeff_zero (baseArguments_centered (R := R) (α := α) (ι := ι))) hs] |
| simp only [baseArguments, subst_X hs, Sum.elim_inl] |
|
|
| theorem subst_extended_shifted (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) |
| (f : MvPowerSeries (α ⊕ ι) R) : |
| subst (Sum.elim x δ) (subst (shiftedArguments (R := R)) f) = subst (shiftedGraph x δ) f := by |
| let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ) |
| rw [subst_comp_subst_apply (R := R) (hasSubst_of_constantCoeff_zero (shiftedArguments_centered (R := R) (α := α) (ι := ι))) hs] |
| congr 1 |
| funext i |
| cases i <;> simp only [shiftedArguments, shiftedGraph, Sum.elim_inl, Sum.elim_inr, |
| subst_add hs, subst_X hs] |
|
|
| def gradientValue (f : MvPowerSeries (α ⊕ ι) R) (x : (α ⊕ ι) → MvPowerSeries σ R) : |
| ι → MvPowerSeries σ R := fun i => subst x (MvPowerSeries.pderiv (R := R) (Sum.inr i) f) |
|
|
| theorem gradientValue_vanishes (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) : |
| ∀ i, Vanishes 2 (gradientValue f x i) := by |
| intro i |
| exact (hf.pderiv _).subst x hx |
|
|
| theorem evaluated_remainder (f : MvPowerSeries (α ⊕ ι) R) |
| (H : Matrix ι ι (MvPowerSeries (Extended (α := α)) R)) |
| (hH : subst shiftedArguments f = subst baseArguments f + |
| (∑ i, X (Sum.inr i) * subst baseArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)) + |
| ∑ i, ∑ j, X (Sum.inr i) * H i j * X (Sum.inr j)) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) : |
| subst (shiftedGraph x δ) f = subst x f + dotProduct (gradientValue f x) δ + |
| dotProduct δ ((fun i j => subst (Sum.elim x δ) (H i j)) *ᵥ δ) := by |
| let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ) |
| have hh := congrArg (substAlgHom hs) hH |
| simp only [map_add, map_sum, map_mul, substAlgHom_apply, subst_X hs, |
| Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ] at hh |
| rw [hh] |
| congr 2 |
| · exact Finset.sum_congr rfl fun i _ => mul_comm _ _ |
| · simp only [dotProduct, mulVec, Finset.mul_sum, mul_assoc] |
|
|
| theorem evaluated_first_remainder (f : MvPowerSeries (α ⊕ ι) R) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) : |
| ∃ q : ι → MvPowerSeries σ R, |
| subst (shiftedGraph x δ) f - subst x f = dotProduct q δ := by |
| obtain ⟨q,_,hq⟩ := exists_first_remainder f |
| let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ) |
| refine ⟨fun i => subst (Sum.elim x δ) (q i), ?_⟩ |
| have hh := congrArg (substAlgHom hs) hq |
| simpa only [map_sub, map_sum, map_mul, substAlgHom_apply, subst_X hs, |
| Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ, |
| dotProduct] using hh |
|
|
| end BoundaryOnly.FormalObstruction.FormalCorrection |
|
|
| namespace BoundaryOnly.FormalObstruction.FormalCorrection |
| open MvPowerSeries Matrix |
| open scoped Classical |
| variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ] |
|
|
| omit [Finite σ] in |
| theorem mulVec_vanishes [Finite σ] {n : ℕ} (B : Matrix ι ι (MvPowerSeries σ R)) |
| (v : ι → MvPowerSeries σ R) (hv : ∀ i, Vanishes n (v i)) : |
| ∀ i, Vanishes n ((B *ᵥ v) i) := by |
| intro i |
| exact Vanishes.sum Finset.univ _ (fun j _ => (hv j).mul_left (B i j)) |
|
|
| omit [Finite σ] in |
| theorem quadratic_transpose [Finite σ] (B H : Matrix ι ι (MvPowerSeries σ R)) |
| (v : ι → MvPowerSeries σ R) : |
| dotProduct (B *ᵥ v) (H *ᵥ (B *ᵥ v)) = |
| dotProduct v ((B.transpose * H * B) *ᵥ v) := by |
| rw [← mulVec_mulVec, ← mulVec_mulVec, dotProduct_transpose_mulVec, dotProduct_comm] |
|
|
| omit [Fintype α] [Fintype ι] [Finite σ] in |
| theorem shiftedGraph_jet [Fintype α] [Fintype ι] [Finite σ] |
| {n : ℕ} (x : (α ⊕ ι) → MvPowerSeries σ R) |
| (δ : ι → MvPowerSeries σ R) (hδ : ∀ i, Vanishes n (δ i)) : |
| ∀ i, Jet n (shiftedGraph x δ i) (x i) := by |
| intro i |
| cases i with |
| | inl a => exact Jet.refl _ _ |
| | inr i => |
| change Vanishes n ((x (.inr i) + δ i) - x (.inr i)) |
| simpa only [add_sub_cancel_left] using hδ i |
|
|
| theorem exists_zero_correction (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) |
| (b : Matrix ι ι (MvPowerSeries σ R)) |
| (hg : subst x f = dotProduct (gradientValue f x) (b *ᵥ gradientValue f x)) : |
| ∃ B : Matrix ι ι (MvPowerSeries σ R), |
| subst (shiftedGraph x (B *ᵥ gradientValue f x)) f = 0 ∧ |
| (∀ i, Jet 2 (shiftedGraph x (B *ᵥ gradientValue f x) i) (x i)) := by |
| obtain ⟨H,hH,hTaylor⟩ := exists_taylor_remainder f hf |
| let v := gradientValue f x |
| have hv : ∀ i, Vanishes 2 (v i) := gradientValue_vanishes f hf x hx |
| obtain ⟨B,hB⟩ := exists_correction_matrix b H x v hH hx hv |
| have hδ := mulVec_vanishes B v hv |
| have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 := |
| fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega)) |
| refine ⟨B, ?_, shiftedGraph_jet x _ hδ⟩ |
| have ht := evaluated_remainder f H hTaylor x (B *ᵥ v) hx hδ0 |
| change subst (shiftedGraph x (B *ᵥ v)) f = _ at ht ⊢ |
| have heval : (fun i j => subst (Sum.elim x (B *ᵥ v)) (H i j)) = remainderValue H x v B := by |
| funext i j |
| unfold remainderValue |
| congr 1 |
| funext k |
| cases k <;> rfl |
| rw [heval, quadratic_transpose B, hg] at ht |
| have hz : b + B + B.transpose * remainderValue H x v B * B = 0 := by |
| change B = -b - B.transpose * remainderValue H x v B * B at hB |
| calc |
| _ = b + (-b - B.transpose * remainderValue H x v B * B) + |
| B.transpose * remainderValue H x v B * B := congrArg (fun A => b+A+B.transpose * remainderValue H x v B * B) hB |
| _ = 0 := by abel |
| rw [ht] |
| change dotProduct v (b *ᵥ v) + dotProduct v (B *ᵥ v) + |
| dotProduct v ((B.transpose * remainderValue H x v B * B) *ᵥ v) = 0 |
| rw [← dotProduct_add, ← add_mulVec, ← dotProduct_add, ← add_mulVec, hz] |
| simp |
|
|
| end BoundaryOnly.FormalObstruction.FormalCorrection |
|
|
| namespace BoundaryOnly.FormalObstruction.FormalCorrection |
| open MvPowerSeries Matrix |
| open scoped Classical |
| variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ] |
|
|
| theorem evaluated_gradient_remainder (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) |
| (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) : |
| ∃ G : Matrix ι ι (MvPowerSeries σ R), (∀ i j, Vanishes 1 (G i j)) ∧ |
| gradientValue f (shiftedGraph x δ) = gradientValue f x + G *ᵥ δ := by |
| obtain ⟨G,hG,hgrad⟩ := exists_gradient_remainder f hf |
| let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ) |
| refine ⟨fun i j => subst (Sum.elim x δ) (G i j), ?_, ?_⟩ |
| · intro i j |
| exact (hG i j).subst _ (extended_centered x δ hx hδ) |
| · funext i |
| have hh := congrArg (substAlgHom hs) (hgrad i) |
| simp only [map_sub, map_sum, map_mul, substAlgHom_apply, subst_X hs, |
| Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ] at hh |
| change gradientValue f (shiftedGraph x δ) i = gradientValue f x i + _ |
| change gradientValue f (shiftedGraph x δ) i - gradientValue f x i = _ at hh |
| exact sub_eq_iff_eq_add.mp hh |>.trans (add_comm _ _) |
|
|
| omit [Finite σ] in |
| theorem matrix_one_add_isUnit [Finite σ] (M : Matrix ι ι (MvPowerSeries σ R)) |
| (hM : ∀ i j, Vanishes 1 (M i j)) : IsUnit (1 + M) := by |
| have hc : (1 + M).map (constantCoeff (σ := σ) (R := R)) = 1 := by |
| ext i j |
| simp only [Matrix.map_apply, Matrix.add_apply, map_add, Vanishes.one_iff.mp (hM i j), add_zero] |
| simp only [Matrix.one_apply, apply_ite, map_one, map_zero] |
| split_ifs <;> rfl |
| apply ((1+M).isUnit_iff_isUnit_det).mpr |
| apply MvPowerSeries.isUnit_iff_constantCoeff.mpr |
| rw [RingHom.map_det] |
| change IsUnit (((1+M).map (constantCoeff (σ := σ) (R := R))).det) |
| rw [hc, Matrix.det_one] |
| exact isUnit_one |
|
|
| theorem gradient_transport (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) |
| (B : Matrix ι ι (MvPowerSeries σ R)) : |
| ∃ A : Matrix ι ι (MvPowerSeries σ R), IsUnit A ∧ |
| gradientValue f (shiftedGraph x (B *ᵥ gradientValue f x)) = A *ᵥ gradientValue f x := by |
| let v := gradientValue f x |
| have hv : ∀ i, Vanishes 2 (v i) := gradientValue_vanishes f hf x hx |
| have hδ := mulVec_vanishes B v hv |
| have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 := |
| fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega)) |
| obtain ⟨G,hG,hgrad⟩ := evaluated_gradient_remainder f hf x (B *ᵥ v) hx hδ0 |
| have hM : ∀ i j, Vanishes 1 ((G*B) i j) := by |
| intro i j |
| exact Vanishes.sum Finset.univ _ (fun k _ => (hG i k).mul_right (B k j)) |
| refine ⟨1+G*B, matrix_one_add_isUnit _ hM, ?_⟩ |
| rw [hgrad, Matrix.add_mulVec, Matrix.one_mulVec, ← Matrix.mulVec_mulVec] |
|
|
| def vectorIdeal (v : ι → MvPowerSeries σ R) : Ideal (MvPowerSeries σ R) := |
| Ideal.span (Set.range v) |
|
|
| omit [Fintype ι] [Finite σ] in |
| theorem vector_mem_vectorIdeal [Fintype ι] [Finite σ] |
| (v : ι → MvPowerSeries σ R) (i : ι) : |
| v i ∈ vectorIdeal v := Ideal.subset_span ⟨i,rfl⟩ |
|
|
| theorem mulVec_mem_vectorIdeal (A : Matrix ι ι (MvPowerSeries σ R)) |
| (v : ι → MvPowerSeries σ R) (i : ι) : (A *ᵥ v) i ∈ vectorIdeal v := by |
| apply Ideal.sum_mem |
| intro j _ |
| exact Ideal.mul_mem_left _ _ (vector_mem_vectorIdeal v j) |
|
|
| theorem vectorIdeal_mulVec_le (A : Matrix ι ι (MvPowerSeries σ R)) |
| (v : ι → MvPowerSeries σ R) : vectorIdeal (A *ᵥ v) ≤ vectorIdeal v := by |
| apply Ideal.span_le.mpr |
| rintro _ ⟨i,rfl⟩ |
| exact mulVec_mem_vectorIdeal A v i |
|
|
| theorem vectorIdeal_unit_mulVec (A : Matrix ι ι (MvPowerSeries σ R)) |
| (hA : IsUnit A) (v : ι → MvPowerSeries σ R) : vectorIdeal (A *ᵥ v) = vectorIdeal v := by |
| obtain ⟨u,rfl⟩ := hA |
| apply le_antisymm (vectorIdeal_mulVec_le _ v) |
| have h := vectorIdeal_mulVec_le (↑(u⁻¹) : Matrix ι ι (MvPowerSeries σ R)) ((↑u) *ᵥ v) |
| simpa only [mulVec_mulVec, Units.inv_mul, one_mulVec] using h |
|
|
| theorem gradient_ideal_transport (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) |
| (B : Matrix ι ι (MvPowerSeries σ R)) : |
| vectorIdeal (gradientValue f (shiftedGraph x (B *ᵥ gradientValue f x))) = |
| vectorIdeal (gradientValue f x) := by |
| obtain ⟨A,hA,h⟩ := gradient_transport f hf x hx B |
| rw [h] |
| exact vectorIdeal_unit_mulVec A hA _ |
|
|
| theorem scalar_transport_mem (g : MvPowerSeries (α ⊕ ι) R) |
| (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) |
| (v : ι → MvPowerSeries σ R) (hv : ∀ i, Vanishes 2 (v i)) |
| (B : Matrix ι ι (MvPowerSeries σ R)) : |
| subst (shiftedGraph x (B *ᵥ v)) g - subst x g ∈ vectorIdeal v := by |
| have hδ := mulVec_vanishes B v hv |
| have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 := |
| fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega)) |
| obtain ⟨q,hq⟩ := evaluated_first_remainder g x (B *ᵥ v) hx hδ0 |
| rw [hq] |
| apply Ideal.sum_mem |
| intro i _ |
| exact Ideal.mul_mem_left _ _ (mulVec_mem_vectorIdeal B v i) |
|
|
| end BoundaryOnly.FormalObstruction.FormalCorrection |
|
|
| end |
|
|
| end OAI |
|
|
