| import OAI.Combinatorics.Crossing.Interpolation |
| import Mathlib.LinearAlgebra.Finsupp.Defs |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace Zarankiewicz |
| open PolynomialModule |
|
|
| abbrev BiPoly := PolynomialModule ℝ (PolynomialModule ℝ ℝ) |
|
|
| def biCoeff (p : BiPoly) (a b : ℕ) : ℝ := (p.coeff a).coeff b |
|
|
| def biEval (u v : ℝ) : BiPoly →ₗ[ℝ] ℝ := (eval v).comp (eval u) |
|
|
| def BiBounded (r s : ℕ) (p : BiPoly) : Prop := |
| Bounded r p ∧ ∀ a, Bounded s (p.coeff a) |
|
|
| def flattenBi : BiPoly ≃ₗ[ℝ] (ℕ × ℕ →₀ ℝ) := |
| ((coeffLinearEquiv ℝ ℝ).trans |
| (Finsupp.mapRange.linearEquiv (coeffLinearEquiv ℝ ℝ))).trans |
| (Finsupp.curryLinearEquiv ℝ).symm |
|
|
| theorem flattenBi_apply (p : BiPoly) (a b : ℕ) : flattenBi p (a,b) = biCoeff p a b := rfl |
|
|
| def swapBi : BiPoly ≃ₗ[ℝ] BiPoly := |
| (flattenBi.trans (Finsupp.mapDomain.linearEquiv ℝ ℝ (Equiv.prodComm ℕ ℕ))).trans |
| flattenBi.symm |
|
|
| theorem biCoeff_swap (p : BiPoly) (a b : ℕ) : biCoeff (swapBi p) a b = biCoeff p b a := by |
| rw [← flattenBi_apply] |
| change flattenBi (flattenBi.symm _) (a,b) = _ |
| rw [LinearEquiv.apply_symm_apply] |
| exact Finsupp.mapDomain_equiv_apply (flattenBi p) (a,b) |
|
|
| theorem bi_ext {p q : BiPoly} (h : ∀ a b, biCoeff p a b = biCoeff q a b) : p = q := by |
| apply PolynomialModule.ext |
| apply Finsupp.ext |
| intro a |
| apply PolynomialModule.ext |
| apply Finsupp.ext |
| exact h a |
|
|
| theorem swapBi_swapBi (p : BiPoly) : swapBi (swapBi p) = p := by |
| apply bi_ext |
| intro a b |
| rw [biCoeff_swap, biCoeff_swap] |
|
|
| theorem swapBi_single (a b : ℕ) (c : ℝ) : |
| swapBi (single ℝ a (single ℝ b c)) = single ℝ b (single ℝ a c) := by |
| apply bi_ext |
| intro i j |
| rw [biCoeff_swap] |
| simp [biCoeff, Finsupp.single_apply] |
| split_ifs <;> simp_all |
|
|
| theorem biEval_swap (p : BiPoly) (u v : ℝ) : biEval u v (swapBi p) = biEval v u p := by |
| induction p using PolynomialModule.induction_linear with |
| | zero => simp |
| | add p q hp hq => simp only [map_add, hp, hq] |
| | single a q => |
| induction q using PolynomialModule.induction_linear with |
| | zero => simp |
| | add p q hp hq => simp only [single_add, map_add, hp, hq] |
| | single b c => |
| rw [swapBi_single] |
| simp [biEval, eval_single, smul_eq_mul] |
| ring |
|
|
| theorem biBounded_swap {r s : ℕ} {p : BiPoly} (hp : BiBounded r s p) : |
| BiBounded s r (swapBi p) := by |
| constructor |
| · intro a ha |
| apply PolynomialModule.ext |
| apply Finsupp.ext |
| intro b |
| change biCoeff (swapBi p) a b = 0 |
| rw [biCoeff_swap] |
| exact hp.2 b a ha |
| · intro a b hb |
| change biCoeff (swapBi p) a b = 0 |
| rw [biCoeff_swap] |
| simp [biCoeff, hp.1 b hb] |
|
|
| def boundedSpace (k : ℕ) : Submodule ℝ (PolynomialModule ℝ ℝ) where |
| carrier := {p | Bounded k p} |
| zero_mem' := bounded_zero k |
| add_mem' := bounded_add |
| smul_mem' := by |
| intro c p hp n hn |
| change c • p.coeff n = 0 |
| rw [hp n hn, smul_zero] |
|
|
| theorem coefficients_of_mulRoot {W : Type*} [AddCommGroup W] [Module ℝ W] |
| (Z : Submodule ℝ W) (t : ℝ) (k : ℕ) (q : PolynomialModule ℝ W) |
| (hq : Bounded k q) (hc : ∀ n, (mulRoot t q).coeff n ∈ Z) : |
| ∀ n, q.coeff n ∈ Z := by |
| have aux : ∀ d n, k-n = d → q.coeff n ∈ Z := by |
| intro d |
| induction d with |
| | zero => |
| intro n hn |
| rw [hq n (by omega)] |
| exact Z.zero_mem |
| | succ d ih => |
| intro n hn |
| have hh := Z.add_mem (hc (n+1)) (Z.smul_mem t (ih (n+1) (by omega))) |
| simpa only [mulRoot_coeff_succ, sub_add_cancel] using hh |
| intro n |
| exact aux (k-n) n rfl |
|
|
| theorem bi_factor_row (r s : ℕ) (p : BiPoly) (hp : BiBounded (r+1) s p) |
| (t : ℝ) (hz : eval t p = 0) : |
| ∃ q : BiPoly, BiBounded r s q ∧ mulRoot t q = p := by |
| obtain ⟨q, hq, he⟩ := exists_mulRoot_of_eval_zero t r p hp.1 hz |
| refine ⟨q, ⟨hq, ?_⟩, he⟩ |
| apply coefficients_of_mulRoot (boundedSpace s) t r q hq |
| intro n |
| rw [he] |
| exact hp.2 n |
|
|
| theorem biEval_mulRoot (t u v : ℝ) (p : BiPoly) : |
| biEval u v (mulRoot t p) = (u-t) * biEval u v p := by |
| change eval v (eval u (mulRoot t p)) = _ |
| rw [eval_mulRoot, _root_.map_smul] |
| rfl |
|
|
| theorem bounded_eval_outer {r s : ℕ} {p : BiPoly} (hp : BiBounded r s p) (u : ℝ) : |
| Bounded s (eval u p) := by |
| change eval u p ∈ boundedSpace s |
| change p.coeff.sum (fun a c => u^a • c) ∈ boundedSpace s |
| apply Submodule.sum_mem |
| intro a ha |
| exact (boundedSpace s).smul_mem (u^a) (hp.2 a) |
|
|
| end Zarankiewicz |
|
|
| end |
|
|
| end OAI |
|
|
