| import OAI.Computability.WeisfeilerLeman.Simulation |
|
|
| namespace OAI |
|
|
| universe uJ uT uP uE uA uB uA' uB' uV uW uU |
|
|
| namespace WLTime.OneTape |
| open NatCode |
| variable (M : OneTape) {J : Type uJ} |
| theorem inputPredicate_bounded (f : M.Cell) (a : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (ha : a.Bounded σ w B) : (M.inputPredicate f a).Bounded σ w B := by |
| simp only [inputPredicate,Predicate.bounded_disj,Predicate.Bounded,Expr.Bounded] |
| exact ⟨⟨⟨ha,trivial⟩,ha,trivial⟩,⟨⟨⟨ha,Nat.zero_le _⟩,trivial⟩,⟨ha,Nat.zero_le _⟩,trivial⟩⟩ |
| end WLTime.OneTape |
|
|
| namespace WLTime.Compression |
| open NatCode |
| namespace FormalName |
| variable {T : Type uT} {J : Type uJ} |
| def Bounded (σ : J → ℕ) (w : List Bool) (B : ℕ) (n : FormalName T J) : Prop := |
| n.first.Bounded σ w B ∧ n.second.Bounded σ w B |
| theorem equal_bounded (σ : J → ℕ) (w : List Bool) (B : ℕ) (a b : FormalName T J) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) : (a.equal b).Bounded σ w B := by |
| exact ⟨trivial,⟨ha.1,hb.1⟩,ha.2,hb.2⟩ |
| end FormalName |
| namespace ConsistencyData |
| variable {r m : ℕ} {P : Type uP} {E : Type uE} {J : Type uJ} (I : ConsistencyData (r+1) m P E) |
| variable (D : E → Fin (r+1) → Expr J → Predicate J) (Q : E → Fin (r+1) → Expr J → Expr J) |
|
|
| theorem blockPredicate_bounded (K : ℕ) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Expr J) |
| (hD : ∀e i,(D e i a).Bounded σ w B ∧ (D e i b).Bounded σ w B) : |
| (blockPredicate D K t a b).Bounded σ w B := by |
| rcases t with ⟨i,t|l⟩ |
| · cases t with |
| | inl p => exact ⟨trivial,trivial⟩ |
| | inr e => exact ⟨(hD e.1 i).1,(hD e.1 (finRotate (r+1) i)).2⟩ |
| · exact ⟨(hD l.1 i).1,(hD l.1 (finRotate (r+1) i)).2⟩ |
|
|
| theorem validPredicate_bounded (K : ℕ) (ε : F₂) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (t : BlockTag (r:=r) (P:=P) (E:=E) K) (v : I.TagValues K) (a b : Expr J) |
| (hD : ∀e i,(D e i a).Bounded σ w B ∧ (D e i b).Bounded σ w B) : |
| (I.validPredicate D K ε t v a b).Bounded σ w B := |
| ⟨blockPredicate_bounded D K σ w B t a b hD,trivial⟩ |
|
|
| theorem formalFootprint_bounded (K : ℕ) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Expr J) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) |
| (hQ : ∀e i,(Q e i a).Bounded σ w B ∧ (Q e i b).Bounded σ w B) : |
| ∀n∈I.formalFootprint Q K t a b,n.Bounded σ w B := by |
| rcases t with ⟨i,t|l⟩ |
| · intro n hn |
| simp only [formalFootprint,List.mem_cons,List.not_mem_nil,or_false] at hn |
| subst n |
| exact ⟨ha,hb⟩ |
| · intro n hn |
| simp only [formalFootprint,List.mem_cons,List.not_mem_nil,or_false] at hn |
| rcases hn with rfl|rfl|rfl|rfl |
| · exact ⟨ha,hb⟩ |
| · unfold FormalName.Bounded matchCode |
| split_ifs |
| · exact ⟨(hQ l.1 i).1,(hQ l.1 (finRotate (r+1) i)).2⟩ |
| · exact ⟨ha,hb⟩ |
| · exact ⟨ha,Nat.zero_le _⟩ |
| · exact ⟨hb,Nat.zero_le _⟩ |
|
|
| theorem overlapPredicate_bounded (K : ℕ) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (l s : List (FormalName (Tag (r:=r) (P:=P) (E:=E) K) J)) |
| (hl : ∀a∈l,a.Bounded σ w B) (hs : ∀b∈s,b.Bounded σ w B) : |
| (overlapPredicate K l s).Bounded σ w B := by |
| rw [overlapPredicate,Predicate.bounded_any] |
| intro p hp |
| obtain ⟨a,ha,hp⟩ := List.mem_flatMap.mp hp |
| obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hp |
| exact FormalName.equal_bounded σ w B a b (hl a ha) (hs b hb) |
|
|
| theorem agreePredicate_bounded (K : ℕ) (σ : J → ℕ) (w : List Bool) (B : ℕ) (v u : I.TagValues K) |
| (l s : List (FormalName (Tag (r:=r) (P:=P) (E:=E) K) J)) |
| (hl : ∀a∈l,a.Bounded σ w B) (hs : ∀b∈s,b.Bounded σ w B) : |
| (I.agreePredicate K v u l s).Bounded σ w B := by |
| rw [agreePredicate,Predicate.bounded_all] |
| intro p hp |
| obtain ⟨a,ha,hp⟩ := List.mem_flatMap.mp hp |
| obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hp |
| exact ⟨FormalName.equal_bounded σ w B a b (hl a ha) (hs b hb),trivial⟩ |
|
|
| theorem adjacencyPredicate_bounded (K : ℕ) (σ : J → ℕ) (w : List Bool) (B : ℕ) |
| (t u : BlockTag (r:=r) (P:=P) (E:=E) K) (v z : I.TagValues K) (a b c d : Expr J) |
| (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) (hc : c.Bounded σ w B) (hd : d.Bounded σ w B) |
| (hQ : ∀e i,(Q e i a).Bounded σ w B ∧ (Q e i b).Bounded σ w B ∧ |
| (Q e i c).Bounded σ w B ∧ (Q e i d).Bounded σ w B) : |
| (I.adjacencyPredicate Q K t u v z a b c d).Bounded σ w B := by |
| have hl := I.formalFootprint_bounded Q K σ w B t a b ha hb (fun e i => ⟨(hQ e i).1,(hQ e i).2.1⟩) |
| have hs := I.formalFootprint_bounded Q K σ w B u c d hc hd (fun e i => (hQ e i).2.2) |
| exact ⟨⟨trivial,⟨ha,hc⟩,hb,hd⟩,overlapPredicate_bounded K σ w B _ _ hl hs, |
| I.agreePredicate_bounded K σ w B v z _ _ hl hs⟩ |
| end ConsistencyData |
| end WLTime.Compression |
|
|
| namespace WLTime.OneTape.Symbolic |
| open CircuitEncoding NatCode Compression |
| variable (M : OneTape) (d q : ℕ) |
|
|
| abbrev Node := Schematic.Node (Tableau.Gate M.Cell) (BoxTableau.Label M.Cell d (q+1)) |
| abbrev Edge := Schematic.Edge (BoxTableau.Label M.Cell d (q+1)) (M.Cell ⊕ Fin q) |
| {f : M.Cell // M.letterAccepting f} |
|
|
| noncomputable def schema (w : List Bool) : Schematic (d+q+1) w.length (Tableau.Gate M.Cell) |
| (BoxTableau.Label M.Cell d (q+1)) (M.Cell ⊕ Fin q) {f : M.Cell // M.letterAccepting f} := |
| BoxTableau.schematic (d:=d) (q:=q) M.localRule (M.inputCell w) M.blankCell M.letterAccepting |
|
|
| noncomputable def instanceData (w : List Bool) : ConsistencyData (d+q+1) w.length (Node M d q) (Edge M d q) := |
| (schema M d q w).consistency |
|
|
| variable {J : Type uJ} |
| noncomputable def domain (N : Expr J) : Edge M d q → Fin (d+q+1) → Expr J → Predicate J |
| | .first e,i,a => BoxTableau.Formula.labelDomain e N a i |
| | .second e,i,a => BoxTableau.Formula.labelDomain e N a i |
| | .third e,i,a => BoxTableau.Formula.labelDomain e N a i |
| | .seed s,i,a => BoxTableau.Formula.seed (d:=d) (q:=q) M.inputPredicate s a i |
| | .test _,i,a => BoxTableau.Formula.test (d:=d) (q:=q) N a i |
|
|
| def coord (N : Expr J) : Edge M d q → Fin (d+q+1) → Expr J → Expr J |
| | .third e,i,a => BoxTableau.Formula.labelCoord e N a i |
| | _,_,a => a |
|
|
| theorem domain_correct (N : Expr J) (σ : J → ℕ) (w : List Bool) (hN : N.eval σ w=w.length) |
| (e : Edge M d q) (i : Fin (d+q+1)) (a : Expr J) (x : Fin w.length) (ha : a.eval σ w=x.val) : |
| (domain M d q N e i a).Holds σ w ↔ x∈(instanceData M d q w).domain e i := by |
| classical |
| cases e with |
| | first e | second e | third e => |
| exact BoxTableau.Formula.labelDomain_correct e N a i σ w x hN ha |
| | seed s => |
| exact BoxTableau.Formula.seed_correct (M.inputCell w) M.inputPredicate σ w |
| (fun f a x hx => M.inputPredicate_correct f a σ w x hx) s a i x ha |
| | test f => exact BoxTableau.Formula.test_correct (d:=d) (q:=q) M.letterAccepting f N a i σ w x hN ha |
|
|
| theorem coord_correct (N : Expr J) (σ : J → ℕ) (w : List Bool) (hN : N.eval σ w=w.length) |
| (e : Edge M d q) (i : Fin (d+q+1)) (a : Expr J) (x : Fin w.length) |
| (hx : x∈(instanceData M d q w).domain e i) (ha : a.eval σ w=x.val) : |
| (coord M d q N e i a).eval σ w=((instanceData M d q w).coord e i ⟨x,hx⟩).val := by |
| cases e with |
| | first | second | seed | test => exact ha |
| | third e => exact BoxTableau.Formula.labelCoord_correct e N a i σ w x hN ha |
|
|
| abbrev BlockTag (K : ℕ) := ConsistencyData.BlockTag (r:=d+q) (P:=Node M d q) (E:=Edge M d q) K |
| abbrev Values (K : ℕ) := (instanceData M d q []).TagValues K |
|
|
| theorem fixedLegal_iff (K : ℕ) (ε : F₂) (w : List Bool) (t : BlockTag M d q K) |
| (v : Values M d q K) : |
| (instanceData M d q []).FixedLegal K ε t v ↔ (instanceData M d q w).FixedLegal K ε t v := by |
| unfold ConsistencyData.FixedLegal ConsistencyData.fixedForm ConsistencyData.fixedBias |
| rcases t with ⟨i,t|⟨e,j⟩⟩ |
| · rfl |
| · cases e <;> rfl |
|
|
| noncomputable def validity (N : Expr J) (K : ℕ) (ε : F₂) (t : BlockTag M d q K) |
| (v : Values M d q K) (a b : Expr J) : Predicate J := |
| (instanceData M d q []).validPredicate (domain M d q N) K ε t v a b |
|
|
| noncomputable def adjacent (N : Expr J) (K : ℕ) (t u : BlockTag M d q K) |
| (v z : Values M d q K) (a b c e : Expr J) : Predicate J := |
| (instanceData M d q []).adjacencyPredicate (coord M d q N) K t u v z a b c e |
|
|
| theorem validity_correct (N : Expr J) (K : ℕ) (ε : F₂) (σ : J → ℕ) (w : List Bool) |
| (hN : N.eval σ w=w.length) (t : BlockTag M d q K) (v : Values M d q K) |
| (a b : Expr J) (x y : Fin w.length) (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) : |
| (validity M d q N K ε t v a b).Holds σ w ↔ |
| (instanceData M d q w).DescriptorValid K ε (ConsistencyData.makeBlock K t x y,v) := by |
| erw [(instanceData M d q w).descriptorValid_fixed] |
| simp only [validity,ConsistencyData.validPredicate,Predicate.Holds,decide_eq_true_eq, |
| fixedLegal_iff M d q K ε w t v] |
| exact and_congr ((instanceData M d q w).blockPredicate_holds (domain M d q N) K σ w |
| (domain_correct M d q N σ w hN) t a b x y ha hb) Iff.rfl |
|
|
| theorem adjacent_correct (N : Expr J) (K : ℕ) (σ : J → ℕ) (w : List Bool) |
| (hN : N.eval σ w=w.length) (t u : BlockTag M d q K) (v z : Values M d q K) |
| (a b c e : Expr J) (x y p s : Fin w.length) |
| (ha : a.eval σ w=x.val) (hb : b.eval σ w=y.val) (hc : c.eval σ w=p.val) (he : e.eval σ w=s.val) |
| (ht : (instanceData M d q w).ValidBlock K (ConsistencyData.makeBlock K t x y)) |
| (hu : (instanceData M d q w).ValidBlock K (ConsistencyData.makeBlock K u p s)) : |
| (adjacent M d q N K t u v z a b c e).Holds σ w ↔ |
| (instanceData M d q w).RawAdjacent K (ConsistencyData.makeBlock K t x y,v) |
| (ConsistencyData.makeBlock K u p s,z) := by |
| change ((instanceData M d q w).adjacencyPredicate (coord M d q N) K t u v z a b c e).Holds σ w ↔ _ |
| exact (instanceData M d q w).adjacencyPredicate_correct (coord M d q N) K σ w |
| (coord_correct M d q N σ w hN) t u v z a b c e x y p s ha hb hc he ht hu |
| end WLTime.OneTape.Symbolic |
|
|
| namespace WLTime.OneTape.Symbolic |
| open CircuitEncoding NatCode Compression |
| variable (M : OneTape) (d q : ℕ) {J : Type uJ} |
|
|
| theorem domain_bounded (N : Expr J) (e : Edge M d q) (i : Fin (d+q+1)) (a : Expr J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B) |
| (hN : N.Bounded σ w B) (ha : a.Bounded σ w B) : |
| (domain M d q N e i a).Bounded σ w (6*B) := by |
| cases e with |
| | first e | second e | third e => exact BoxTableau.Formula.labelDomain_bounded e N a i σ w B hB hN ha |
| | seed s => |
| exact (BoxTableau.Formula.seed _ s a i).bounded_mono σ w |
| (BoxTableau.Formula.seed_bounded M.inputPredicate s a i σ w B ha (fun f => M.inputPredicate_bounded f a σ w B ha)) |
| (by omega) |
| | test f => |
| exact (BoxTableau.Formula.test (d:=d) (q:=q) N a i).bounded_mono σ w |
| (BoxTableau.Formula.test_bounded (d:=d) (q:=q) N a i σ w B hB hN ha) (by omega : 2*B≤6*B) |
|
|
| theorem coord_bounded (N : Expr J) (e : Edge M d q) (i : Fin (d+q+1)) (a : Expr J) |
| (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B) |
| (hN : N.Bounded σ w B) (ha : a.Bounded σ w B) : |
| (coord M d q N e i a).Bounded σ w (6*B) := by |
| cases e with |
| | third e => exact BoxTableau.Formula.labelCoord_bounded e N a i σ w B hB hN ha |
| | first | second | seed | test => exact a.bounded_mono σ w ha (by omega) |
|
|
| theorem validity_bounded (N : Expr J) (K : ℕ) (ε : F₂) (t : BlockTag M d q K) (v : Values M d q K) |
| (a b : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B) |
| (hN : N.Bounded σ w B) (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) : |
| (validity M d q N K ε t v a b).Bounded σ w (6*B) := |
| (instanceData M d q []).validPredicate_bounded _ K ε σ w (6*B) t v a b |
| (fun e i => ⟨domain_bounded M d q N e i a σ w B hB hN ha, |
| domain_bounded M d q N e i b σ w B hB hN hb⟩) |
|
|
| theorem adjacent_bounded (N : Expr J) (K : ℕ) (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 : ℕ) (hB : 1≤B) |
| (hN : N.Bounded σ w B) (ha : a.Bounded σ w B) (hb : b.Bounded σ w B) |
| (hc : c.Bounded σ w B) (he : e.Bounded σ w B) : |
| (adjacent M d q N K t u v z a b c e).Bounded σ w (6*B) := |
| (instanceData M d q []).adjacencyPredicate_bounded _ K σ w (6*B) t u v z a b c e |
| (a.bounded_mono σ w ha (by omega)) (b.bounded_mono σ w hb (by omega)) |
| (c.bounded_mono σ w hc (by omega)) (e.bounded_mono σ w he (by omega)) |
| (fun f i => ⟨coord_bounded M d q N f i a σ w B hB hN ha, |
| coord_bounded M d q N f i b σ w B hB hN hb, |
| coord_bounded M d q N f i c σ w B hB hN hc, |
| coord_bounded M d q N f i e σ w B hB hN he⟩) |
| end WLTime.OneTape.Symbolic |
|
|
| namespace WLTime.Compression.ConsistencyData |
| variable {r m : ℕ} {P : Type uP} {E : Type uE} (I : ConsistencyData (r+1) m P E) |
|
|
| abbrev Rect (K : ℕ) := BlockTag (r:=r) (P:=P) (E:=E) K × I.TagValues K × Fin m × Fin m |
|
|
| noncomputable def rectEquiv (K : ℕ) : I.Rect K ≃ I.Descriptor K where |
| toFun x := (makeBlock K x.1 x.2.2.1 x.2.2.2,x.2.1) |
| invFun x := match x.1 with |
| | .site i t a b => ((i,.inl t),x.2,a,b) |
| | .square i l a b => ((i,.inr l),x.2,a,b) |
| left_inv x := by rcases x with ⟨⟨i,t|l⟩,v,a,b⟩ <;> rfl |
| right_inv x := by rcases x with ⟨b,v⟩; cases b <;> rfl |
|
|
| def RectValid (K : ℕ) (ε : F₂) (v : I.Rect K) : Prop := |
| I.DescriptorValid K ε (I.rectEquiv K v) |
|
|
| noncomputable def rectVertexEquiv (K : ℕ) (hK : 0<K) (hr : 1≤r) (ε : F₂) : |
| {v : I.Rect K // I.RectValid K ε v} ≃ I.Vertex K ε := |
| (Equiv.subtypeEquiv (I.rectEquiv K) (fun _ => Iff.rfl)).trans (I.descriptorEquiv K hK hr ε) |
|
|
| variable [Fintype P] [Fintype E] |
| open scoped Classical |
|
|
| noncomputable def mixedCode (K : ℕ) (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Fin m) : ℕ := |
| (b.val+m*(a.val+m*(Fintype.equivFin _ t).val))+1 |
|
|
| theorem mixedCode_pos (K : ℕ) (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Fin m) : |
| 0 < mixedCode (m:=m) K t a b := by unfold mixedCode; omega |
|
|
| theorem mixedCode_le (K : ℕ) (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Fin m) : |
| mixedCode (m:=m) K t a b≤Fintype.card (BlockTag (r:=r) (P:=P) (E:=E) K)*m^2 := by |
| have ht := (finProdFinEquiv (finProdFinEquiv (Fintype.equivFin _ t,a),b)).isLt |
| change b.val+m*(a.val+m*(Fintype.equivFin _ t).val) < _ at ht |
| unfold mixedCode |
| nlinarith |
|
|
| theorem mixedCode_injective (K : ℕ) : |
| Function.Injective (fun x : BlockTag (r:=r) (P:=P) (E:=E) K × Fin m × Fin m => |
| mixedCode (m:=m) K x.1 x.2.1 x.2.2) := by |
| rintro ⟨t,a,b⟩ ⟨u,c,d⟩ h |
| have he : finProdFinEquiv (finProdFinEquiv (Fintype.equivFin _ t,a),b) = |
| finProdFinEquiv (finProdFinEquiv (Fintype.equivFin _ u,c),d) := by |
| apply Fin.ext |
| change b.val+m*(a.val+m*(Fintype.equivFin _ t).val) = d.val+m*(c.val+m*(Fintype.equivFin _ u).val) |
| simpa only [mixedCode,Nat.add_left_inj] using h |
| have h1 := finProdFinEquiv.injective he |
| have h2 := finProdFinEquiv.injective (congrArg Prod.fst h1) |
| have ht := (Fintype.equivFin _).injective (congrArg Prod.fst h2) |
| have ha : a=c := congrArg Prod.snd h2 |
| have hb : b=d := congrArg Prod.snd h1 |
| subst u; subst c; subst d; rfl |
|
|
| noncomputable def rawCode (K : ℕ) : RawBlock (r:=r) (m:=m) (P:=P) (E:=E) K → ℕ |
| | .site i t a b => mixedCode (P:=P) (E:=E) K (i,.inl t) a b |
| | .square i e a b => mixedCode (P:=P) (E:=E) K (i,.inr e) a b |
|
|
| theorem rawCode_make (K : ℕ) (t : BlockTag (r:=r) (P:=P) (E:=E) K) (a b : Fin m) : |
| rawCode K (makeBlock K t a b)=mixedCode K t a b := by rcases t with ⟨i,t|l⟩ <;> rfl |
|
|
| theorem rawCode_injective (K : ℕ) : Function.Injective (rawCode (r:=r) (m:=m) (P:=P) (E:=E) K) := by |
| intro x y h |
| cases x <;> cases y |
| all_goals simp only [rawCode] at h |
| all_goals have he := mixedCode_injective K (a₁:=(_,_,_)) (a₂:=(_,_,_)) h |
| all_goals simp only [Prod.mk.injEq,Sum.inl.injEq,Sum.inr.injEq,reduceCtorEq] at he |
| all_goals first | rcases he with ⟨⟨rfl,rfl⟩,rfl,rfl⟩; rfl | tauto |
|
|
| theorem rawCode_pos (K : ℕ) (v : RawBlock (r:=r) (m:=m) (P:=P) (E:=E) K) : 0<rawCode K v := by |
| cases v <;> exact mixedCode_pos (P:=P) (E:=E) K _ _ _ |
|
|
| theorem rawCode_le (K : ℕ) (v : RawBlock (r:=r) (m:=m) (P:=P) (E:=E) K) : |
| rawCode K v≤Fintype.card (BlockTag (r:=r) (P:=P) (E:=E) K)*m^2 := by |
| cases v <;> exact mixedCode_le (P:=P) (E:=E) K _ _ _ |
|
|
| noncomputable def rectCoefficient (K : ℕ) := |
| Fintype.card (BlockTag (r:=r) (P:=P) (E:=E) K)*Fintype.card (I.TagValues K) |
|
|
| theorem rect_card (K : ℕ) : Fintype.card (I.Rect K)=I.rectCoefficient K*m^2 := by |
| simp only [Rect,Fintype.card_prod,Fintype.card_fin,rectCoefficient,pow_two] |
| ring |
|
|
| theorem tagValues_card_pos (K : ℕ) : 0<Fintype.card (I.TagValues K) := by |
| apply Fintype.card_pos_iff.mpr |
| exact ⟨fun _ => 0⟩ |
|
|
| theorem rectangle_code_le (K : ℕ) (v : RawBlock (r:=r) (m:=m) (P:=P) (E:=E) K) : |
| rawCode K v≤I.rectCoefficient K*m^2 := by |
| apply (rawCode_le K v).trans |
| have h := I.tagValues_card_pos K |
| unfold rectCoefficient |
| gcongr |
| exact Nat.le_mul_of_pos_right _ h |
|
|
| theorem card_bases_le_rectangle (K : ℕ) (hK : 0<K) (hr : 1≤r) (ε : F₂) : |
| Fintype.card (I.Vertex K ε)≤I.rectCoefficient K*m^2 := by |
| rw [← Fintype.card_congr (I.rectVertexEquiv K hK hr ε),← I.rect_card K] |
| exact Fintype.card_subtype_le _ |
|
|
| noncomputable def spacedCount (K : ℕ) (v : I.Block K) : ℕ := |
| rawCode K v.val*(I.rectCoefficient K*m^2+1) |
|
|
| noncomputable def slotLimit (K : ℕ) : ℕ := (I.rectCoefficient K*m^2+1)^2+1 |
|
|
| theorem spacedCount_lt_limit (K : ℕ) (ε : F₂) (v : I.Vertex K ε) : |
| I.spacedCount K v.1+1≤I.slotLimit K := by |
| have h := I.rectangle_code_le K v.1.val |
| unfold spacedCount slotLimit |
| nlinarith |
|
|
| noncomputable def slots (K : ℕ) (hK : 0<K) (hr : 1≤r) (ε : F₂) (q : ℕ) : |
| (I.Rect K × Fin (I.slotLimit K)) ⊕ Fin q → Option (Marking.Slot (I.Vertex K ε) (fun v => I.spacedCount K v.1)) := |
| Marking.decodeSlots (I.rectVertexEquiv K hK hr ε) (I.slotLimit K) q |
|
|
| theorem slots_complete (K : ℕ) (hK : 0<K) (hr : 1≤r) (ε : F₂) (q : ℕ) |
| (v : Marking.Slot (I.Vertex K ε) (fun v => I.spacedCount K v.1)) : |
| ∃!u,I.slots K hK hr ε q u=some v := |
| Marking.decodeSlots_complete (I.rectVertexEquiv K hK hr ε) (I.slotLimit K) q |
| (I.spacedCount_lt_limit K ε) v |
|
|
| noncomputable def rectangularGraph (K : ℕ) (hK : 0<K) (hr : 1≤r) (ε : F₂) (q : ℕ) := |
| Marking.rawGraph (I.valuationGraph K ε) (I.slots K hK hr ε q) |
| end WLTime.Compression.ConsistencyData |
|
|
| namespace WLTime.Pebble |
| theorem wins_transport_iff {K : ℕ} {A : Type uA} {B : Type uB} {A' : Type uA'} {B' : Type uB'} |
| (G : SimpleGraph A) (H : SimpleGraph B) (G' : SimpleGraph A') (H' : SimpleGraph B') |
| (f : A ≃ A') (g : B ≃ B') |
| (hf : ∀x y,G.Adj x y ↔ G'.Adj (f x) (f y)) |
| (hg : ∀x y,H.Adj x y ↔ H'.Adj (g x) (g y)) : |
| Wins G H (fun _ _ => True) (fun _ : Fin K => none) ↔ |
| Wins G' H' (fun _ _ => True) (fun _ : Fin K => none) := by |
| constructor |
| · intro h; simpa only [Position.map_none] using h.transport f g hf hg |
| · intro h |
| have h' := h.transport f.symm g.symm |
| (fun x y => by simpa only [Equiv.apply_symm_apply] using (hf (f.symm x) (f.symm y)).symm) |
| (fun x y => by simpa only [Equiv.apply_symm_apply] using (hg (g.symm x) (g.symm y)).symm) |
| simpa only [Position.map_none] using h' |
| end WLTime.Pebble |
|
|
| namespace WLTime.Marking |
| variable {V : Type uV} {W : Type uW} {U : Type uU} [Fintype V] [Fintype W] [Fintype U] |
| variable (G : SimpleGraph V) (H : SimpleGraph W) (count : V → ℕ) (count' : W → ℕ) |
| omit [Fintype V] [Fintype W] in |
| theorem raw_wins_iff (a : U → Option (Slot V count)) (b : U → Option (Slot W count')) |
| (ha : ∀ v,∃!u,a u=some v) (hb : ∀ v,∃!u,b u=some v) |
| (hholes : Fintype.card {u // a u=none}=Fintype.card {u // b u=none}) (K : ℕ) : |
| Pebble.Wins (rawGraph G a) (rawGraph H b) (fun _ _ => True) (fun _ : Fin K => none) ↔ |
| Pebble.Wins (graph G count (Fintype.card {u // a u=none})) |
| (graph H count' (Fintype.card {u // a u=none})) (fun _ _ => True) (fun _ : Fin K => none) := by |
| classical |
| have h := Pebble.wins_transport_iff (K:=K) (rawGraph G a) (rawGraph H b) |
| (graph G count _) (graph H count' _) (rawEquiv a ha) (rawEquiv b hb) |
| (fun x y => (rawEquiv_adj G a ha x y).symm) (fun x y => (rawEquiv_adj H b hb x y).symm) |
| have he := congrArg (fun q => Pebble.Wins (graph G count (Fintype.card {u // a u=none})) |
| (graph H count' q) (fun _ _ => True) (fun _ : Fin K => none)) hholes.symm |
| exact h.trans (iff_of_eq he) |
| end WLTime.Marking |
|
|
| namespace WLTime.Compression.ConsistencyData |
| variable {r m : ℕ} {P : Type uP} {E : Type uE} (I : ConsistencyData (r+1) m P E) |
| variable [Fintype P] [Fintype E] [Nonempty P] |
| open scoped Classical |
|
|
| theorem spaced_wins_iff_ac (hr : 2≤r) (hm : 2 ≤ m) (q : ℕ) : |
| Pebble.Wins (Marking.graph (I.valuationGraph (r+2) 0) (fun v => I.spacedCount (r+2) v.1) q) |
| (Marking.graph (I.valuationGraph (r+2) 1) (fun v => I.spacedCount (r+2) v.1) q) |
| (fun _ _ => True) (fun _ : Fin (r+2) => none) ↔ I.ArcConsistent := by |
| classical |
| constructor |
| · intro h |
| apply (I.colored_wins_iff_ac hr).mp |
| exact Marking.wins_bases_spaced (I.valuationGraph (r+2) 0) (I.valuationGraph (r+2) 1) |
| Sigma.fst Sigma.fst (fun v : I.Block (r+2) => rawCode (r+2) v.val) |
| ((rawCode_injective (r+2)).comp Subtype.val_injective) |
| (fun v => rawCode_pos (r+2) v.val) (I.baseEquiv (r+2) (by omega)) (fun _ => rfl) |
| q (r+2) (I.rectCoefficient (r+2)*m^2) (I.card_bases_le_rectangle (r+2) (by omega) (by omega) 0) |
| (I.two_le_card_base (r+2) hm) (by omega) h |
| · intro h |
| obtain ⟨Q⟩ := I.arcConsistent_iff.mp h |
| exact (Marking.liftSystem Sigma.fst Sigma.fst (I.spacedCount (r+2)) q (r+2) |
| (I.valuationSystem Q (r+2) (by omega) hr le_rfl)).wins_empty |
|
|
| theorem rectangular_wins_iff_ac (hr : 2≤r) (hm : 2 ≤ m) (q : ℕ) : |
| Pebble.Wins (I.rectangularGraph (r+2) (by omega) (by omega) 0 q) |
| (I.rectangularGraph (r+2) (by omega) (by omega) 1 q) |
| (fun _ _ => True) (fun _ : Fin (r+2) => none) ↔ I.ArcConsistent := by |
| classical |
| have hh := Marking.raw_holes_eq (I.baseEquiv (r+2) (by omega)) (fun _ => rfl) |
| (I.slots (r+2) (by omega) (by omega) 0 q) (I.slots (r+2) (by omega) (by omega) 1 q) |
| (I.slots_complete (r+2) (by omega) (by omega) 0 q) (I.slots_complete (r+2) (by omega) (by omega) 1 q) |
| exact (Marking.raw_wins_iff _ _ _ _ _ _ |
| (I.slots_complete (r+2) (by omega) (by omega) 0 q) |
| (I.slots_complete (r+2) (by omega) (by omega) 1 q) hh (r+2)).trans (I.spaced_wins_iff_ac hr hm _) |
|
|
| omit [Nonempty P] in |
| theorem rectangular_card (K q : ℕ) : |
| Fintype.card (Option ((I.Rect K × Fin (I.slotLimit K)) ⊕ Fin q))= |
| 1+I.rectCoefficient K*m^2*((I.rectCoefficient K*m^2+1)^2+1)+q := by |
| classical |
| rw [Fintype.card_option,Fintype.card_sum,Fintype.card_prod,Fintype.card_fin,Fintype.card_fin,I.rect_card] |
| unfold slotLimit |
| omega |
| end WLTime.Compression.ConsistencyData |
|
|
| end OAI |
|
|
