| import OAI.Algebra.Determinantal.RankTransfer |
|
|
| namespace OAI |
|
|
| namespace PermanentBorder.Polar |
| open scoped Classical |
| variable {ι : Type*} [Fintype ι] |
| |
| lemma isInvertible_of_injective (D : (ι → ℂ) →L[ℂ] (ι → ℂ)) |
| (hD : Function.Injective D) : D.IsInvertible := by |
| have hs : Function.Surjective D := (LinearMap.injective_iff_surjective).mp hD |
| let e := LinearEquiv.ofBijective D.toLinearMap ⟨hD,hs⟩ |
| exact ⟨e.toContinuousLinearEquiv, rfl⟩ |
|
|
| lemma normalizer_simple_restrict |
| (e : (Option ι → ℂ) ≃L[ℂ] (Option ι → ℂ)) |
| (F : (Option ι → ℂ) → (Option ι → ℂ)) |
| (hfirst : ∀ y, F y none = e y none - 1) (z : ι → ℂ) |
| (hF : DifferentiableAt ℂ F (affineNormChart e z)) |
| (hs : (fderiv ℂ F (affineNormChart e z)).IsInvertible) : |
| (fderiv ℂ (fun z i => F (affineNormChart e z) (some i)) z).IsInvertible := by |
| let D := (fderiv ℂ F (affineNormChart e z)).comp |
| (e.symm.toContinuousLinearMap.comp optionInsert) |
| have hfull : HasFDerivAt (fun z => F (affineNormChart e z)) D z := |
| hF.hasFDerivAt.comp z (affineNormChart_hasFDerivAt e z) |
| let E : (ι → ℂ) →L[ℂ] (ι → ℂ) := |
| ContinuousLinearMap.pi (fun i => (ContinuousLinearMap.proj (some i)).comp D) |
| have hred : HasFDerivAt (fun z i => F (affineNormChart e z) (some i)) E z := |
| hasFDerivAt_pi.mpr (fun i => (ContinuousLinearMap.proj (some i) : (Option ι → ℂ) →L[ℂ] ℂ).hasFDerivAt.comp z hfull) |
| have hzero : (fun z => F (affineNormChart e z) none) = fun _ => (0 : ℂ) := by |
| funext z |
| rw [hfirst, affineNormChart, e.apply_symm_apply] |
| simp |
| have hnone : (ContinuousLinearMap.proj none).comp D = 0 := by |
| have hd := (ContinuousLinearMap.proj none : (Option ι → ℂ) →L[ℂ] ℂ).hasFDerivAt.comp z hfull |
| change HasFDerivAt (fun z => F (affineNormChart e z) none) _ z at hd |
| rw [hzero] at hd |
| exact hd.unique (hasFDerivAt_const _ _) |
| rw [hred.fderiv] |
| apply isInvertible_of_injective |
| apply LinearMap.ker_eq_bot.mp |
| apply LinearMap.ker_eq_bot'.mpr |
| intro v hv |
| have hd : D v = 0 := by |
| funext i |
| cases i with |
| | none => exact congrArg (fun T : (ι → ℂ) →L[ℂ] ℂ => T v) hnone |
| | some i => exact congrFun hv i |
| have he : e.symm (optionInsert v) = 0 := hs.injective (hd.trans (map_zero _).symm) |
| have hi : optionInsert v = 0 := e.symm.injective (he.trans (map_zero _).symm) |
| exact funext (fun i => congrFun hi (some i)) |
|
|
| end PermanentBorder.Polar |
| namespace PermanentBorder.Polar |
| open MvPolynomial |
| open scoped Classical |
| variable {τ : Type*} [Fintype τ] |
|
|
| theorem smooth_polar_affine_certificate (f : MvPolynomial (PolarVars τ) ℂ) |
| {r : ℕ} (hr : 2 ≤ r) (hh : f.IsHomogeneous r) |
| (hs : ∀ y : PolarVars τ → ℂ, eval y f = 0 → |
| (∀ j, eval y (pderiv j f) = 0) → y = 0) : |
| ∃ w : τ → PolarVars τ → ℂ, |
| ∃ e : (PolarVars τ → ℂ) ≃L[ℂ] (PolarVars τ → ℂ), |
| ∃ x : Fin (r * (r-1)^Fintype.card τ) → Option τ → ℂ, |
| Function.Injective x ∧ |
| ∀ i, (fun j => eval (affineNormChart e (x i)) (hypersurfacePolars w f j)) = 0 ∧ |
| (fderiv ℂ (fun z j => eval (affineNormChart e z) |
| (hypersurfacePolars w f j)) (x i)).IsInvertible := by |
| classical |
| obtain ⟨w,l,hg,hcard⟩ := smooth_polar_count f hr hh hs |
| let R := CI.Roots (hypersurfacePolars w f) l |
| have hpos : 0 < Nat.card R := by |
| rw [show Nat.card R = _ from hcard] |
| exact Nat.mul_pos (by omega) (Nat.pow_pos (by omega)) |
| have : Finite R := (Nat.card_pos_iff.mp hpos).2 |
| let : Fintype R := Fintype.ofFinite R |
| have hcard' : Fintype.card R = r * (r-1)^Fintype.card τ := by |
| simpa only [Nat.card_eq_fintype_card] using hcard |
| let q : Fin (r * (r-1)^Fintype.card τ) ≃ R := (Fintype.equivFinOfCardEq hcard').symm |
| have hl : l ≠ 0 := by |
| intro hz |
| obtain ⟨y⟩ := (Nat.card_pos_iff.mp hpos).1 |
| have hy := y.property.2 |
| simp [CI.eval_linear, hz] at hy |
| obtain ⟨e,he⟩ := exists_normalizer_equiv l hl |
| have hy (i : Fin (r * (r-1)^Fintype.card τ)) : e (q i).val none = 1 := by |
| rw [he, ← CI.eval_linear] |
| exact (q i).property.2 |
| choose x hx using fun i => exists_chart_preimage e (hy i) |
| refine ⟨w,e,x,?_,?_⟩ |
| · intro i j hij |
| apply q.injective |
| apply Subtype.ext |
| rw [← hx i, ← hx j, hij] |
| · intro i |
| have hz : (fun j => eval (q i).val (CI.normalized (hypersurfacePolars w f) l j)) = 0 := |
| (CI.normalized_eval_zero_iff _ _ _).mpr (q i).property |
| constructor |
| · rw [hx i] |
| exact funext (q i).property.1 |
| · have hfirst (y : PolarVars τ → ℂ) : |
| eval y (CI.normalized (hypersurfacePolars w f) l none) = e y none - 1 := by |
| change eval y (CI.linear l - 1) = _ |
| rw [map_sub, map_one, CI.eval_linear, he] |
| apply normalizer_simple_restrict e |
| (fun y j => eval y (CI.normalized (hypersurfacePolars w f) l j)) hfirst (x i) |
| · exact ((contDiff_pi.mpr (fun j => CI.contDiff_eval |
| (CI.normalized (hypersurfacePolars w f) l j))).differentiable (by decide)) _ |
| · rw [hx i] |
| exact CI.good_derivative_invertible _ _ _ hg hz |
|
|
| end PermanentBorder.Polar |
|
|
| namespace PermanentBorder |
|
|
| open Filter |
| open scoped Topology |
|
|
| abbrev Variables (m : ℕ) := Fin m × Fin m |
| abbrev Poly (σ : Type*) := MvPolynomial σ ℂ |
|
|
| noncomputable def permanentPolynomial (m : ℕ) : Poly (Variables m) := |
| ∑ τ : Equiv.Perm (Fin m), ∏ i : Fin m, MvPolynomial.X (i, τ i) |
|
|
| noncomputable def affineMatrixPolynomial {σ : Type*} [Fintype σ] (n : ℕ) |
| (A₀ : Matrix (Fin n) (Fin n) ℂ) |
| (A : σ → Matrix (Fin n) (Fin n) ℂ) : Poly σ := |
| Matrix.det (fun i j => MvPolynomial.C (A₀ i j) + |
| ∑ v : σ, MvPolynomial.C (A v i j) * MvPolynomial.X v) |
|
|
| def HasBorderDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop := |
| 0 < n ∧ ∃ (A₀ : ℕ → Matrix (Fin n) (Fin n) ℂ) |
| (A : ℕ → σ → Matrix (Fin n) (Fin n) ℂ), |
| ∀ d : σ →₀ ℕ, Tendsto |
| (fun j => (affineMatrixPolynomial n (A₀ j) (A j)).coeff d) |
| atTop (𝓝 (p.coeff d)) |
|
|
| def HasExactDeterminant {σ : Type*} [Fintype σ] (n : ℕ) (p : Poly σ) : Prop := |
| 0 < n ∧ ∃ (A₀ : Matrix (Fin n) (Fin n) ℂ) |
| (A : σ → Matrix (Fin n) (Fin n) ℂ), affineMatrixPolynomial n A₀ A = p |
|
|
| theorem HasExactDeterminant.hasBorderDeterminant {σ : Type*} [Fintype σ] |
| {n : ℕ} {p : Poly σ} (h : HasExactDeterminant n p) : |
| HasBorderDeterminant n p := by |
| rcases h with ⟨hn, A₀, A, hp⟩ |
| refine ⟨hn, (fun _ => A₀), (fun _ => A), ?_⟩ |
| intro d |
| simpa only [hp] using |
| (tendsto_const_nhds : Tendsto (fun _ : ℕ => p.coeff d) atTop (𝓝 (p.coeff d))) |
|
|
| end PermanentBorder |
|
|
| namespace PermanentBorder |
| open MvPolynomial Filter |
| open scoped Topology |
|
|
| section FixedCoefficientSpace |
| variable {σ τ : Type*} [Fintype σ] |
|
|
| noncomputable def exponentCube (n : ℕ) : Finset (σ →₀ ℕ) := |
| by |
| classical |
| exact Finset.Iic (Finsupp.equivFunOnFinite.symm (fun _ : σ => n)) |
|
|
| @[simp] theorem mem_exponentCube (n : ℕ) (d : σ →₀ ℕ) : |
| d ∈ exponentCube (σ := σ) n ↔ ∀ i, d i ≤ n := by |
| classical |
| simp only [exponentCube, Finset.mem_Iic, Finsupp.le_def] |
| rfl |
|
|
| theorem support_subset_exponentCube {P : Poly σ} {n : ℕ} (hP : P.totalDegree ≤ n) : |
| P.support ⊆ exponentCube n := by |
| intro d hd |
| rw [mem_exponentCube] |
| intro i |
| exact (monomial_le_degreeOf i hd).trans ((degreeOf_le_totalDegree P i).trans hP) |
|
|
| theorem sum_over_exponentCube {P : Poly σ} {n : ℕ} |
| (hP : P.support ⊆ exponentCube n) : |
| P = ∑ d ∈ exponentCube n, monomial d (P.coeff d) := by |
| calc |
| P = ∑ d ∈ P.support, monomial d (P.coeff d) := MvPolynomial.as_sum P |
| _ = _ := ?_ |
| apply Finset.sum_subset hP |
| intro d _ hd |
| simp only [notMem_support_iff.mp hd, map_zero] |
|
|
| theorem coeff_linear_map_cube (F : Poly σ →ₗ[ℂ] Poly τ) {P : Poly σ} {n : ℕ} |
| (hP : P.support ⊆ exponentCube n) (e : τ →₀ ℕ) : |
| (F P).coeff e = ∑ d ∈ exponentCube n, |
| P.coeff d * (F (monomial d 1)).coeff e := by |
| conv_lhs => rw [sum_over_exponentCube hP] |
| simp only [map_sum, coeff_sum] |
| apply Finset.sum_congr rfl |
| intro d _ |
| rw [show monomial d (P.coeff d) = P.coeff d • monomial d (1 : ℂ) by simp [smul_monomial], |
| map_smul, coeff_smul, smul_eq_mul] |
|
|
| theorem support_subset_cube_of_limit {P : ℕ → Poly σ} {p : Poly σ} {n : ℕ} |
| (hP : ∀ j, (P j).support ⊆ exponentCube n) |
| (hp : ∀ d, Tendsto (fun j => (P j).coeff d) atTop (𝓝 (p.coeff d))) : |
| p.support ⊆ exponentCube n := by |
| classical |
| intro d hd |
| by_contra hn |
| have hz : ∀ j, (P j).coeff d = 0 := by |
| intro j |
| apply notMem_support_iff.mp |
| exact fun hj => hn (hP j hj) |
| have ht : Tendsto (fun _ : ℕ => (0 : ℂ)) atTop (𝓝 (p.coeff d)) := by |
| simpa only [hz] using hp d |
| have he : p.coeff d = 0 := (tendsto_nhds_unique tendsto_const_nhds ht).symm |
| exact mem_support_iff.mp hd he |
|
|
| theorem coefficientwise_linear_map_limit (F : Poly σ →ₗ[ℂ] Poly τ) |
| {P : ℕ → Poly σ} {p : Poly σ} {n : ℕ} |
| (hP : ∀ j, (P j).support ⊆ exponentCube n) |
| (hp : ∀ d, Tendsto (fun j => (P j).coeff d) atTop (𝓝 (p.coeff d))) : |
| ∀ e, Tendsto (fun j => (F (P j)).coeff e) atTop (𝓝 ((F p).coeff e)) := by |
| intro e |
| have hc := support_subset_cube_of_limit hP hp |
| have ht := tendsto_finsetSum (exponentCube (σ := σ) n) |
| (fun d _ => (hp d).mul (tendsto_const_nhds (x := (F (monomial d 1)).coeff e))) |
| convert ht using 1 |
| · funext j |
| exact coeff_linear_map_cube F (hP j) e |
| · congr 1 |
| exact coeff_linear_map_cube F hc e |
| end FixedCoefficientSpace |
|
|
| section DeterminantDegree |
| variable {σ : Type*} [Fintype σ] |
|
|
| theorem degree_affine_form (b : ℂ) (a : σ → ℂ) : |
| (C b + ∑ v : σ, C (a v) * X v : Poly σ).totalDegree ≤ 1 := by |
| apply (totalDegree_add _ _).trans |
| apply max_le |
| · simp |
| · apply totalDegree_finsetSum_le |
| intro v _ |
| exact (totalDegree_mul _ _).trans (by simp) |
|
|
| theorem degree_affineMatrixPolynomial (n : ℕ) |
| (A₀ : Matrix (Fin n) (Fin n) ℂ) (A : σ → Matrix (Fin n) (Fin n) ℂ) : |
| (affineMatrixPolynomial n A₀ A).totalDegree ≤ n := by |
| classical |
| unfold affineMatrixPolynomial |
| have he := Matrix.det_apply (show Matrix (Fin n) (Fin n) (Poly σ) from |
| fun i j => C (A₀ i j) + ∑ v, C (A v i j) * X v) |
| rw [he] |
| apply totalDegree_finsetSum_le |
| intro s _ |
| apply (totalDegree_smul_le _ _).trans |
| apply (totalDegree_finsetProd _ _).trans |
| calc |
| _ ≤ ∑ _ : Fin n, 1 := Finset.sum_le_sum fun i _ => degree_affine_form _ _ |
| _ = n := by simp |
| end DeterminantDegree |
|
|
| section AffineSubstitution |
| variable {σ τ : Type*} [Fintype σ] [Fintype τ] |
|
|
| noncomputable def affineSubstitution (b : σ → ℂ) (B : σ → τ → ℂ) : |
| Poly σ →ₐ[ℂ] Poly τ := |
| MvPolynomial.aeval (fun v => C (b v) + ∑ w : τ, C (B v w) * X w) |
|
|
| theorem affineSubstitution_matrix (b : σ → ℂ) (B : σ → τ → ℂ) |
| (n : ℕ) (A₀ : Matrix (Fin n) (Fin n) ℂ) (A : σ → Matrix (Fin n) (Fin n) ℂ) : |
| affineSubstitution b B (affineMatrixPolynomial n A₀ A) = |
| affineMatrixPolynomial n |
| (fun i j => A₀ i j + ∑ v : σ, A v i j * b v) |
| (fun w i j => ∑ v : σ, A v i j * B v w) := by |
| classical |
| unfold affineMatrixPolynomial |
| have he := RingHom.map_det (affineSubstitution b B).toRingHom |
| (show Matrix (Fin n) (Fin n) (Poly σ) from |
| fun i j => C (A₀ i j) + ∑ v, C (A v i j) * X v) |
| refine he.trans ?_ |
| apply congrArg Matrix.det |
| funext i j |
| change (affineSubstitution b B) (C (A₀ i j) + ∑ v, C (A v i j) * X v) = |
| C (A₀ i j + ∑ v, A v i j * b v) + ∑ w, C (∑ v, A v i j * B v w) * X w |
| simp only [affineSubstitution, map_add, map_sum, map_mul, |
| aeval_C, aeval_X, algebraMap_eq] |
| simp only [mul_add, Finset.mul_sum, Finset.sum_add_distrib, ← map_mul] |
| rw [← add_assoc] |
| congr 1 |
| rw [Finset.sum_comm] |
| simp only [Finset.sum_mul, map_mul, mul_assoc] |
|
|
| theorem HasBorderDeterminant.affineSubstitution {n : ℕ} {p : Poly σ} |
| (h : HasBorderDeterminant n p) (b : σ → ℂ) (B : σ → τ → ℂ) : |
| HasBorderDeterminant n (affineSubstitution b B p) := by |
| classical |
| obtain ⟨hn, A₀, A, hlim⟩ := h |
| refine ⟨hn, |
| (fun l i j => A₀ l i j + ∑ v : σ, A l v i j * b v), |
| (fun l w i j => ∑ v : σ, A l v i j * B v w), ?_⟩ |
| have hf := coefficientwise_linear_map_limit (PermanentBorder.affineSubstitution b B).toLinearMap |
| (fun l => support_subset_exponentCube (degree_affineMatrixPolynomial n (A₀ l) (A l))) hlim |
| intro e |
| simpa only [AlgHom.toLinearMap_apply, affineSubstitution_matrix] using hf e |
| end AffineSubstitution |
| end PermanentBorder |
|
|
| namespace PermanentBorder |
| open MvPolynomial Filter |
| open scoped Topology |
|
|
| section ScalarNormalization |
| variable {σ : Type*} [Fintype σ] |
|
|
| theorem affineMatrixPolynomial_scaleRow (n : ℕ) (i₀ : Fin n) (a : ℂ) |
| (A₀ : Matrix (Fin n) (Fin n) ℂ) (A : σ → Matrix (Fin n) (Fin n) ℂ) : |
| affineMatrixPolynomial n (A₀.updateRow i₀ (a • A₀ i₀)) |
| (fun v => (A v).updateRow i₀ (a • A v i₀)) = |
| a • affineMatrixPolynomial n A₀ A := by |
| classical |
| let M : Matrix (Fin n) (Fin n) (Poly σ) := |
| fun i j => C (A₀ i j) + ∑ v, C (A v i j) * X v |
| let M' : Matrix (Fin n) (Fin n) (Poly σ) := fun i j => |
| C ((A₀.updateRow i₀ (a • A₀ i₀)) i j) + |
| ∑ v, C (((A v).updateRow i₀ (a • A v i₀)) i j) * X v |
| have hM : M' = M.updateRow i₀ ((C a : Poly σ) • M i₀) := by |
| funext i j |
| change C ((A₀.updateRow i₀ (a • A₀ i₀)) i j) + (∑ v, |
| C (((A v).updateRow i₀ (a • A v i₀)) i j) * X v) = _ |
| by_cases hi : i = i₀ |
| · subst i |
| rw [Matrix.updateRow_self, Matrix.updateRow_self] |
| simp only [Matrix.updateRow_self, Pi.smul_apply, smul_eq_mul, map_mul] |
| change _ = C a * (C (A₀ i₀ j) + ∑ v, C (A v i₀ j) * X v) |
| simp only [mul_add, Finset.mul_sum, mul_assoc] |
| · rw [Matrix.updateRow_ne hi, Matrix.updateRow_ne hi] |
| simp only [Matrix.updateRow_ne hi] |
| rfl |
| change M'.det = a • M.det |
| rw [hM] |
| rw [Matrix.det_updateRow_smul] |
| rw [Matrix.updateRow_eq_self] |
| exact (MvPolynomial.smul_eq_C_mul M.det a).symm |
|
|
| theorem HasBorderDeterminant.smul {n : ℕ} {p : Poly σ} |
| (h : HasBorderDeterminant n p) (a : ℂ) : HasBorderDeterminant n (a • p) := by |
| classical |
| obtain ⟨hn, A₀, A, hlim⟩ := h |
| let i₀ : Fin n := ⟨0, hn⟩ |
| refine ⟨hn, (fun l => (A₀ l).updateRow i₀ (a • A₀ l i₀)), |
| (fun l v => (A l v).updateRow i₀ (a • A l v i₀)), ?_⟩ |
| intro e |
| simp only [affineMatrixPolynomial_scaleRow, coeff_smul, smul_eq_mul] |
| exact tendsto_const_nhds.mul (hlim e) |
|
|
| theorem HasBorderDeterminant.affineSubstitution_smul |
| {τ : Type*} [Fintype τ] {n : ℕ} {p : Poly σ} |
| (h : HasBorderDeterminant n p) (b : σ → ℂ) (B : σ → τ → ℂ) (a : ℂ) : |
| HasBorderDeterminant n (a • PermanentBorder.affineSubstitution b B p) := |
| (h.affineSubstitution b B).smul a |
| end ScalarNormalization |
| end PermanentBorder |
|
|
| end OAI |
|
|
