File size: 3,778 Bytes
ea76aac | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | 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
|