Download data/lean/OAI/Combinatorics/Crossing/Bivariate.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.47 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/Crossing/Bivariate.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/Crossing/Bivariate.lean
-
curl -L -o Bivariate.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/Crossing/Bivariate.lean
4.47 kB
| 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 | |