| import OAI.Computability.FourierTransform.DirectionalWords |
|
|
| namespace OAI |
|
|
| namespace PowerSaving.Cluster |
| open Finset Binary |
| /-! Binary network with 32 coordinates. Triple indicators omit two fixed pivots. |
| Unused ordered side pairs can also have storage assigned. -/ |
|
|
| abbrev H := Fin 32 |
| abbrev J := Fin 3 |
| abbrev Blocks := J → H |
| abbrev Mask := Finset Blocks |
| def freeSet : Finset H := univ \ {0,1} |
| def tripSet := freeSet.powersetCard 3 |
| abbrev Trip := ↑tripSet |
|
|
| lemma piv : (0:H) ≠ 1 := by decide |
|
|
| lemma trip_card (x : Trip) : x.val.card = 3 := |
| (Finset.mem_powersetCard.mp x.property).2 |
|
|
| lemma trip_sub (x : Trip) : x.val ⊆ freeSet := |
| (Finset.mem_powersetCard.mp x.property).1 |
|
|
| lemma num_trip : Fintype.card Trip = 4060 := by |
| rw [Fintype.card_coe tripSet, tripSet, Finset.card_powersetCard] |
| have hf : freeSet.card = 30 := by |
| rw [freeSet, card_sdiff_of_subset (subset_univ _)] |
| simp |
| rw [hf, Nat.choose_eq_descFactorial_div_factorial] |
| decide |
|
|
| def meet (x y : Trip) := (x.val ∩ y.val).card |
| def neighbor (x y : Trip) := meet x y = 0 ∨ meet x y = 2 |
| instance (x y : Trip) : Decidable (neighbor x y) := by unfold neighbor; infer_instance |
|
|
| lemma meet_comm (x y : Trip) : meet x y = meet y x := by simp [meet, inter_comm] |
| lemma meet_self (x : Trip) : meet x x=3 := by simp [meet, trip_card] |
| lemma meet_le (x y : Trip) (h : x≠y) : meet x y ≤ 2 := by |
| unfold meet |
| have hi := card_le_card (inter_subset_left (s₁:=x.val) (s₂:=y.val)) |
| by_contra he |
| have hh : (x.val ∩ y.val).card = 3 := by have := trip_card x; omega |
| have hx : x.val ∩ y.val = x.val := |
| eq_of_subset_of_card_le inter_subset_left (by simp [hh,trip_card]) |
| have hy : x.val ∩ y.val = y.val := |
| eq_of_subset_of_card_le inter_subset_right (by simp [hh,trip_card]) |
| exact h (Subtype.ext (hx.symm.trans hy)) |
|
|
| lemma neighbor_comm (x y : Trip) : neighbor x y ↔ neighbor y x := by |
| simp only [neighbor, meet_comm x y] |
|
|
| def tip (x : Trip) : Space H := fun i => if i∈x.val then 1 else 0 |
|
|
| / |
| theorem meet_ind {R : Type*} [Semiring R] (x y : Trip) : |
| ∑ i : H, ((if i ∈ x.val then (1:R) else 0)*(if i ∈ y.val then 1 else 0)) |
| = (meet x y:R) := by |
| calc |
| _ = ∑ i ∈ (univ:Finset H), (if i∈x.val∩y.val then (1:R) else 0) := by |
| apply sum_congr rfl |
| intro i hi |
| by_cases hx : i∈x.val <;> by_cases hy : i∈y.val <;> simp [*] |
| _ = ∑ i ∈ x.val∩y.val, (1:R) := by |
| rw [← sum_filter] |
| apply sum_congr _ (fun _ _ => rfl) |
| ext; simp |
| _ = _ := by simp [meet] |
|
|
| @[simp] theorem tip_unit (x : Trip) : dot (tip x) (tip x)=1 := by |
| unfold dot tip |
| rw [meet_ind, meet_self] |
| decide |
|
|
| @[simp] theorem tip_zero (x : Trip) : tip x 0 = 0 := by |
| have h : 0∉x.val := by intro hh; have := trip_sub x hh; simp [freeSet] at this |
| simp [tip,h] |
| @[simp] theorem tip_one (x : Trip) : tip x 1 = 0 := by |
| have h : 1∉x.val := by intro hh; have := trip_sub x hh; simp [freeSet] at this |
| simp [tip,h] |
|
|
| theorem tip_orth (x y : Trip) (h : neighbor x y) : |
| dot (tip x) (tip y)=0 := by |
| unfold dot tip |
| rw [meet_ind] |
| obtain he|he := h <;> rw [he] <;> decide |
|
|
| def tripBase (x : Trip) : OBase H := |
| OBase.adapt (OBase.canonical H) 0 (tip x) (tip_unit x) |
| (by simp [OBase.canonical]) |
|
|
| @[simp] theorem tripBase_main (x : Trip) : (tripBase x).v 0 = tip x := |
| OBase.adapt_pivot _ _ _ _ _ |
| @[simp] theorem tripBase_unused (x : Trip) : (tripBase x).v 1 = eu 1 := |
| OBase.adapt_other _ _ _ _ piv _ _ (by simp [OBase.canonical]) |
|
|
| def pairBase (x y : Trip) : OBase H := |
| if h : neighbor x y then |
| OBase.adapt (tripBase x) 1 (tip y) (tip_unit y) (by simp) |
| else OBase.canonical H |
|
|
| @[simp] lemma pairBase_left (x y : Trip) (h : neighbor x y) : |
| (pairBase x y).v 0 = tip x := by |
| unfold pairBase; rw [dite_eq_left h] |
| rw [OBase.adapt_other, tripBase_main] |
| · exact piv.symm |
| · simp [dot_symm (tip y), tip_orth x y h] |
|
|
| @[simp] lemma pairBase_right (x y : Trip) (h : neighbor x y) : |
| (pairBase x y).v 1 = tip y := by |
| unfold pairBase; rw [dite_eq_left h,OBase.adapt_pivot] |
|
|
| section Masks |
|
|
| / |
| future fixed zero. -/ |
| def sets (j : J) (e : Bool) (s : Finset H) (i : J) : Finset H := |
| if i=j then s else if i<j ∧ e=true then univ else {0} |
|
|
| def rect (j : J) (e : Bool) (s : Finset H) : Mask := |
| Fintype.piFinset (sets j e s) |
|
|
| def future (j : J) (x : Blocks) := ∀ i : J, j < i → x i=0 |
| def previous (j : J) (x : Blocks) := ∀ i : J, i<j → x i=0 |
|
|
| lemma mem_rect (j : J) (e : Bool) (s : Finset H) (x) : |
| x ∈ rect j e s ↔ future j x ∧ (e=false → previous j x) ∧ x j∈s := by |
| rw [rect, Fintype.mem_piFinset] |
| constructor |
| · intro h |
| refine ⟨fun i hi => ?_, fun hg i hi => ?_, by simpa [sets] using h j⟩ |
| · simpa [sets, ne_of_gt hi, not_lt.mpr hi.le] using h i |
| · simpa [sets, hg, ne_of_lt hi] using h i |
| · rintro ⟨hf,hg,hs⟩ i |
| unfold sets |
| rcases lt_trichotomy i j with h|h|h |
| · cases e |
| · simp [ne_of_lt h, hg rfl i h] |
| · simp [ne_of_lt h,h] |
| · subst i; simp [hs] |
| · simp [ne_of_gt h, not_lt.mpr h.le, hf i h] |
|
|
| |
| def big (j : J) : Mask := rect j true univ |
| def belt (j : J) : Mask := big j \ rect j false univ |
| def xstart (j : J) (slot : H) : Mask := rect j true {slot} |
| def ystart (j : J) (slot : H) : Mask := xstart j slot \ rect j false {slot} |
| / |
| def xstep (j : J) (slot : H) : Mask := big j \ rect j false (univ \ {slot}) |
| def ystep (j : J) (slot : H) : Mask := big j \ rect j false {slot} |
|
|
| theorem in_big (j : J) (x) : x ∈ big j ↔ future j x := by simp [big, mem_rect] |
| theorem in_belt (j : J) (x) : x ∈ belt j ↔ future j x ∧ ¬previous j x := by |
| simp [belt, in_big, mem_rect]; tauto |
| theorem in_xstart (j : J) (slot : H) (x) : |
| x∈xstart j slot ↔ future j x ∧ x j=slot := by simp [xstart,mem_rect] |
| theorem in_ystart (j : J) (slot : H) (x) : |
| x∈ystart j slot ↔ future j x ∧ ¬previous j x ∧ x j=slot := by |
| simp [ystart,in_xstart,mem_rect]; tauto |
| theorem in_xstep (j : J) (slot : H) (x) : |
| x∈xstep j slot ↔ future j x ∧ (¬previous j x ∨ x j=slot) := by |
| simp [xstep, in_big,mem_rect]; tauto |
| theorem in_ystep (j : J) (slot : H) (x) : |
| x∈ystep j slot ↔ future j x ∧ (¬previous j x ∨ x j≠slot) := by |
| simp [ystep, in_big,mem_rect]; tauto |
|
|
| lemma rect_le_big (j : J) (e : Bool) (s : Finset H) : |
| rect j e s ⊆ big j := |
| fun k h => (in_big j k).2 ((mem_rect ..).1 h).1 |
|
|
| lemma belt_drop (j : J) : |
| (big j \ belt j).card = 32 := by |
| have hs := rect_le_big j false univ |
| have eq : big j \ belt j = rect j false univ := by |
| ext k |
| simp only [belt, mem_sdiff] |
| have h : k ∈ rect j false univ → k∈big j := fun hh => hs hh |
| tauto |
| rw [eq, rect, Fintype.card_piFinset] |
| rw [Finset.prod_eq_single j] |
| · simp [sets] |
| all_goals |
| first | intro i _ hi; simp [sets, hi] | simp |
|
|
| / |
| lemma rect_proj {b d : J → OBase H} {j : J} {s t : Finset H} |
| (hi : ∀ i, i ≠ j → b i = d i) |
| (hh : (b j).mat s = (d j).mat t) (e : Bool) : |
| (OBase.tensor b).mat (rect j e s) = (OBase.tensor d).mat (rect j e t) := by |
| unfold rect |
| rw [OBase.mat_rect,OBase.mat_rect] |
| apply congrArg (fun f : J → Matrix H H F => digitProd f) |
| funext k |
| by_cases h : k=j |
| · subst k; simpa [sets] using hh |
| · simp [sets, h, hi k h] |
|
|
| lemma singleton_proj {b d : OBase H} {i k : H} (h : b.v i=d.v k) : |
| b.mat {i}=d.mat {k} := by |
| ext j l |
| simp [OBase.mat, h] |
|
|
| lemma big_proj {b d : J → OBase H} {j : J} (hi : ∀ i, i ≠ j → b i = d i) : |
| (OBase.tensor b).mat (big j) = (OBase.tensor d).mat (big j) := |
| rect_proj hi (by simp) _ |
|
|
| lemma belt_proj {b d : J → OBase H} {j : J} (hi : ∀ i, i ≠ j → b i = d i) : |
| (OBase.tensor b).mat (belt j) = (OBase.tensor d).mat (belt j) := by |
| unfold belt |
| rw [OBase.mat_sub _ _ _ (rect_le_big ..), OBase.mat_sub _ _ _ (rect_le_big ..), |
| big_proj hi, rect_proj (s:=univ) (t:=univ) hi (by simp)] |
|
|
| lemma ystart_proj {b d : J → OBase H} {j : J} (hi : ∀ i, i ≠ j → b i = d i) |
| {e f : H} (hh : (b j).v e=(d j).v f) : |
| (OBase.tensor b).mat (ystart j e) = (OBase.tensor d).mat (ystart j f) := by |
| have hs (e : H) : rect j false {e} ⊆ rect j true {e} := by |
| intro k hk |
| simp only [mem_rect] at * |
| exact ⟨hk.1,(by simp),hk.2.2⟩ |
| have ht := rect_proj hi (singleton_proj hh) |
| unfold ystart xstart |
| rw [OBase.mat_sub _ _ _ (hs e), OBase.mat_sub _ _ _ (hs f), ht, ht] |
|
|
| lemma xstep_proj {b d : J → OBase H} {j : J} (hi : ∀ i, i ≠ j → b i = d i) |
| {e f : H} (hh : (b j).v e=(d j).v f) : |
| (OBase.tensor b).mat (xstep j e) = (OBase.tensor d).mat (xstep j f) := by |
| unfold xstep |
| rw [OBase.mat_sub _ _ _ (rect_le_big ..), OBase.mat_sub _ _ _ (rect_le_big ..), big_proj hi] |
| congr 1 |
| apply rect_proj hi |
| rw [OBase.mat_sub _ _ _ (subset_univ _), OBase.mat_sub _ _ _ (subset_univ _), |
| singleton_proj hh]; simp |
|
|
| lemma ystep_proj {b d : J → OBase H} {j : J} (hi : ∀ i, i ≠ j → b i = d i) |
| {e f : H} (hh : (b j).v e=(d j).v f) : |
| (OBase.tensor b).mat (ystep j e) = (OBase.tensor d).mat (ystep j f) := by |
| unfold ystep |
| rw [OBase.mat_sub _ _ _ (rect_le_big ..), OBase.mat_sub _ _ _ (rect_le_big ..), |
| big_proj hi, rect_proj hi (singleton_proj hh)] |
|
|
| end Masks |
|
|
| end PowerSaving.Cluster |
|
|
| end OAI |
|
|
