| import OAI.Computability.WeisfeilerLeman.Writer |
|
|
| namespace OAI |
|
|
| universe uV uW uT uS uJ uR uJ' |
|
|
| namespace WLTime.Enumeration |
| variable {V : Type uV} {W : Type uW} |
| structure Listing (V : Type uV) where |
| items : List V |
| nodup : items.Nodup |
| complete : ∀v,v∈items |
|
|
| noncomputable def Listing.equiv (l : Listing V) : Fin l.items.length ≃ V := |
| Equiv.ofBijective l.items.get ⟨List.nodup_iff_injective_get.mp l.nodup, |
| fun v => List.mem_iff_get.mp (l.complete v)⟩ |
| @[simp] theorem Listing.equiv_apply (l : Listing V) (i : Fin l.items.length) : l.equiv i=l.items.get i := rfl |
|
|
| noncomputable def ofFintype (V : Type uV) [Fintype V] : Listing V := by |
| classical |
| exact ⟨Finset.univ.toList,Finset.nodup_toList _,fun v => by simp⟩ |
|
|
| def fin (n : ℕ) : Listing (Fin n) := ⟨List.finRange n,List.nodup_finRange n,List.mem_finRange⟩ |
|
|
| def Listing.prod (l : Listing V) (k : Listing W) : Listing (V × W) where |
| items := l.items.flatMap (fun v => k.items.map (fun w => (v,w))) |
| nodup := by |
| apply List.nodup_flatMap.mpr |
| refine ⟨fun v _ => (List.nodup_map_iff (fun x y h => (Prod.mk.inj h).2)).mpr k.nodup,?_⟩ |
| apply l.nodup.imp |
| intro x y hxy |
| apply List.disjoint_left.mpr |
| intro a ha hb |
| obtain ⟨u,_,rfl⟩ := List.mem_map.mp ha |
| obtain ⟨v,_,he⟩ := List.mem_map.mp hb |
| exact hxy (Prod.mk.inj he).1.symm |
| complete := by |
| rintro ⟨v,w⟩ |
| exact List.mem_flatMap.mpr ⟨v,l.complete v,List.mem_map.mpr ⟨w,k.complete w,rfl⟩⟩ |
|
|
| def Listing.sum (l : Listing V) (k : Listing W) : Listing (V ⊕ W) where |
| items := l.items.map Sum.inl ++ k.items.map Sum.inr |
| nodup := by |
| apply List.nodup_append.mpr |
| refine ⟨(List.nodup_map_iff Sum.inl_injective).mpr l.nodup, |
| (List.nodup_map_iff Sum.inr_injective).mpr k.nodup,?_⟩ |
| intro a ha b hb |
| obtain ⟨x,_,rfl⟩ := List.mem_map.mp ha |
| obtain ⟨y,_,rfl⟩ := List.mem_map.mp hb |
| exact Sum.inl_ne_inr |
| complete := by |
| intro v; cases v with |
| | inl v => exact List.mem_append_left _ (List.mem_map.mpr ⟨v,l.complete v,rfl⟩) |
| | inr w => exact List.mem_append_right _ (List.mem_map.mpr ⟨w,k.complete w,rfl⟩) |
| |
| def Listing.option (l : Listing V) : Listing (Option V) where |
| items := none::l.items.map some |
| nodup := by |
| rw [List.nodup_cons] |
| exact ⟨by simp,(List.nodup_map_iff (Option.some_injective V)).mpr l.nodup⟩ |
| complete := by |
| intro v; cases v with |
| | none => exact List.mem_cons_self |
| | some v => exact List.mem_cons_of_mem _ (List.mem_map.mpr ⟨v,l.complete v,rfl⟩) |
| |
| theorem fin_values (n : ℕ) : (List.finRange n).map Fin.val=List.range n := by |
| apply List.ext_getElem |
| · simp |
| · intro i hi hj; simp |
| |
| theorem range_flatMap {T : Type uT} (n : ℕ) (f : ℕ → List T) : |
| (List.range n).flatMap f=(List.finRange n).flatMap (fun i => f i.val) := by |
| rw [← fin_values,List.flatMap_map] |
|
|
| theorem Listing.length_eq_card [Fintype V] (l : Listing V) : l.items.length=Fintype.card V := by |
| rw [← Fintype.card_fin l.items.length] |
| exact Fintype.card_congr l.equiv |
| end WLTime.Enumeration |
|
|
| namespace WLTime.Enumeration |
| open NatCode |
| variable {T : Type uT} {S : Type uS} {J : Type uJ} |
| abbrev Vertex (T : Type uT) (S : Type uS) (m L p : ℕ) := Option ((((T × S × Fin m × Fin m) × Fin L)) ⊕ Fin p) |
|
|
| def rectangle (t : Listing T) (s : Listing S) (m L p : ℕ) : Listing (Vertex T S m L p) := |
| ((t.prod (s.prod ((fin m).prod (fin m)))).prod (fin L) |>.sum (fin p)).option |
|
|
| theorem rectangle_flatMap {R : Type uR} (t : Listing T) (s : Listing S) (m L p : ℕ) |
| (f : Vertex T S m L p → List R) : |
| (rectangle t s m L p).items.flatMap f=f none ++ |
| t.items.flatMap (fun t => s.items.flatMap (fun s => (List.finRange m).flatMap (fun a => |
| (List.finRange m).flatMap (fun b => (List.finRange L).flatMap (fun i => f (some (.inl ((t,s,a,b),i)))))))) ++ |
| (List.finRange p).flatMap (fun i => f (some (.inr i))) := by |
| simp only [rectangle,Listing.option,Listing.sum,Listing.prod,fin,List.flatMap_cons, |
| List.flatMap_append,List.flatMap_map,List.flatMap_assoc,List.append_assoc] |
|
|
| def writer (t : Listing T) (s : Listing S) (N L P : Expr J) |
| (hub : Writer J) (slot : T → S → Writer (Option (Option (Option J)))) |
| (pad : Writer (Option J)) : Writer J := |
| .seq hub (.seq (Writer.each t.items (fun t => Writer.each s.items (fun s => Writer.grid N L (slot t s)))) |
| (.loop P pad)) |
|
|
| theorem writer_eval (t : Listing T) (s : Listing S) (N L P : Expr J) |
| (hub : Writer J) (slot : T → S → Writer (Option (Option (Option J)))) (pad : Writer (Option J)) |
| (σ : J → ℕ) (w : List Bool) (m a p : ℕ) |
| (hN : N.eval σ w=m) (hL : L.eval σ w=a) (hP : P.eval σ w=p) |
| (f : Vertex T S m a p → List Bool) |
| (hh : hub.eval σ w=f none) |
| (hs : ∀t s (x y : Fin m) (i : Fin a), |
| (slot t s).eval (Option.elim' i.val (Option.elim' y.val (Option.elim' x.val σ))) w= |
| f (some (.inl ((t,s,x,y),i)))) |
| (hp : ∀i : Fin p,pad.eval (Option.elim' i.val σ) w=f (some (.inr i))) : |
| (writer t s N L P hub slot pad).eval σ w=(rectangle t s m a p).items.flatMap f := by |
| rw [rectangle_flatMap] |
| simp only [writer,Writer.eval,Writer.each_eval,Writer.grid_eval,hN,hL,hP,hh, |
| ← List.append_assoc,range_flatMap] |
| simp only [hs,hp] |
|
|
| theorem writer_safe (t : Listing T) (s : Listing S) (N L P : Expr J) |
| (hub : Writer J) (slot : T → S → Writer (Option (Option (Option J)))) (pad : Writer (Option J)) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (hN : N.Bounded σ w B) (hL : L.Bounded σ w B) (hP : P.Bounded σ w B) |
| (hh : hub.Safe σ w B) |
| (hs : ∀t s x,x < N.eval σ w → ∀y,y<N.eval σ w → ∀i,i<L.eval σ w → |
| (slot t s).Safe (Option.elim' i (Option.elim' y (Option.elim' x σ))) w B) |
| (hp : ∀i<P.eval σ w,pad.Safe (Option.elim' i σ) w B) : |
| (writer t s N L P hub slot pad).Safe σ w B := by |
| refine ⟨hh,⟨Writer.each_safe _ _ σ w B ?_,⟨hP,hp⟩⟩⟩ |
| intro tag htag |
| apply Writer.each_safe |
| intro value hvalue |
| exact Writer.grid_safe N L (slot tag value) σ w B hN hL (hs tag value) |
|
|
| theorem writer_depth (t : Listing T) (s : Listing S) (N L P : Expr J) |
| (hub : Writer J) (slot : T → S → Writer (Option (Option (Option J)))) (pad : Writer (Option J)) |
| (b : ℕ) (hh : hub.depth≤b+3) (hs : ∀t s,(slot t s).depth≤b) (hp : pad.depth≤b+2) : |
| (writer t s N L P hub slot pad).depth≤b+3 := by |
| apply max_le hh |
| apply max_le |
| · apply Writer.each_depth_le _ _ _ (by omega) |
| intro tag htag |
| apply Writer.each_depth_le _ _ _ (by omega) |
| intro value hvalue |
| rw [Writer.grid_depth] |
| exact Nat.add_le_add_right (hs tag value) 3 |
| · exact Nat.add_le_add_right hp 1 |
| end WLTime.Enumeration |
|
|
| namespace WLTime.Enumeration |
| variable {V : Type uV} |
| open scoped Classical |
| noncomputable def Listing.matrix (l : Listing V) (G : SimpleGraph V) : Graph l.items.length := |
| Graph.ofSimple G l.equiv.symm |
|
|
| theorem Listing.ofFn_eq_map {R : Type uR} (l : Listing V) (f : V → R) : |
| List.ofFn (fun i => f (l.items.get i))=l.items.map f := by |
| change List.ofFn (f ∘ l.items.get)=_ |
| rw [←List.map_ofFn,List.ofFn_get] |
|
|
| theorem Listing.matrix_bits (l : Listing V) (G : SimpleGraph V) : |
| matrixBits (l.matrix G)=l.items.flatMap (fun x => l.items.map (fun y => decide (G.Adj x y))) := by |
| classical |
| have hx : matrixBits (l.matrix G)= |
| (List.ofFn fun i => List.ofFn fun j => decide (G.Adj (l.items.get i) (l.items.get j))).flatten := by |
| rfl |
| rw [hx] |
| have hr (v : V) := l.ofFn_eq_map (fun y => decide (G.Adj v y)) |
| have ho := l.ofFn_eq_map (fun x => l.items.map (fun y => decide (G.Adj x y))) |
| calc |
| _ = (List.ofFn fun i => l.items.map (fun y => decide (G.Adj (l.items.get i) y))).flatten := by |
| apply congrArg List.flatten |
| apply congrArg List.ofFn |
| funext i |
| exact hr _ |
| _ = (l.items.map (fun x => l.items.map (fun y => decide (G.Adj x y)))).flatten := congrArg List.flatten ho |
| _ = _ := rfl |
| end WLTime.Enumeration |
|
|
| namespace WLTime.OneTape.Symbolic |
| open CircuitEncoding NatCode Compression Enumeration |
| variable (M : OneTape) (d q K : ℕ) |
| open scoped Classical |
|
|
| noncomputable instance valuesFintype : Fintype (Values M d q K) := by |
| classical |
| letI : Fintype (ConsistencyData.Tag (r:=d+q) (P:=Node M d q) (E:=Edge M d q) K) := inferInstance |
| letI : ∀ t : ConsistencyData.Tag (r:=d+q) (P:=Node M d q) (E:=Edge M d q) K, |
| Fintype ((instanceData M d q []).TagValue K t) := fun t => by |
| cases t <;> dsimp [ConsistencyData.TagValue] <;> infer_instance |
| change Fintype ((t : ConsistencyData.Tag (r:=d+q) (P:=Node M d q) (E:=Edge M d q) K) → |
| (instanceData M d q []).TagValue K t) |
| infer_instance |
|
|
| abbrev RawVertex (w : List Bool) (pad : ℕ) := |
| Enumeration.Vertex (BlockTag M d q K) (Values M d q K) w.length |
| ((instanceData M d q w).slotLimit K) pad |
|
|
| noncomputable def listing (w : List Bool) (pad : ℕ) : Listing (RawVertex M d q K w pad) := |
| Enumeration.rectangle (ofFintype (BlockTag M d q K)) (ofFintype (Values M d q K)) |
| w.length ((instanceData M d q w).slotLimit K) pad |
|
|
| inductive Location (J : Type uJ) where |
| | hub | hole |
| | slot (tag : BlockTag M d q K) (value : Values M d q K) (a b i : Expr J) |
|
|
| namespace Location |
| variable {M d q K} {J : Type uJ} {J' : Type uJ'} |
| def rename (f : J → J') : Location M d q K J → Location M d q K J' |
| | .hub => .hub |
| | .hole => .hole |
| | .slot t v a b i => .slot t v (a.rename f) (b.rename f) (i.rename f) |
| end Location |
|
|
| variable {J : Type uJ} |
| inductive Represents (σ : J → ℕ) (w : List Bool) (pad : ℕ) : |
| Location M d q K J → RawVertex M d q K w pad → Prop |
| | hub : Represents σ w pad .hub none |
| | hole (i : Fin pad) : Represents σ w pad .hole (some (.inr i)) |
| | slot (t : BlockTag M d q K) (v : Values M d q K) (a b i : Expr J) |
| (x y : Fin w.length) (s : Fin ((instanceData M d q w).slotLimit K)) |
| (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) (hi : i.eval σ w=s.val) : |
| Represents σ w pad (.slot t v a b i) (some (.inl ((t,v,x,y),s))) |
|
|
| theorem Represents.rename {J' : Type uJ'} (f : J → J') (σ : J' → ℕ) (w : List Bool) (pad : ℕ) |
| (x : Location M d q K J) (v : RawVertex M d q K w pad) |
| (h : Represents M d q K (σ ∘ f) w pad x v) : |
| Represents M d q K σ w pad (x.rename f) v := by |
| cases h with |
| | hub => exact .hub |
| | hole i => exact .hole i |
| | slot t v a b i x y s ha hb hi => |
| exact .slot t v _ _ _ x y s (by simpa only [Expr.rename_eval] using ha) |
| (by simpa only [Expr.rename_eval] using hb) (by simpa only [Expr.rename_eval] using hi) |
|
|
| noncomputable def adjacency (N : Expr J) (ε : F₂) : |
| Location M d q K J → Location M d q K J → Predicate J |
| | .hub,.hub => .truth false |
| | .hub,_ => .truth true |
| | _,.hub => .truth true |
| | .slot t v a b i,.slot u z c e j => slotPredicate M d q K N ε t u v z a b i c e j |
| | _,_ => .truth false |
|
|
| theorem adjacency_correct (N : Expr J) (hK : 0<K) (hr : 1≤d+q) (ε : F₂) |
| (σ : J → ℕ) (w : List Bool) (pad : ℕ) (hN : N.eval σ w=w.length) |
| (x y : Location M d q K J) (v z : RawVertex M d q K w pad) |
| (hx : Represents M d q K σ w pad x v) (hy : Represents M d q K σ w pad y z) : |
| (adjacency M d q K N ε x y).Holds σ w ↔ |
| ((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj v z := by |
| cases hx <;> cases hy |
| case slot.slot t v a b i x y s ha hb hi u z c e j l h t' hc he hj => |
| exact slotPredicate_correct M d q K N hK hr ε σ w hN t u v z a b i c e j x y l h s t' pad ha hb hi hc he hj |
| all_goals simp [adjacency,Predicate.Holds,ConsistencyData.rectangularGraph, |
| ConsistencyData.slots,Marking.rawGraph,Marking.rawAdj,Marking.decodeSlots] |
| |
| abbrev up3 {J : Type uJ} : J → Option (Option (Option J)) := some ∘ some ∘ some |
|
|
| def slotLocation (t : BlockTag M d q K) (v : Values M d q K) : Location M d q K (Option (Option (Option J))) := |
| .slot t v (.var (some (some none))) (.var (some none)) (.var none) |
|
|
| noncomputable def columns (N L P : Expr J) (ε : F₂) (row : Location M d q K J) : Writer J := |
| Enumeration.writer (ofFintype (BlockTag M d q K)) (ofFintype (Values M d q K)) N L P |
| (.emit (adjacency M d q K N ε row .hub)) |
| (fun t v => .emit (adjacency M d q K (N.rename up3) ε (row.rename up3) (slotLocation M d q K t v))) |
| (.emit (adjacency M d q K (N.rename some) ε (row.rename some) .hole)) |
|
|
| theorem columns_eval (N L P : Expr J) (hK : 0<K) (hr : 1≤d+q) (ε : F₂) |
| (σ : J → ℕ) (w : List Bool) (pad : ℕ) |
| (hN : N.eval σ w=w.length) (hL : L.eval σ w=(instanceData M d q w).slotLimit K) |
| (hP : P.eval σ w=pad) (row : Location M d q K J) (x : RawVertex M d q K w pad) |
| (hx : Represents M d q K σ w pad row x) : |
| (columns M d q K N L P ε row).eval σ w= |
| (listing M d q K w pad).items.map |
| (fun y => decide (((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj x y)) := by |
| classical |
| rw [show (listing M d q K w pad).items.map |
| (fun y => decide (((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj x y)) = |
| (listing M d q K w pad).items.flatMap |
| (fun y => [decide (((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj x y)]) from |
| List.map_eq_flatMap] |
| apply Enumeration.writer_eval _ _ N L P _ _ _ σ w w.length _ pad hN hL hP |
| · simp only [Writer.eval,List.singleton_inj] |
| exact decide_eq_decide.mpr (adjacency_correct M d q K N hK hr ε σ w pad hN row .hub x none hx .hub) |
| · intro t v a b i |
| simp only [Writer.eval,List.singleton_inj] |
| apply decide_eq_decide.mpr |
| apply adjacency_correct M d q K _ hK hr ε _ w pad |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hN |
| · exact Represents.rename M d q K up3 _ w pad row x hx |
| · exact .slot t v _ _ _ a b i rfl rfl rfl |
| · intro i |
| simp only [Writer.eval,List.singleton_inj] |
| apply decide_eq_decide.mpr |
| apply adjacency_correct M d q K _ hK hr ε _ w pad |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hN |
| · exact Represents.rename M d q K some _ w pad row x hx |
| · exact .hole i |
|
|
| noncomputable def matrixWriter (N L P : Expr J) (ε : F₂) : Writer J := |
| Enumeration.writer (ofFintype (BlockTag M d q K)) (ofFintype (Values M d q K)) N L P |
| (columns M d q K N L P ε .hub) |
| (fun t v => columns M d q K (N.rename up3) (L.rename up3) (P.rename up3) ε (slotLocation M d q K t v)) |
| (columns M d q K (N.rename some) (L.rename some) (P.rename some) ε .hole) |
|
|
| theorem matrixWriter_eval (N L P : Expr J) (hK : 0<K) (hr : 1≤d+q) (ε : F₂) |
| (σ : J → ℕ) (w : List Bool) (pad : ℕ) |
| (hN : N.eval σ w=w.length) (hL : L.eval σ w=(instanceData M d q w).slotLimit K) |
| (hP : P.eval σ w=pad) : |
| (matrixWriter M d q K N L P ε).eval σ w= |
| (listing M d q K w pad).items.flatMap (fun x => (listing M d q K w pad).items.map |
| (fun y => decide (((instanceData M d q w).rectangularGraph K hK hr ε pad).Adj x y))) := by |
| apply Enumeration.writer_eval _ _ N L P _ _ _ σ w w.length _ pad hN hL hP |
| · exact columns_eval M d q K N L P hK hr ε σ w pad hN hL hP .hub none .hub |
| · intro t v a b i |
| apply columns_eval M d q K _ _ _ hK hr ε _ w pad |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hL |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hP |
| · exact .slot t v _ _ _ a b i rfl rfl rfl |
| · intro i |
| apply columns_eval M d q K _ _ _ hK hr ε _ w pad |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hL |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hP |
| · exact .hole i |
|
|
| theorem columns_depth (N L P : Expr J) (ε : F₂) (row : Location M d q K J) : |
| (columns M d q K N L P ε row).depth≤3 := |
| Enumeration.writer_depth _ _ _ _ _ _ _ _ 0 (by exact Nat.zero_le _) (fun _ _ => le_rfl) (by exact Nat.zero_le _) |
|
|
| theorem matrixWriter_depth (N L P : Expr J) (ε : F₂) : (matrixWriter M d q K N L P ε).depth≤6 := |
| Enumeration.writer_depth _ _ _ _ _ _ _ _ 3 ((columns_depth M d q K N L P ε .hub).trans (by omega)) |
| (fun t v => columns_depth M d q K _ _ _ ε _) ((columns_depth M d q K _ _ _ ε .hole).trans (by omega)) |
| end WLTime.OneTape.Symbolic |
|
|
| namespace WLTime.OneTape.Symbolic |
| open CircuitEncoding NatCode Compression Enumeration |
| variable (M : OneTape) (d q K : ℕ) {J : Type uJ} |
| open scoped Classical |
|
|
| theorem coefficient_eq (w : List Bool) : |
| coefficient M d q K=(instanceData M d q w).rectCoefficient K := rfl |
|
|
| theorem tagIndex_le (t : BlockTag M d q K) : |
| (Fintype.equivFin _ t).val≤coefficient M d q K := by |
| apply (Nat.le_of_lt (Fintype.equivFin _ t).isLt).trans |
| exact Nat.le_mul_of_pos_right _ ((instanceData M d q []).tagValues_card_pos K) |
|
|
| theorem countExpr_bounded (N : Expr J) (t : BlockTag M d q K) (a b : Expr J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hm : 1≤w.length) |
| (hN : N.eval σ w=w.length) (hNB : N.Bounded σ w B) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) |
| (hax : a.eval σ w<w.length) (hbx : b.eval σ w<w.length) |
| (hC : coefficient M d q K≤B) (hL : (instanceData M d q w).slotLimit K≤B) : |
| (countExpr M d q K N t a b).Bounded σ w B := by |
| let c := coefficient M d q K |
| let m := w.length |
| let z := (Fintype.equivFin _ t).val |
| let x := a.eval σ w |
| let y := b.eval σ w |
| have hz : z≤c := tagIndex_le M d q K t |
| have ht : z<Fintype.card (BlockTag M d q K) := (Fintype.equivFin _ t).isLt |
| have hraw : y+m*(x+m*z)+1≤c*m^2 := by |
| have hh := ConsistencyData.mixedCode_le K t (⟨x,hax⟩ : Fin m) (⟨y,hbx⟩ : Fin m) |
| have hc : Fintype.card (BlockTag M d q K)≤c := |
| Nat.le_mul_of_pos_right _ ((instanceData M d q []).tagValues_card_pos K) |
| exact hh.trans (Nat.mul_le_mul_right _ hc) |
| have hQ : (c*m^2+1)^2+1≤B := hL |
| have hcpos : 1≤c := by |
| by_contra h |
| have hc0 : c=0 := by omega |
| rw [hc0,zero_mul] at hraw |
| omega |
| have hm2 : m*m≤c*m^2 := by simpa only [pow_two] using Nat.le_mul_of_pos_left (m*m) hcpos |
| have hcm : c*m^2+1≤B := by nlinarith [Nat.zero_le ((c*m^2)*(c*m^2))] |
| have hzm : m*z≤x+m*z := Nat.le_add_left _ _ |
| have hxm : x+m*z ≤ m*(x+m*z) := Nat.le_mul_of_pos_left _ hm |
| have hsum : y+m*(x+m*z)+1≤B := hraw.trans (by omega) |
| have hmul : (y+m*(x+m*z)+1)*(c*m^2+1)≤B := by |
| calc |
| _ ≤ (c*m^2+1)*(c*m^2+1) := Nat.mul_le_mul_right _ (by omega) |
| _ ≤ B := by nlinarith |
| unfold countExpr |
| simp only [Expr.mul,Expr.add,Expr.Bounded,Expr.eval,Binary.eval,hN] |
| change (((b.Bounded σ w B ∧ (N.Bounded σ w B ∧ (a.Bounded σ w B ∧ |
| (N.Bounded σ w B ∧ z≤B ∧ m*z≤B) ∧ x+m*z≤B) ∧ m*(x+m*z)≤B) ∧ y+m*(x+m*z)≤B) ∧ |
| 1≤B ∧ y+m*(x+m*z)+1≤B) ∧ ((c≤B ∧ (N.Bounded σ w B ∧ N.Bounded σ w B ∧ m*m≤B) ∧ |
| c*(m*m)≤B) ∧ 1≤B ∧ c*(m*m)+1≤B) ∧ (y+m*(x+m*z)+1)*(c*(m*m)+1)≤B) |
| exact ⟨⟨⟨hb,⟨hNB,⟨ha,⟨hNB,hz.trans hC,by omega⟩,by omega⟩,by omega⟩,by omega⟩, |
| by omega,hsum⟩,⟨⟨hC,⟨hNB,hNB,hm2.trans (by omega)⟩,by nlinarith [hcm]⟩, |
| by omega,by simpa only [pow_two] using hcm⟩,by simpa only [pow_two] using hmul⟩ |
|
|
| theorem sameRect_bounded (t u : BlockTag M d q K) (v z : Values M d q K) |
| (a b c e : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) (hc : c.Bounded σ w B) (he : e.Bounded σ w B) : |
| (sameRect M d q K t u v z a b c e).Bounded σ w B := ⟨trivial,⟨ha,hc⟩,hb,he⟩ |
|
|
| theorem slotPredicate_bounded (N : Expr J) (ε : F₂) (t u : BlockTag M d q K) |
| (v z : Values M d q K) (a b i c e j : Expr J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hm : 1≤w.length) |
| (hN : N.eval σ w=w.length) (hNB : N.Bounded σ w B) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) (hi : i.Bounded σ w B) |
| (hc : c.Bounded σ w B) (he : e.Bounded σ w B) (hj : j.Bounded σ w B) |
| (hax : a.eval σ w<w.length) (hbx : b.eval σ w<w.length) |
| (hcx : c.eval σ w<w.length) (hex : e.eval σ w<w.length) |
| (hC : coefficient M d q K≤B) (hL : (instanceData M d q w).slotLimit K≤B) : |
| (slotPredicate M d q K N ε t u v z a b i c e j).Bounded σ w (6*B) := by |
| have hB : 1≤B := hm.trans (hN.symm ▸ N.eval_le σ w B hNB) |
| have hBB : B≤6*B := by omega |
| have hv := validity_bounded M d q N K ε t v a b σ w B hB hNB ha hb |
| have hz := validity_bounded M d q N K ε u z c e σ w B hB hNB hc he |
| have hR := adjacent_bounded M d q N K t u v z a b c e σ w B hB hNB ha hb hc he |
| have hS := sameRect_bounded M d q K t u v z a b c e σ w B ha hb hc he |
| have hS' := (sameRect M d q K t u v z a b c e).bounded_mono σ w hS hBB |
| have hx := (countExpr M d q K N t a b).bounded_mono σ w |
| (countExpr_bounded M d q K N t a b σ w B hm hN hNB ha hb hax hbx hC hL) hBB |
| have hy := (countExpr M d q K N u c e).bounded_mono σ w |
| (countExpr_bounded M d q K N u c e σ w B hm hN hNB hc he hcx hex hC hL) hBB |
| have hi' := i.bounded_mono σ w hi hBB |
| have hj' := j.bounded_mono σ w hj hBB |
| unfold slotPredicate Predicate.rectangular Predicate.le Predicate.disj |
| simp only [Predicate.Bounded] |
| exact ⟨hv,hz,⟨hx,hi'⟩,⟨hy,hj'⟩,⟨⟨hi',by exact Nat.zero_le _⟩,⟨hj',by exact Nat.zero_le _⟩,hR⟩, |
| ⟨⟨hi',by exact Nat.zero_le _⟩,⟨hj',by exact Nat.zero_le _⟩,hS'⟩, |
| ⟨hi',by exact Nat.zero_le _⟩,⟨hj',by exact Nat.zero_le _⟩,hS'⟩ |
|
|
| namespace Location |
| variable {M d q K} |
| def Bounded (σ : J → ℕ) (w : List Bool) (B : ℕ) : Location M d q K J → Prop |
| | .slot _ _ a b i => a.Bounded σ w B ∧ b.Bounded σ w B ∧ i.Bounded σ w B ∧ |
| a.eval σ w<w.length ∧ b.eval σ w<w.length |
| | _ => True |
| theorem rename_bounded {J' : Type uJ'} (f : J → J') (x : Location M d q K J) |
| (σ : J' → ℕ) (w : List Bool) (B : ℕ) : |
| (x.rename f).Bounded σ w B ↔ x.Bounded (σ ∘ f) w B := by |
| cases x <;> simp only [rename,Bounded,Expr.rename_bounded,Expr.rename_eval] |
| end Location |
| |
| theorem adjacency_bounded (N : Expr J) (ε : F₂) (x y : Location M d q K J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hm : 1≤w.length) |
| (hN : N.eval σ w=w.length) (hNB : N.Bounded σ w B) |
| (hx : x.Bounded σ w B) (hy : y.Bounded σ w B) |
| (hC : coefficient M d q K≤B) (hL : (instanceData M d q w).slotLimit K≤B) : |
| (adjacency M d q K N ε x y).Bounded σ w (6*B) := by |
| cases x <;> cases y |
| case slot.slot t v a b i u z c e j => |
| exact slotPredicate_bounded M d q K N ε t u v z a b i c e j σ w B hm hN hNB |
| hx.1 hx.2.1 hx.2.2.1 hy.1 hy.2.1 hy.2.2.1 hx.2.2.2.1 hx.2.2.2.2 hy.2.2.2.1 hy.2.2.2.2 hC hL |
| all_goals trivial |
| |
| theorem columns_safe (N L P : Expr J) (ε : F₂) (row : Location M d q K J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hm : 1≤w.length) |
| (hN : N.eval σ w=w.length) (hL : L.eval σ w=(instanceData M d q w).slotLimit K) |
| (hNB : N.Bounded σ w B) (hLB : L.Bounded σ w B) (hPB : P.Bounded σ w B) |
| (hx : row.Bounded σ w B) (hC : coefficient M d q K≤B) : |
| (columns M d q K N L P ε row).Safe σ w (6*B) := by |
| have hBB : B≤6*B := by omega |
| have hlimit : (instanceData M d q w).slotLimit K≤B := hL ▸ L.eval_le σ w B hLB |
| apply Enumeration.writer_safe _ _ N L P _ _ _ σ w (6*B) |
| (N.bounded_mono σ w hNB hBB) (L.bounded_mono σ w hLB hBB) (P.bounded_mono σ w hPB hBB) |
| · exact adjacency_bounded M d q K N ε row .hub σ w B hm hN hNB hx trivial hC hlimit |
| · intro t v a ha b hb i hi |
| apply adjacency_bounded M d q K _ ε _ _ _ w B hm |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_bounded,up3,Function.comp_def,Option.elim'_some] using hNB |
| · simpa only [Location.rename_bounded,up3,Function.comp_def,Option.elim'_some] using hx |
| · change a≤B ∧ b≤B ∧ i≤B ∧ a<w.length ∧ b<w.length |
| have hnB := N.eval_le σ w B hNB |
| have hlB := L.eval_le σ w B hLB |
| exact ⟨by omega,by omega,by omega,by omega,by omega⟩ |
| · exact hC |
| · exact hlimit |
| · intro i hi |
| apply adjacency_bounded M d q K _ ε _ _ _ w B hm |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hNB |
| · simpa only [Location.rename_bounded,Function.comp_def,Option.elim'_some] using hx |
| · trivial |
| · exact hC |
| · exact hlimit |
|
|
| theorem matrixWriter_safe (N L P : Expr J) (ε : F₂) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hm : 1≤w.length) |
| (hN : N.eval σ w=w.length) (hL : L.eval σ w=(instanceData M d q w).slotLimit K) |
| (hNB : N.Bounded σ w B) (hLB : L.Bounded σ w B) (hPB : P.Bounded σ w B) |
| (hC : coefficient M d q K≤B) : |
| (matrixWriter M d q K N L P ε).Safe σ w (6*B) := by |
| have hBB : B≤6*B := by omega |
| apply Enumeration.writer_safe _ _ N L P _ _ _ σ w (6*B) |
| (N.bounded_mono σ w hNB hBB) (L.bounded_mono σ w hLB hBB) (P.bounded_mono σ w hPB hBB) |
| · exact columns_safe M d q K N L P ε .hub σ w B hm hN hL hNB hLB hPB trivial hC |
| · intro t v a ha b hb i hi |
| apply columns_safe M d q K _ _ _ ε _ _ w B hm |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_eval,up3,Function.comp_def,Option.elim'_some] using hL |
| · simpa only [Expr.rename_bounded,up3,Function.comp_def,Option.elim'_some] using hNB |
| · simpa only [Expr.rename_bounded,up3,Function.comp_def,Option.elim'_some] using hLB |
| · simpa only [Expr.rename_bounded,up3,Function.comp_def,Option.elim'_some] using hPB |
| · change a≤B ∧ b≤B ∧ i≤B ∧ a<w.length ∧ b<w.length |
| have hnB := N.eval_le σ w B hNB |
| have hlB := L.eval_le σ w B hLB |
| exact ⟨by omega,by omega,by omega,by omega,by omega⟩ |
| · exact hC |
| · intro i hi |
| apply columns_safe M d q K _ _ _ ε _ _ w B hm |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hN |
| · simpa only [Expr.rename_eval,Function.comp_def,Option.elim'_some] using hL |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hNB |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hLB |
| · simpa only [Expr.rename_bounded,Function.comp_def,Option.elim'_some] using hPB |
| · trivial |
| · exact hC |
| end WLTime.OneTape.Symbolic |
|
|
| end OAI |
|
|
