| import OAI.Combinatorics.HadwigerCounterexample.BooleanLabels |
| import OAI.Combinatorics.HadwigerCounterexample.QuadraticTesters |
| import OAI.Combinatorics.HadwigerCounterexample.CoordinateEmbeddings |
|
|
| namespace OAI |
|
|
| /-! # Coordinate Blocks -/ |
|
|
| noncomputable section |
| namespace HadwigerCounterexample |
| open Matrix |
| open scoped BigOperators |
| variable {p : Shape} {n : ℕ} |
|
|
| def blockA (p : Shape) (n : ℕ) (B : Block p.g) : Mat (AIdx p.g n) (Fin n) := |
| embedMat (fun i => some (B,i)) |
|
|
| def blockRay (p : Shape) (n : ℕ) (s : Label p.b) (B : Block p.g) : Mat (Row p n) (Fin n) := |
| labMat p n s * blockA p n B |
|
|
| theorem lab_inj (s : Label p.b) : Function.Injective (labMat p n s).mulVec := by |
| intro x y he |
| funext i |
| rw [labMat_act,labMat_act] at he |
| have h := congr_fun he (emptySel,i) |
| simpa [putLab,selV,emptySel] using h |
|
|
| theorem joined_lab_inj {s t : Label p.b} (hj : 1≤p.j) (hs : s≠t) : |
| Function.Injective (fromCols (labMat p n s) (labMat p n t)).mulVec := by |
| apply inj_fromCols (lab_inj _) (lab_inj _) |
| classical |
| rw [disjoint_iff_inf_le] |
| rintro x ⟨⟨v,rfl⟩,w,h⟩ |
| simp only [mulVecLin_apply,labMat_act] at h |
| let Z : Label p.b → Vec (AIdx p.g n) := fun i => if i=s then v else -w |
| have he : ∑ i ∈ ({s,t} : Finset _), putLab p n i (Z i)=0 := by |
| simp [Z,hs,hs.symm,map_neg,h] |
| have hi : ({s,t}:Finset _).card ≤ p.j+1 := by |
| have hh : ({s,t}:Finset _).card=2 := by simp [hs] |
| omega |
| have hg := ray_indep _ _ hi he s (by simp) |
| have hv : v=0 := by simpa [Z] using hg |
| rw [hv,map_zero]; exact Submodule.zero_mem _ |
|
|
| theorem block_inj (B : Block p.g) : Function.Injective (blockA p n B).mulVec := |
| embedMat_inj (show Function.Injective (fun i => some (B,i)) from |
| fun _ _ h => congrArg Prod.snd (Option.some.inj h)) |
|
|
| theorem blockRay_inj (p : Shape) (n) (s) (B) : |
| Function.Injective (blockRay p n s B).mulVec := |
| inj_comp_mat _ _ (lab_inj _) (block_inj B) |
|
|
| theorem joined_block_inj {s t : Label p.b} (hj : 1 ≤ p.j) (hs : s ≠ t) (B : Block p.g) : |
| Function.Injective (fromCols (blockRay p n s B) (blockRay p n t B)).mulVec := by |
| classical |
| apply inj_fromCols (blockRay_inj ..) (blockRay_inj ..) |
| rw [disjoint_iff_inf_le] |
| rintro x ⟨⟨v,rfl⟩,w,h⟩ |
| simp only [Matrix.mulVecLin_apply,blockRay,← Matrix.mulVec_mulVec] at h |
| let a := Sum.elim (blockA p n B *ᵥ v) (0 : Vec (AIdx p.g n)) |
| let b := Sum.elim (0 : Vec (AIdx p.g n)) (blockA p n B *ᵥ w) |
| have heq : a=b := joined_lab_inj hj hs (by |
| dsimp only [a,b] |
| rw [fromCols_mulVec_sumElim,fromCols_mulVec_sumElim,Matrix.mulVec_zero, |
| Matrix.mulVec_zero,zero_add,add_zero,h]) |
| have hg : blockA p n B *ᵥ v = 0 := funext (fun x => congr_fun heq (.inl x)) |
| change blockRay p n s B *ᵥ v ∈ _ |
| rw [blockRay,← Matrix.mulVec_mulVec,hg,Matrix.mulVec_zero] |
| exact Submodule.zero_mem _ |
|
|
| theorem blockRay_eval (p : Shape) (s : Label p.b) (B) (i) (j : Fin n) : |
| blockRay p n s B i j = if i.2=some (B,j) then monoBit s i.1.val else 0 := by |
| rw [blockRay,blockA,mul_embedMat]; rfl |
|
|
| theorem project_pick {d B : Block p.g} (hd : d ≠ B) (a) (s) (i) : |
| (blockRay p n s B)ᵀ *ᵥ pick p n a d i = 0 := by |
| classical |
| unfold pick |
| split |
| · rename_i hi |
| rw [Matrix.mulVec_single_one] |
| ext j |
| change blockRay p n s B (a,some (d,⟨i,hi⟩)) j=0 |
| simp [blockRay_eval,hd] |
| rw [Matrix.mulVec_zero] |
|
|
| theorem project_same (B : Block p.g) (a s) (i : Fin n) : |
| (blockRay p n s B)ᵀ *ᵥ pick p n a B i.val = Pi.single i (monoBit s a.val) := by |
| classical |
| rw [pick,dite_eq_left i.isLt,Matrix.mulVec_single_one] |
| ext j |
| change blockRay p n s B _ j=_ |
| rw [blockRay_eval] |
| simp [Pi.single_apply, eq_comm] |
|
|
| def pullM {I J V U : Type} [Fintype V] [Fintype U] (P : Mat V I) (Q : Mat U J) : |
| Mat V U →ₗ[F] Mat I J := liftM Pᵀ Qᵀ |
| theorem pullM_def {I J V U : Type} [Fintype V] [Fintype U] (P : Mat V I) |
| (Q : Mat U J) (M : Mat V U) : pullM P Q M=Pᵀ*M*Q := rfl |
|
|
| theorem pull_test {d B : Block p.g} (h : d≠B) (s s') : |
| pullM (blockRay p n s B) (blockRay p n s' B) (testM p n d) = 0 := by |
| unfold testM pullM |
| simp only [map_sum,liftM_outer,project_pick h] |
| simp |
|
|
| theorem pull_self_Z (M) (s s' : Label p.b) : |
| pullM (blockRay p n s Block.Z) (blockRay p n s' Block.Z) (selfM p n M)=0 := by |
| let L := pullM (blockRay p n s Block.Z) (blockRay p n s' Block.Z) |
| have hx (i j : Tag p.g) := pull_test (n:=n) (d:=Block.O i j) |
| (B:=Block.Z) (by simp [Block.O,Block.Z]) s s' |
| have hs := pull_test (p:=p) (n:=n) (d:=Block.S) (B:=Block.Z) (by simp [Block.S,Block.Z]) s s' |
| have h (a : SelIdx p.b p.j) (s : Label p.b) (i) := |
| project_pick (n:=n) (p:=p) (d:=Block.sharp) (B:=Block.Z) (by simp [Block.sharp,Block.Z]) a s i |
| rw [selfM]; simp only [map_add,map_sum,hx,hs,Finset.sum_const_zero,zero_add] |
| unfold sharpM sharpPick pullM |
| by_cases he : 1 ≤ p.j |
| · simp only [map_sum,map_smul,map_add, dite_eq_left he,liftM_outer,h] |
| simp |
| · simp only [dite_eq_right he]; simp |
|
|
| theorem pull_self_sharp (M) (s s' : Label p.b) (hj : 1≤p.j) : |
| pullM (blockRay p n s Block.sharp) (blockRay p n s' Block.sharp) (selfM p n M) = |
| ∑ i, (s i+s' i) • M i := by |
| classical |
| have hx (i j : Tag p.g) := pull_test (n:=n) (d:=Block.O i j) |
| (B:=Block.sharp) (by simp [Block.O,Block.sharp]) s s' |
| have hs := pull_test (p:=p) (n:=n) (d:=Block.S) (B:=Block.sharp) (by simp [Block.S,Block.sharp]) s s' |
| rw [selfM]; simp only [map_add,map_sum,hx,hs,Finset.sum_const_zero,zero_add] |
| unfold sharpM sharpPick pullM |
| simp only [map_sum,map_add,map_smul, dite_eq_left hj,liftM_outer,project_same] |
| refine Finset.sum_congr rfl fun i _ => ?_ |
| ext a b |
| simp only [Matrix.sum_apply,Matrix.add_apply,Matrix.smul_apply,smul_eq_mul, |
| vecMulVec_apply,monoBit,emptySel,Finset.prod_empty,Finset.prod_singleton,Pi.single_apply] |
| rw [Finset.sum_eq_single a] |
| · rw [Finset.sum_eq_single b] |
| · simp; ring |
| · intro j _ h; simp [h.symm] |
| · simp |
| · intro j _ h; simp [h.symm] |
| simp |
| end HadwigerCounterexample |
|
|
| end |
|
|
| end OAI |
|
|
