| import Mathlib |
| import OAI.Computability.MinUncut.Graphs.CanonicalPathGraph |
|
|
| namespace OAI |
|
|
| section |
| namespace MinUncut.Costed.GraphRegisters |
| open MinUncut.PathRealization |
|
|
| def packDemand {N : ℕ} (d : Demand (Fin N)) : List ℕ := |
| [d.left.val,d.right.val,d.equal.toNat] |
| def packDemands {N : ℕ} (ds : List (Demand (Fin N))) : List ℕ := ds.flatMap packDemand |
|
|
| lemma packed_addresses {N : ℕ} (ds : List (Demand (Fin N))) (d : ℕ) (hd : d<ds.length) : |
| ((packDemands ds).drop (3*d)).headI=ds[d].left.val ∧ |
| ((packDemands ds).drop (3*d+1)).headI=ds[d].right.val ∧ |
| ((packDemands ds).drop (3*d+2)).headI=ds[d].equal.toNat := by |
| induction ds generalizing d with |
| | nil => simp at hd |
| | cons e ds ih => |
| cases d with |
| | zero => simp [packDemands,packDemand] |
| | succ d => |
| have hh : d<ds.length := by simpa using hd |
| simpa only [packDemands,List.flatMap_cons,packDemand,List.cons_append,List.nil_append, |
| Nat.mul_add,Nat.mul_one,Nat.add_assoc,List.drop_succ_cons,List.getElem_cons_succ, |
| Nat.succ_eq_add_one] using ih d hh |
|
|
| lemma canonicalLocal_iff {N M : ℕ} (e : Fin M → Demand (Fin N)) (d : Fin M) |
| (u v : Fin (N+M*3)) : |
| (∃j:Fin 4, j.val<(if (e d).equal then 4 else 3) ∧ |
| ((u=number N M (ends e (d,j)).1 ∧ v=number N M (ends e (d,j)).2) ∨ |
| (v=number N M (ends e (d,j)).1 ∧ u=number N M (ends e (d,j)).2))) ↔ |
| localAdj N d.val (e d).left.val (e d).right.val (e d).equal.toNat u.val v.val := by |
| simp only [show (4:ℕ)=3+1 from rfl,Fin.exists_fin_succ] |
| simp only [Fin.val_zero,Fin.val_succ] |
| cases h : (e d).equal <;> |
| simp [h,ends,localAdj,endpoint,Fin.ext_iff,number_left,number_right, |
| Nat.add_assoc,Nat.add_comm,Nat.add_left_comm,and_comm,or_assoc,or_comm,or_left_comm] |
| |
| lemma rawLocal_pack {N : ℕ} (ds : List (Demand (Fin N))) (d : Fin ds.length) (u v : ℕ) : |
| rawLocal N d.val (packDemands ds) u v= |
| localAdj N d.val ds[d].left.val ds[d].right.val ds[d].equal.toNat u v := by |
| obtain ⟨hL,hR,hE⟩ := packed_addresses ds d.val d.isLt |
| simp only [rawLocal,hL,hR,hE,Fin.getElem_fin] |
|
|
| lemma rawCell_canonical {N : ℕ} (ds : List (Demand (Fin N))) (u v : Fin (N+ds.length*3)) : |
| rawCell N ds.length (packDemands ds) u.val v.val= |
| (canonicalAdjacent (fun d:Fin ds.length=>ds[d]) u v).toNat := by |
| have he : (∃d<ds.length,rawLocal N d (packDemands ds) u.val v.val) ↔ |
| (∃d:Fin ds.length,∃j:Fin 4,j.val<(if ds[d].equal then 4 else 3) ∧ |
| ((u=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).1 ∧ |
| v=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).2) ∨ |
| (v=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).1 ∧ |
| u=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).2))) := by |
| constructor |
| · rintro ⟨d,hd,h⟩ |
| refine ⟨⟨d,hd⟩,(canonicalLocal_iff (fun d:Fin ds.length=>ds[d]) ⟨d,hd⟩ u v).mpr ?_⟩ |
| exact (rawLocal_pack ds ⟨d,hd⟩ u.val v.val).mp h |
| · rintro ⟨d,h⟩ |
| refine ⟨d.val,d.isLt,?_⟩ |
| have hx := (canonicalLocal_iff (fun d:Fin ds.length=>ds[d]) d u v).mp h |
| simpa only [←rawLocal_pack] using hx |
| unfold rawCell canonicalAdjacent |
| simp only [he] |
| by_cases hh : ∃ d:Fin ds.length,∃j:Fin 4,j.val<(if ds[d].equal then 4 else 3) ∧ |
| ((u=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).1 ∧ |
| v=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).2) ∨ |
| (v=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).1 ∧ |
| u=number N ds.length (ends (fun d:Fin ds.length=>ds[d]) (d,j)).2)) <;> |
| simp only [hh,ite_true,ite_false,decide_true,decide_false,Bool.toNat_true,Bool.toNat_false] |
| |
| end MinUncut.Costed.GraphRegisters |
| |
| end |
| |
| end OAI |
| |
