| import OAI.Computability.Superstring.FactoryPoly |
|
|
| namespace OAI |
|
|
| namespace Superstring.DistributeCode |
| open BitCode Hierarchical WalkCode LayerArray BlockClose |
| variable {α : Type} [Inhabited α] [DecidableEq α] |
| abbrev Result (α : Type) := Walk α × List (BlockClose.Block α) × List ℕ |
|
|
| def one (D : GroupData α) (src tar off i : ℕ) (a b : ℤ) : Result α := |
| if hasShort D i then (shortLoop D i,[],[]) |
| else if decide (b ≤ GeoCode.exit (exits D i) a+D.1.length) then |
| ([[]],[BlockFactory.individual D src tar off i a b],[]) |
| else ([[]],[],[i]) |
|
|
| def budget (o : Result α) (p : ℕ) : ℕ := |
| cost o.1+(o.2.1.map Block.reserve).sum+2*(o.2.2.length*p) |
| def combine (x y : Result α) : Result α := |
| (join x.1 y.1,x.2.1++y.2.1,x.2.2++y.2.2) |
| def many (D : GroupData α) (src tar off : ℕ) (I : List ℕ) (a b : ℤ) : Result α := |
| let os := I.map (fun i => one D src tar off i a b) |
| (collect (os.map Prod.fst),os.flatMap (fun o => o.2.1),os.flatMap (fun o => o.2.2)) |
|
|
| variable [LinearOrder α] |
| theorem one_spec {V : Set (List α)} {A B : ℤ → α} {p q : ℕ} |
| (L : ℕ → Layer V A p) (T : Layer V B q) {D : GroupData α} {i src tar off : ℕ} |
| (h : Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V) |
| (hp : 0 < p) (hq : 0 < q) (perA : Function.Periodic A (p : ℤ)) |
| (perB : Function.Periodic B (q : ℤ)) (letters : ∀ x, [A x] ∈ V) |
| (R : T.Record A) (hne : A ≠ fun x => B (x+R.offset)) |
| (hf : (L i).first R.start ≤ R.stop) |
| (ids : List ℕ) (ls : ℕ → Walk α) (owner periods : ℕ → ℕ) (rank : ℕ → Lex (ℕ → α)) |
| (hsrc : periods src = p) (htar : tar ∈ ids) (hown : owner (off+i) = src) |
| (htper : periods (owner tar) = q) |
| (hrec : textWord A R.start R.stop ∈ ls tar) |
| (hlayers : ∀ w ∈ ls (off+i), w ∈ (L i).Content) : |
| let o := one D src tar off i R.start R.stop |
| Runs V [] [] o.1 ∧ budget o p ≤ 2*p ∧ |
| (∀ b ∈ o.2.1, ValidBlock V ids ls owner periods rank b) ∧ |
| ((∀ w ∈ ls (off+i), w ∈ o.1) ∨ (∃ b ∈ o.2.1, off+i ∈ b.members) ∨ i ∈ o.2.2) ∧ |
| o.2.2.Sublist [i] ∧ |
| ∀ j ∈ o.2.2, R.start+p < (L j).first R.start ∧ (L j).last R.start < R.stop-p := by |
| dsimp only |
| have h0 : ([] : List α) ∈ V := closed (letters 0) List.nil_infix |
| have hroot : Runs V [] [] ([[]] : Walk α) := ⟨valid_nil [] h0,rfl,rfl⟩ |
| by_cases hs : hasShort D i = true |
| · rw [one,ite_eq_left hs] |
| obtain ⟨hr,hc,hv⟩ := shortLoop_spec L h closed hp perA hs |
| exact ⟨hr,by simpa [budget] using hc,by simp,Or.inl (fun w hw => hv w (hlayers w hw)),by simp,by simp⟩ |
| · rw [one,ite_eq_right hs] |
| by_cases ht : decide (R.stop ≤ GeoCode.exit (exits D i) R.start+D.1.length) = true |
| · rw [ite_eq_left ht] |
| have ht' : R.stop ≤ (L i).last R.start+p := by |
| simpa only [h.exit_eq,h.length_eq,decide_eq_true_eq,Layer.last] using ht |
| have hb := BlockFactory.individual_valid L T h closed hp hq perA perB letters R hne hf ht' |
| ids ls owner periods rank hsrc htar hown htper |
| (by intro he; rw [he,hsrc] at htper; exact htper) hrec hlayers |
| refine ⟨hroot,?_,?_,Or.inr (Or.inl ⟨_,List.mem_singleton_self _,?_⟩),by simp,by simp⟩ |
| · simp [budget,BlockFactory.individual,BlockFactory.pack,Block.reserve,h.length_eq] |
| · intro b hb'; have := List.mem_singleton.mp hb'; subst b; exact hb |
| · simp [BlockFactory.individual,BlockFactory.pack,Block.members] |
| · rw [ite_eq_right ht] |
| have hn : ¬ (L i).HasShort p := fun hx => hs ((hasShort_eq h hp perA).mpr hx) |
| have hl := (L i).first_long_of_not_short p hn R.start |
| have ht' : (L i).last R.start+p < R.stop := by |
| simp only [h.exit_eq,h.length_eq,decide_eq_true_eq] at ht |
| change (L i).z R.start+p < R.stop |
| omega |
| refine ⟨hroot,by simp [budget],by simp,Or.inr (Or.inr (by simp)),List.Sublist.refl _,?_⟩ |
| intro j hj; have := List.mem_singleton.mp hj; subst j |
| exact ⟨by omega,by omega⟩ |
|
|
| omit [DecidableEq α] [Inhabited α] [LinearOrder α] in |
| theorem combine_budget (x y : Result α) (p : ℕ) {V : Set (List α)} |
| (hx : Runs V [] [] x.1) (hy : Runs V [] [] y.1) : |
| budget (combine x y) p = budget x p+budget y p := by |
| simp only [budget,combine,cost_join _ _ _ hx.2.2 hy.2.1,List.map_append,List.sum_append,List.length_append] |
| ring |
|
|
| omit [DecidableEq α] [Inhabited α] [LinearOrder α] in |
| theorem gather_budget {V : Set (List α)} (h0 : ([] : List α) ∈ V) |
| (os : List (Result α)) (hr : ∀ o ∈ os, Runs V [] [] o.1) (p : ℕ) : |
| budget (collect (os.map Prod.fst),os.flatMap (fun o => o.2.1),os.flatMap (fun o => o.2.2)) p = |
| (os.map (fun o => budget o p)).sum := by |
| have hh := collect_spec h0 (os.map Prod.fst) (by |
| intro P hP; obtain ⟨o,ho,rfl⟩ := List.mem_map.mp hP; exact hr o ho) |
| simp only [budget,hh.2.1,List.map_map] |
| clear hh hr |
| induction os with |
| | nil => simp |
| | cons o os ih => |
| simp only [List.map_cons,List.sum_cons,List.flatMap_cons,List.map_append,List.sum_append, |
| List.length_append,Function.comp_apply,Nat.add_mul,Nat.mul_add] |
| omega |
|
|
| omit [LinearOrder α] [Inhabited α] [DecidableEq α] in |
| theorem flatMap_sublist (I : List ℕ) (f : ℕ → List ℕ) |
| (h : ∀ i ∈ I, (f i).Sublist [i]) : (I.flatMap f).Sublist I := by |
| induction I with |
| | nil => exact .refl _ |
| | cons i I ih => |
| simpa only [List.flatMap_cons,List.singleton_append] using |
| (h i (List.mem_cons_self ..)).append (ih (fun j hj => h j (List.mem_cons_of_mem _ hj))) |
|
|
| theorem many_spec {V : Set (List α)} {A B : ℤ → α} {p q : ℕ} |
| (L : ℕ → Layer V A p) (T : Layer V B q) {D : GroupData α} {I : List ℕ} {src tar off : ℕ} |
| (h : ∀ i ∈ I, Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V) |
| (hp : 0 < p) (hq : 0 < q) (perA : Function.Periodic A (p : ℤ)) |
| (perB : Function.Periodic B (q : ℤ)) (letters : ∀ x, [A x] ∈ V) |
| (R : T.Record A) (hne : A ≠ fun x => B (x+R.offset)) |
| (hf : ∀ i ∈ I, (L i).first R.start ≤ R.stop) |
| (ids : List ℕ) (ls : ℕ → Walk α) (owner periods : ℕ → ℕ) (rank : ℕ → Lex (ℕ → α)) |
| (hsrc : periods src = p) (htar : tar ∈ ids) (hown : ∀ i ∈ I, owner (off+i) = src) |
| (htper : periods (owner tar) = q) (hrec : textWord A R.start R.stop ∈ ls tar) |
| (hlayers : ∀ i ∈ I, ∀ w ∈ ls (off+i), w ∈ (L i).Content) : |
| let o := many D src tar off I R.start R.stop |
| Runs V [] [] o.1 ∧ budget o p ≤ 2*(I.length*p) ∧ |
| (∀ b ∈ o.2.1, ValidBlock V ids ls owner periods rank b) ∧ |
| (∀ i ∈ I, (∀ w ∈ ls (off+i), w ∈ o.1) ∨ (∃ b ∈ o.2.1, off+i ∈ b.members) ∨ i ∈ o.2.2) ∧ |
| o.2.2.Sublist I ∧ |
| ∀ j ∈ o.2.2, R.start+p < (L j).first R.start ∧ (L j).last R.start < R.stop-p := by |
| let f := fun i => one D src tar off i R.start R.stop |
| have hh := fun i hi => one_spec L T (h i hi) closed hp hq perA perB letters R hne (hf i hi) |
| ids ls owner periods rank hsrc htar (hown i hi) htper hrec (hlayers i hi) |
| have h0 : ([] : List α) ∈ V := closed (letters 0) List.nil_infix |
| have hr : ∀ o ∈ I.map f, Runs V [] [] o.1 := by |
| intro o ho; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp ho; exact (hh i hi).1 |
| have hc := collect_spec h0 ((I.map f).map Prod.fst) (by |
| intro P hP; obtain ⟨o,ho,rfl⟩ := List.mem_map.mp hP; exact hr o ho) |
| change Runs V [] [] (collect ((I.map f).map Prod.fst)) ∧ _ |
| refine ⟨hc.1,?_,?_,?_,?_,?_⟩ |
| · change budget (collect ((I.map f).map Prod.fst),(I.map f).flatMap (fun o => o.2.1),(I.map f).flatMap (fun o => o.2.2)) p ≤ _ |
| rw [gather_budget h0 (I.map f) hr p,List.map_map] |
| have hb : (I.map (fun i => budget (f i) p)).sum ≤ (I.map (fun _ => 2*p)).sum := |
| List.sum_le_sum (fun i hi => (hh i hi).2.1) |
| exact hb.trans_eq (by simp [List.sum_replicate]; ring) |
| · intro b hb |
| obtain ⟨o,ho,hb⟩ := List.mem_flatMap.mp hb |
| obtain ⟨i,hi,rfl⟩ := List.mem_map.mp ho |
| exact (hh i hi).2.2.1 b hb |
| · intro i hi |
| rcases (hh i hi).2.2.2.1 with hv|⟨b,hb,hm⟩|ha |
| · exact Or.inl (fun w hw => hc.2.2 (f i).1 (List.mem_map.mpr ⟨f i,List.mem_map.mpr ⟨i,hi,rfl⟩,rfl⟩) w (hv w hw)) |
| · exact Or.inr (Or.inl ⟨b,List.mem_flatMap.mpr ⟨f i,List.mem_map.mpr ⟨i,hi,rfl⟩,hb⟩,hm⟩) |
| · exact Or.inr (Or.inr (List.mem_flatMap.mpr ⟨f i,List.mem_map.mpr ⟨i,hi,rfl⟩,ha⟩)) |
| · change ((I.map f).flatMap _).Sublist I |
| rw [List.flatMap_map] |
| exact flatMap_sublist I _ (fun i hi => (hh i hi).2.2.2.2.1) |
| · intro j hj |
| obtain ⟨o,ho,hj⟩ := List.mem_flatMap.mp hj |
| obtain ⟨i,hi,rfl⟩ := List.mem_map.mp ho |
| exact (hh i hi).2.2.2.2.2 j hj |
|
|
| variable [Coded α] |
| instance codedResult : Coded (Result α) := codedProd |
| abbrev OneInput (α : Type) := (GroupData α × ℕ × ℕ × ℕ) × (ℕ × ℤ × ℤ) |
| instance codedOneInput : Coded (OneInput α) := codedProd |
| omit [LinearOrder α] in |
| @[fun_prop] theorem poly_one : Poly (fun q : OneInput α => one q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1 q.2.2.1 q.2.2.2) := by |
| unfold one |
| fun_prop |
| omit [LinearOrder α] [Inhabited α] [DecidableEq α] in |
| @[fun_prop] theorem poly_budget : Poly (fun q : Result α × ℕ => budget q.1 q.2) := by |
| unfold budget |
| have hs : Poly (fun q : Result α × ℕ => (q.1.2.1.map Block.reserve).sum) := poly_reserves.comp (by fun_prop) |
| fun_prop |
| omit [LinearOrder α] in |
| @[fun_prop] theorem poly_many : Poly (fun q : (GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℤ × ℤ) => |
| many q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1 q.2.2.1 q.2.2.2) := by |
| have hm : Poly (fun q : (GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℤ × ℤ) => |
| q.2.1.map (fun i => one q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 i q.2.2.1 q.2.2.2)) := by |
| exact BitCode.Poly.mapFn |
| (f := fun q : ((GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℤ × ℤ)) × ℕ => |
| one q.1.1.1 q.1.1.2.1 q.1.1.2.2.1 q.1.1.2.2.2 q.2 q.1.2.2.1 q.1.2.2.2) |
| (poly_one.comp (f := fun q : ((GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℤ × ℤ)) × ℕ => |
| (q.1.1,(q.2,q.1.2.2))) (by fun_prop)) (by fun_prop) |
| unfold many |
| have h1 : Poly (fun os : List (Result α) => collect (os.map Prod.fst)) := |
| poly_collect.comp (BitCode.Poly.mapFn (f := fun q : List (Result α) × Result α => q.2.1) (by fun_prop) (by fun_prop)) |
| have h2 : Poly (fun os : List (Result α) => os.flatMap (fun o => o.2.1)) := |
| BitCode.Poly.flatMapFn (f := fun q : List (Result α) × Result α => q.2.2.1) (by fun_prop) (by fun_prop) |
| have h3 : Poly (fun os : List (Result α) => os.flatMap (fun o => o.2.2)) := |
| BitCode.Poly.flatMapFn (f := fun q : List (Result α) × Result α => q.2.2.2) (by fun_prop) (by fun_prop) |
| exact (h1.pair (h2.pair h3)).comp hm |
| end Superstring.DistributeCode |
|
|
|
|
| namespace Superstring.LayerArray |
| open BitCode Hierarchical WalkCode |
| variable {α : Type} [Inhabited α] [DecidableEq α] |
| def belowLoop (D : GroupData α) (i : ℕ) (a b : ℤ) : Walk α := |
| if hasShort D i then shortLoop D i else individual D i a b |
| def below (D : GroupData α) (I : List ℕ) (P : Walk α) (a b : ℤ) : Walk α := |
| fill P (I.map (fun i => belowLoop D i a b)) |
|
|
| theorem belowLoop_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ} |
| (L : ℕ → Layer V A p) {D : GroupData α} {i base : ℕ} |
| (h : Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V) |
| (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) (letters : ∀ x, [A x] ∈ V) |
| {P : Walk α} (hP : Runs V [] [] P) |
| (hcover : ∀ w ∈ (L base).Content, w ∈ P) |
| (hbelow : ∀ x, (L i).z x ≤ (L base).z x) |
| {a b : ℤ} (hbf : (L base).first a ≤ b) (hbl : b ≤ (L base).last a) |
| (hlen : b-a < 2*p) : |
| (∃ u, Runs V u u (belowLoop D i a b)) ∧ cost (belowLoop D i a b) ≤ 2*p ∧ |
| (∀ w ∈ (L i).Content, w ∈ belowLoop D i a b) ∧ |
| ∃ w, w ∈ P ∧ w ∈ belowLoop D i a b := by |
| by_cases hs : hasShort D i = true |
| · rw [belowLoop,ite_eq_left hs] |
| obtain ⟨hr,hc,hv⟩ := shortLoop_spec L h closed hp per hs |
| exact ⟨⟨[],hr⟩,hc,hv,[],List.mem_of_head? hP.2.1,List.mem_of_head? hr.2.1⟩ |
| · rw [belowLoop,ite_eq_right hs] |
| have hn : ¬ (L i).HasShort p := fun hh => hs ((hasShort_eq h hp per).mpr hh) |
| have hl := (L i).first_long_of_not_short p hn a |
| have hf : (L i).first a ≤ b := (hbelow (a-1)).trans hbf |
| have hfl := (L i).first_le_last a |
| obtain ⟨hr,hc,hv,hw,_⟩ := individual_spec L h closed hp per letters p |
| ((L base).start_le_first a |>.trans hbf) ((L base).actual a b hbf hbl) hf (by omega) (by omega) |
| exact ⟨⟨_,hr⟩,hc.le,hv,_,hcover _ ⟨a,b,hbf,hbl,rfl⟩,hw⟩ |
|
|
| theorem below_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ} |
| (L : ℕ → Layer V A p) {D : GroupData α} {I : List ℕ} {base : ℕ} |
| (h : ∀ i ∈ I, Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V) |
| (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) (letters : ∀ x, [A x] ∈ V) |
| {P : Walk α} (hP : Runs V [] [] P) |
| (hcover : ∀ w ∈ (L base).Content, w ∈ P) |
| (hbelow : ∀ i ∈ I, ∀ x, (L i).z x ≤ (L base).z x) |
| {a b : ℤ} (hbf : (L base).first a ≤ b) (hbl : b ≤ (L base).last a) |
| (hlen : b-a < 2*p) : |
| Runs V [] [] (below D I P a b) ∧ cost (below D I P a b) ≤ cost P+2*(I.length*p) ∧ |
| (∀ w ∈ P, w ∈ below D I P a b) ∧ |
| ∀ i ∈ I, ∀ w ∈ (L i).Content, w ∈ below D I P a b := by |
| have hh := fun i hi => belowLoop_spec L (h i hi) closed hp per letters hP hcover (hbelow i hi) hbf hbl hlen |
| obtain ⟨hr,hc,hv⟩ := fill_spec P (I.map (fun i => belowLoop D i a b)) hP |
| (by intro Q hQ; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hQ; exact (hh i hi).1) |
| (by intro Q hQ; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hQ; exact (hh i hi).2.2.2) |
| refine ⟨hr,?_,fun w hw => (hv w).mpr (Or.inl hw),?_⟩ |
| · change cost (fill P _) ≤ _ |
| rw [hc,List.map_map] |
| have hb := List.sum_le_sum (g := fun _ : ℕ => 2*p) (fun i hi => (hh i hi).2.1) |
| have he : (I.map (fun _ => 2*p)).sum = 2*(I.length*p) := by simp [List.sum_replicate]; ring |
| rw [he] at hb |
| exact Nat.add_le_add_left hb _ |
| · intro i hi w hw |
| exact (hv w).mpr (Or.inr ⟨_,List.mem_map.mpr ⟨i,hi,rfl⟩,(hh i hi).2.2.1 w hw⟩) |
|
|
| variable [Coded α] |
| @[fun_prop] theorem poly_belowLoop : Poly (fun q : GroupData α × ℕ × ℤ × ℤ => |
| belowLoop q.1 q.2.1 q.2.2.1 q.2.2.2) := by |
| unfold belowLoop |
| fun_prop |
| @[fun_prop] theorem poly_below : Poly (fun q : (GroupData α × List ℕ) × Walk α × ℤ × ℤ => |
| below q.1.1 q.1.2 q.2.1 q.2.2.1 q.2.2.2) := by |
| unfold below |
| have hm : Poly (fun q : (GroupData α × List ℕ) × Walk α × ℤ × ℤ => |
| q.1.2.map (fun i => belowLoop q.1.1 i q.2.2.1 q.2.2.2)) := |
| BitCode.Poly.mapFn (f := fun q : ((GroupData α × List ℕ) × Walk α × ℤ × ℤ) × ℕ => |
| belowLoop q.1.1.1 q.2 q.1.2.2.1 q.1.2.2.2) (by fun_prop) (by fun_prop) |
| fun_prop |
| end Superstring.LayerArray |
|
|
|
|
| namespace Superstring.DistributeCode |
| open BitCode Hierarchical WalkCode LayerArray BlockClose |
| variable {α : Type} [Inhabited α] [DecidableEq α] |
| def record (D : GroupData α) (src tar off : ℕ) (I : List ℕ) (lo hi : ℕ) (a b t : ℤ) : Result α := |
| let J := I.filter (fun i => lessEq lo i) |
| if decide (b ≤ GeoCode.exit (exits D lo) a+(J.length*D.1.length : ℕ)) then |
| let o := many D src tar off (I.filter (fun i => !lessEq lo i)) a b |
| (o.1,BlockFactory.collective D src tar off J lo hi a b t::o.2.1,o.2.2) |
| else many D src tar off I a b |
|
|
| variable [LinearOrder α] |
| theorem record_spec {V : Set (List α)} {A B : ℤ → α} {p q : ℕ} |
| (L : ℕ → Layer V A p) (T : Layer V B q) {D : GroupData α} {I : List ℕ} {src tar off lo hi : ℕ} |
| (h : ∀ i ∈ I, Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V) |
| (hp : 0 < p) (hq : 0 < q) (perA : Function.Periodic A (p : ℤ)) |
| (perB : Function.Periodic B (q : ℤ)) (letters : ∀ x, [A x] ∈ V) |
| (R : T.Record A) (hne : A ≠ fun x => B (x+R.offset)) |
| (t : ℤ) (hat : R.start ≤ t) (htb : t < R.stop) |
| (hmax : ∀ x, forward A x ≤ forward A t) |
| (hlo : lo ∈ I) (hhi : hi ∈ I) (hlohi : lo ≤ hi) |
| (lower : ∀ i ∈ I, lo ≤ i → ∀ x, (L lo).z x ≤ (L i).z x) |
| (upper : ∀ i ∈ I, ∀ x, (L i).z x ≤ (L hi).z x) |
| (hfirst : ∀ i ∈ I, i < lo → (L i).first R.start ≤ R.stop) |
| (hH : (L hi).first t ≤ R.stop+((I.filter (fun i => lessEq lo i)).length*p : ℕ)) |
| (hsharp : (L hi).first t-(L lo).last t ≤ (((I.filter (fun i => lessEq lo i)).length-1)*p : ℕ)) |
| (ids : List ℕ) (ls : ℕ → Walk α) (owner periods : ℕ → ℕ) (rank : ℕ → Lex (ℕ → α)) |
| (hsrc : periods src = p) (htar : tar ∈ ids) (hown : ∀ i ∈ I, owner (off+i) = src) |
| (htper : periods (owner tar) = q) |
| (hrank : rank (owner tar) ≤ rank src → ∀ x, forward (fun x => B (x+R.offset)) x ≤ forward A t) |
| (hrec : textWord A R.start R.stop ∈ ls tar) |
| (hlayers : ∀ i ∈ I, ∀ w ∈ ls (off+i), w ∈ (L i).Content) : |
| let o := record D src tar off I lo hi R.start R.stop t |
| Runs V [] [] o.1 ∧ budget o p ≤ 2*(I.length*p) ∧ |
| (∀ b ∈ o.2.1, ValidBlock V ids ls owner periods rank b) ∧ |
| (∀ i ∈ I, (∀ w ∈ ls (off+i), w ∈ o.1) ∨ (∃ b ∈ o.2.1, off+i ∈ b.members) ∨ i ∈ o.2.2) ∧ |
| o.2.2.Sublist I ∧ |
| ∀ j ∈ o.2.2, R.start+p < (L j).first R.start ∧ (L j).last R.start < R.stop-p := by |
| let J := I.filter (fun i => lessEq lo i) |
| let F := I.filter (fun i => !lessEq lo i) |
| have hJ : ∀ i, i ∈ J ↔ i ∈ I ∧ lo ≤ i := by intro i; simp [J,lessEq] |
| have hF : ∀ i, i ∈ F ↔ i ∈ I ∧ i < lo := by intro i; simp [F,lessEq] |
| have hloJ : lo ∈ J := (hJ lo).mpr ⟨hlo,le_rfl⟩ |
| have hhiJ : hi ∈ J := (hJ hi).mpr ⟨hhi,hlohi⟩ |
| have hk : 0 < J.length := List.length_pos_of_mem hloJ |
| have hgap := Processing.wide_band (L hi) (L lo) hp hk t hsharp R.start |
| by_cases hc : decide (R.stop ≤ GeoCode.exit (exits D lo) R.start+(J.length*D.1.length : ℕ)) = true |
| · change _ ∧ _ |
| simp only [record,show I.filter (fun i => lessEq lo i) = J from rfl,ite_eq_left hc] |
| have hb : R.stop ≤ (L lo).last R.start+(J.length*p : ℕ) := by |
| simpa only [(h lo hlo).exit_eq,(h lo hlo).length_eq,Layer.last,decide_eq_true_eq] using hc |
| have hblock := BlockFactory.collective_valid L T (D:=D) (js:=J) |
| (fun i hi => h i ((hJ i).mp hi).1) hloJ hhiJ |
| (fun i hi => lower i ((hJ i).mp hi).1 ((hJ i).mp hi).2) |
| (fun i hi => upper i ((hJ i).mp hi).1) closed hp hq perA perB letters R hne t hat htb |
| hmax hH hgap hb hsharp ids ls owner periods rank hsrc htar |
| (fun i hi => hown i ((hJ i).mp hi).1) htper |
| (by intro he; rw [he,hsrc] at htper; exact htper) hrank hrec |
| (fun i hi => hlayers i ((hJ i).mp hi).1) |
| obtain ⟨hr,hbudget,hblocks,hcov,hs,hm⟩ := many_spec L T (D:=D) (I:=F) |
| (fun i hi => h i ((hF i).mp hi).1) closed hp hq perA perB letters R hne |
| (fun i hi => hfirst i ((hF i).mp hi).1 ((hF i).mp hi).2) |
| ids ls owner periods rank hsrc htar (fun i hi => hown i ((hF i).mp hi).1) htper hrec |
| (fun i hi => hlayers i ((hF i).mp hi).1) |
| refine ⟨hr,?_,?_,?_,hs.trans (List.filter_sublist),hm⟩ |
| · have he : F.length+J.length = I.length := by |
| simpa only [F,J,Nat.add_comm] using (List.length_eq_length_filter_add (l:=I) (fun i => lessEq lo i)).symm |
| have hbsize : (BlockFactory.collective D src tar off J lo hi R.start R.stop t).reserve = 2*(J.length*p) := by |
| simp only [BlockFactory.collective,BlockFactory.pack,Block.reserve,(h lo hlo).length_eq] |
| change cost _ + ((_ :: _).map Block.reserve).sum + _ ≤ _ |
| simp only [List.map_cons,List.sum_cons,hbsize] |
| change cost _ + _ + _ ≤ _ at hbudget |
| have ha : 2*(I.length*p) = 2*(F.length*p)+2*(J.length*p) := by rw [← he]; ring |
| dsimp only [F] at hbudget ha |
| omega |
| · intro b hb' |
| rcases List.mem_cons.mp hb' with rfl|hb' |
| · exact hblock |
| · exact hblocks b hb' |
| · intro i hi |
| by_cases hj : lo ≤ i |
| · exact Or.inr (Or.inl ⟨_,List.mem_cons_self ..,List.mem_map.mpr ⟨i,(hJ i).mpr ⟨hi,hj⟩,rfl⟩⟩) |
| · rcases hcov i ((hF i).mpr ⟨hi,by omega⟩) with hv|⟨b,hb,hm⟩|ha |
| · exact Or.inl hv |
| · exact Or.inr (Or.inl ⟨b,List.mem_cons_of_mem _ hb,hm⟩) |
| · exact Or.inr (Or.inr ha) |
| · simp only [record,show I.filter (fun i => lessEq lo i) = J from rfl,ite_eq_right hc] |
| apply many_spec L T h closed hp hq perA perB letters R hne _ ids ls owner periods rank hsrc htar hown htper hrec hlayers |
| intro i hmem |
| have hb : (L lo).last R.start+(J.length*p : ℕ) < R.stop := by |
| simp only [(h lo hlo).exit_eq,(h lo hlo).length_eq,decide_eq_true_eq] at hc |
| change (L lo).z R.start+_ < _ |
| omega |
| have hu := upper i hmem (R.start-1) |
| change (L i).first R.start ≤ (L hi).first R.start at hu |
| omega |
|
|
| variable [Coded α] |
| abbrev RecordInput (α : Type) := (GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℕ × ℕ) × (ℤ × ℤ × ℤ) |
| instance codedRecordInput : Coded (RecordInput α) := codedProd |
| omit [LinearOrder α] in |
| @[fun_prop] theorem poly_record : Poly (fun q : RecordInput α => |
| record q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1.1 q.2.1.2.1 q.2.1.2.2 q.2.2.1 q.2.2.2.1 q.2.2.2.2) := by |
| have hj : Poly (fun q : RecordInput α => q.2.1.1.filter (fun i => lessEq q.2.1.2.1 i)) := |
| BitCode.Poly.filterFn (p := fun q : RecordInput α × ℕ => lessEq q.1.2.1.2.1 q.2) (by fun_prop) (by fun_prop) |
| have hf : Poly (fun q : RecordInput α => q.2.1.1.filter (fun i => !lessEq q.2.1.2.1 i)) := |
| BitCode.Poly.filterFn (p := fun q : RecordInput α × ℕ => !lessEq q.1.2.1.2.1 q.2) (by fun_prop) (by fun_prop) |
| have hc : Poly (fun q : RecordInput α => BlockFactory.collective q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 |
| (q.2.1.1.filter (fun i => lessEq q.2.1.2.1 i)) q.2.1.2.1 q.2.1.2.2 q.2.2.1 q.2.2.2.1 q.2.2.2.2) := |
| BlockFactory.poly_collective.comp (f := fun q : RecordInput α => |
| (q.1,((q.2.1.1.filter (fun i => lessEq q.2.1.2.1 i)),q.2.1.2),q.2.2)) (by fun_prop) |
| have hm : Poly (fun q : RecordInput α => many q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 |
| (q.2.1.1.filter (fun i => !lessEq q.2.1.2.1 i)) q.2.2.1 q.2.2.2.1) := |
| poly_many.comp (f := fun q : RecordInput α => |
| (q.1,(q.2.1.1.filter (fun i => !lessEq q.2.1.2.1 i)),q.2.2.1,q.2.2.2.1)) (by fun_prop) |
| have hm' : Poly (fun q : RecordInput α => many q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1.1 q.2.2.1 q.2.2.2.1) := |
| poly_many.comp (f := fun q : RecordInput α => (q.1,q.2.1.1,q.2.2.1,q.2.2.2.1)) (by fun_prop) |
| unfold record |
| dsimp only |
| apply BitCode.Poly.ite |
| · fun_prop |
| · fun_prop |
| · exact hm' |
| end Superstring.DistributeCode |
|
|
|
|
| namespace Superstring.LayerArray |
| open BitCode Hierarchical WalkCode |
| variable {α : Type} [Inhabited α] [DecidableEq α] |
| def attachBand (D : GroupData α) (I : List ℕ) (lo hi : ℕ) (P : Walk α) (t : ℤ) : Walk α := |
| splice P (band D I lo hi I.length t) |
|
|
| theorem band_general {V : Set (List α)} {A : ℤ → α} {p : ℕ} |
| (L : ℕ → Layer V A p) {D : GroupData α} {I : List ℕ} {lo hi k : ℕ} |
| (h : ∀ i ∈ I, Represents D.1 (exits D i) (L i)) |
| (hl : Represents D.1 (exits D lo) (L lo)) (hh : Represents D.1 (exits D hi) (L hi)) |
| (lower : ∀ i ∈ I, ∀ x, (L lo).z x ≤ (L i).z x) |
| (upper : ∀ i ∈ I, ∀ x, (L i).z x ≤ (L hi).z x) |
| (hlohi : ∀ x, (L lo).z x ≤ (L hi).z x) |
| (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) |
| (letters : ∀ x, [A x] ∈ V) (t : ℤ) |
| (hB : (L hi).first t-(L lo).last t ≤ (k*p : ℕ)) : |
| Runs V (textWord A t ((L lo).last t)) (textWord A t ((L lo).last t)) (band D I lo hi k t) ∧ |
| cost (band D I lo hi k t) ≤ (k+I.length)*p ∧ |
| ∀ i ∈ I, ∀ w ∈ (L i).Content, w ∈ band D I lo hi k t := by |
| let J := lo::hi::I |
| have hloJ : lo ∈ J := List.mem_cons_self .. |
| have hhiJ : hi ∈ J := List.mem_cons_of_mem _ (List.mem_cons_self ..) |
| have hlow : ∀ i ∈ J, ∀ x, (L lo).z x ≤ (L i).z x := by |
| intro i hi' x |
| rcases List.mem_cons.mp hi' with rfl|hi' |
| · exact le_rfl |
| rcases List.mem_cons.mp hi' with rfl|hi' |
| · exact hlohi x |
| · exact lower i hi' x |
| have hupp : ∀ i ∈ J, ∀ x, (L i).z x ≤ (L hi).z x := by |
| intro i hi' x |
| rcases List.mem_cons.mp hi' with rfl|hi' |
| · exact hlohi x |
| rcases List.mem_cons.mp hi' with rfl|hi' |
| · exact le_rfl |
| · exact upper i hi' x |
| obtain ⟨Q,he,hc,ht⟩ := GeoCode.join_band_realizes closed A letters p k per |
| (fun j : {j // j ∈ J} => L j.val) ⟨lo,hloJ⟩ ⟨hi,hhiJ⟩ |
| (fun j => hlow j.val j.property) (fun j => hupp j.val j.property) t hB |
| have he' : WalkCode.Path.points Q = GeoCode.band (PeriodWord.text D.1) |
| (GeoCode.exit (exits D lo)) (GeoCode.exit (exits D hi)) D.1.length k t := by |
| rw [hh.text_eq,hl.exit_eq,hh.exit_eq,hh.length_eq]; exact he |
| obtain ⟨hr,hc',_,hv⟩ := filled_realized L h closed hp per he' |
| (fun i hi' => ht ⟨i,List.mem_cons_of_mem _ (List.mem_cons_of_mem _ hi')⟩) |
| refine ⟨hr,?_,hv⟩ |
| change cost (saturate D I _) ≤ _ |
| rw [hc',Nat.add_mul] |
| omega |
|
|
| theorem attachBand_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ} |
| (L : ℕ → Layer V A p) {D : GroupData α} {I : List ℕ} {lo hi : ℕ} |
| (h : ∀ i ∈ I, Represents D.1 (exits D i) (L i)) |
| (hl : Represents D.1 (exits D lo) (L lo)) (hh : Represents D.1 (exits D hi) (L hi)) |
| (lower : ∀ i ∈ I, ∀ x, (L lo).z x ≤ (L i).z x) |
| (upper : ∀ i ∈ I, ∀ x, (L i).z x ≤ (L hi).z x) |
| (hlohi : ∀ x, (L lo).z x ≤ (L hi).z x) |
| (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) |
| (letters : ∀ x, [A x] ∈ V) (t : ℤ) |
| (hB : (L hi).first t-(L lo).last t ≤ (I.length*p : ℕ)) |
| {P : Walk α} (hP : Runs V [] [] P) (hcP : ∀ w ∈ (L lo).Content, w ∈ P) : |
| Runs V [] [] (attachBand D I lo hi P t) ∧ cost (attachBand D I lo hi P t) ≤ cost P+2*(I.length*p) ∧ |
| (∀ w ∈ P, w ∈ attachBand D I lo hi P t) ∧ |
| ∀ i ∈ I, ∀ w ∈ (L i).Content, w ∈ attachBand D I lo hi P t := by |
| obtain ⟨hr,hc,hv⟩ := band_general L h hl hh lower upper hlohi closed hp per letters t hB |
| have hm : textWord A t ((L lo).last t) ∈ P := hcP _ ⟨t,_,(L lo).first_le_last t,le_rfl,rfl⟩ |
| obtain ⟨hR,hc',hv'⟩ := splice_spec hP hr ⟨_,hm,List.mem_of_head? hr.2.1⟩ |
| refine ⟨hR,?_,fun w hw => (hv' w).mpr (Or.inl hw),fun i hi' w hw => (hv' w).mpr (Or.inr (hv i hi' w hw))⟩ |
| change cost (splice P _) ≤ _ |
| rw [hc'] |
| calc |
| _ ≤ cost P+(I.length+I.length)*p := Nat.add_le_add_left hc _ |
| _ = _ := by ring |
|
|
| variable [Coded α] |
| @[fun_prop] theorem poly_attachBand : Poly (fun q : (GroupData α × List ℕ) × (ℕ × ℕ) × Walk α × ℤ => |
| attachBand q.1.1 q.1.2 q.2.1.1 q.2.1.2 q.2.2.1 q.2.2.2) := by |
| unfold attachBand |
| exact poly_splice.comp (f := fun q : (GroupData α × List ℕ) × (ℕ × ℕ) × Walk α × ℤ => |
| (q.2.2.1,band q.1.1 q.1.2 q.2.1.1 q.2.1.2 q.1.2.length q.2.2.2)) (by fun_prop) |
| end Superstring.LayerArray |
|
|
| end OAI |
|
|
