From 37a7950ead96e1d45e5c5bbb11d6aa9ae17359c9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 02:48:52 -0800 Subject: [PATCH 01/11] chore(quest): claim quest/m2/multicast/proof.md Quest-Claim: 8a7ee218ce9ba6ff From 7d1bd2d32aff65abcee4db935b11bbccd04f321a Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 03:12:56 -0800 Subject: [PATCH 02/11] proof(moq-net): the route rule's shared algebra is an increasing path algebra Co-Authored-By: Claude Opus 5.5 --- flake.nix | 5 + nix/route-proof.nix | 54 +++ rs/moq-net/verify/route-algebra/.gitignore | 1 + .../verify/route-algebra/Everything.agda | 4 + .../verify/route-algebra/Increasing.agda | 331 ++++++++++++++++++ rs/moq-net/verify/route-algebra/Order.agda | 121 +++++++ .../route-algebra/route-algebra.agda-lib | 4 + 7 files changed, 520 insertions(+) create mode 100644 nix/route-proof.nix create mode 100644 rs/moq-net/verify/route-algebra/.gitignore create mode 100644 rs/moq-net/verify/route-algebra/Everything.agda create mode 100644 rs/moq-net/verify/route-algebra/Increasing.agda create mode 100644 rs/moq-net/verify/route-algebra/Order.agda create mode 100644 rs/moq-net/verify/route-algebra/route-algebra.agda-lib diff --git a/flake.nix b/flake.nix index 16fe39cbb88..91cdd86e518 100644 --- a/flake.nix +++ b/flake.nix @@ -610,6 +610,11 @@ runner-userns-profile = import ./nix/runner/unshare.nix { inherit pkgs; }; + # Nightly `just test route-proof` type-checks the route rule's convergence + # proof. Its own Agda pin, so neither the dev shell nor `nix flake check` + # fetches it. + route-proof = import ./nix/route-proof.nix { inherit system; }; + # The QUIC Interop Runner's host tools (`just test quic-interop`): tshark # reads its pcaps, OpenSSL makes its certificates (the dev shell's LibreSSL # has no config for them), and Compose drives Podman where Docker's plugin is diff --git a/nix/route-proof.nix b/nix/route-proof.nix new file mode 100644 index 00000000000..389bdab4e16 --- /dev/null +++ b/nix/route-proof.nix @@ -0,0 +1,54 @@ +# The route rule's convergence proof (rs/moq-net/verify/route-algebra), type-checked +# against agda-routing at the Agda and standard library it was released for: +# Agda 2.6.4.3 and standard-library 2.0, which nixos-24.05 pins. The repository's +# nixpkgs has moved past both, so the proof keeps its own pin, fetched only when +# this attribute is evaluated. +{ system }: +let + pkgs = import (builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/b134951a4c9f3c995fd7be05f3243f8ecd65d798.tar.gz"; + sha256 = "0zydsqiaz8qi4zd63zsb2gij2p614cgkcaisnk11wjy3nmiq0x1s"; + }) { inherit system; }; + inherit (pkgs) agdaPackages; + + # Daggitt and Griffin's library, at the commit that moved it to Agda 2.6.4. + routing = agdaPackages.mkDerivation { + pname = "routing-library"; + version = "unstable-2023-12-27"; + src = pkgs.fetchFromGitHub { + owner = "MatthewDaggitt"; + repo = "agda-routing"; + rev = "241d45ae5c783f9ecdfa0be4030286d26c468f6d"; + sha256 = "1w7lm8sy5xji6ibbsxs8k65cbp9704kdv56wcrba53y61lgj782l"; + }; + buildInputs = [ agdaPackages.standard-library ]; + # No Everything file upstream: check the convergence results, which import + # every module the proof uses. + buildPhase = '' + runHook preBuild + agda RoutingLib/Routing/VectorBased/Convergence/Results.agda + runHook postBuild + ''; + meta = { }; + }; + + agda = agdaPackages.agda.withPackages [ + agdaPackages.standard-library + routing + ]; +in +pkgs.runCommand "route-proof" + { + src = ../rs/moq-net/verify/route-algebra; + nativeBuildInputs = [ agda ]; + LC_ALL = "C.UTF-8"; + # `nix shell .#route-proof.agda` gives the same Agda for editing the proof. + passthru = { inherit agda; }; + } + '' + cp -r $src proof + chmod -R u+w proof + cd proof + agda Everything.agda + touch $out + '' diff --git a/rs/moq-net/verify/route-algebra/.gitignore b/rs/moq-net/verify/route-algebra/.gitignore new file mode 100644 index 00000000000..69fa449dd96 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/.gitignore @@ -0,0 +1 @@ +_build/ diff --git a/rs/moq-net/verify/route-algebra/Everything.agda b/rs/moq-net/verify/route-algebra/Everything.agda new file mode 100644 index 00000000000..961bd52fdc0 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Everything.agda @@ -0,0 +1,4 @@ +module Everything where + +import Order +import Increasing diff --git a/rs/moq-net/verify/route-algebra/Increasing.agda b/rs/moq-net/verify/route-algebra/Increasing.agda new file mode 100644 index 00000000000..ec3cd46778c --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Increasing.agda @@ -0,0 +1,331 @@ +-------------------------------------------------------------------------------- +-- The algebra both levels of the route rule share, and the theorem it buys. +-- +-- A route is invalid or carries whether it is draining, a penalty (the lowest +-- priority on its path, counted down from the highest), a cost, its path, and +-- whatever else a level carries in `extra`. Routes rank by draining, then +-- penalty, then cost, then the shorter path, then a fixed order on paths, then +-- `extra`. Crossing a link (`extend`) refuses a route whose path does not start +-- at the link's far end or already names its near end, refuses whatever the +-- link's own filter refuses, and otherwise can only make the route draining, raise +-- its penalty, add to its cost, and prepend the link to its path. +-- +-- Any such algebra is an increasing path algebra, so Daggitt and Griffin's +-- Theorem 5 applies: on every network, from every state, under every schedule +-- of delayed, reordered, lost, and repeated messages, the asynchronous iteration +-- reaches the network's unique fixed point once the network holds still long +-- enough (`convergent`). +-------------------------------------------------------------------------------- + +open import Data.Bool.Base using (Bool; true; false; _∨_) +open import Data.List.Base using (List; []; _∷_) +open import Data.Nat.Base using (ℕ; zero; suc; _+_; _⊔_; z≤n; _^_) + +open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) + +open import Order + +module Increasing + -- What else a route carries, ordered, with the trivial route's value least. + {E : Set} (OE : Ordered E) (e₀ : E) (e₀-least : ∀ e → Ordered._≤_ OE e₀ e) + -- How paths of equal length order. + (OP : Ordered Path) + where + +import Algebra.Construct.NaturalChoice.Min as Min +import Data.Bool.Properties as Bool +import Data.Bool.Base as Boolᵇ +open import Data.Empty using (⊥-elim) +open import Data.Fin.Base using (toℕ) +import Data.Nat.Properties as ℕ +open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) +open import Data.Sum.Base using (_⊎_; inj₁; inj₂) +open import Level using (0ℓ) +open import Relation.Binary.Bundles using (TotalOrder) +open import Relation.Binary.Core using (Rel) +open import Relation.Binary.Definitions using (Decidable; Minimum; Maximum) +open import Relation.Binary.PropositionalEquality +open import Relation.Nullary.Decidable.Core using (yes; no; map′) +open import Relation.Nullary.Negation.Core using (¬_; contradiction) + +open import RoutingLib.Routing.Algebra +import RoutingLib.Routing.Basics.Path.UncertifiedI as PathI +open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (_⇿?_; _∈ₚ?_; p≉i∷p) +open import RoutingLib.Routing.VectorBased.Convergence.Results + +------------------------------------------------------------------------ +-- Routes + +record Valid : Set where + constructor route + field + draining : Bool + penalty : ℕ + cost : ℕ + path : Path + extra : E + +open Valid public + +data Weight : Set where + invalid : Weight + valid : Valid → Weight + +-- The route a node has to itself. +trivial : Weight +trivial = valid (route false 0 0 [] e₀) + +------------------------------------------------------------------------ +-- What crossing a link does + +record Policy : Set₁ where + field + Link : Set + -- The link that is down. + down : Link + -- What the link adds. + cost : Link → ℕ + penalty : Link → ℕ + drains : Link → Bool + -- Whether the receiver ranks the route draining, from the link (near end, + -- far end) and the path as offered. + marks : Link → Edge → Path → Bool + -- Whether the link refuses the route, from the link and the route as offered. + refuses : Link → Edge → Valid → Bool + down-refuses : ∀ e v → refuses down e v ≡ true + -- How the link changes the rest. + tag : Link → E → E + +module Rule (P : Policy) where + + open Policy P using (Link; down; refuses; down-refuses; tag; marks; drains) + private + module P = Policy P + + -- The route as it stands across the link from i to j, j being the neighbour + -- that offered it. + extend : Link → Edge → Weight → Weight + extend f e invalid = invalid + extend f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v + ... | no _ | _ | _ = invalid + ... | yes _ | yes _ | _ = invalid + ... | yes _ | no _ | true = invalid + ... | yes _ | no _ | false = valid (route + (draining v ∨ drains f ∨ marks f (i , j) (path v)) + (P.penalty f ⊔ penalty v) + (P.cost f + cost v) + ((i , j) ∷ path v) + (tag f (extra v))) + + ------------------------------------------------------------------------ + -- The order + + private + key : Valid → Bool × ℕ × ℕ × Path × E + key v = draining v , penalty v , cost v , path v , extra v + + O₄ = lex (shortlex OP) OE + O₃ = lex nat O₄ + O₂ = lex nat O₃ + + OK : Ordered (Bool × ℕ × ℕ × Path × E) + OK = lex bool O₂ + + OV : Ordered Valid + OV = keyed key (λ eq → cong (λ (d , q , c , p , x) → route d q c p x) eq) OK + + private + module OV = Ordered OV + + infix 4 _≤ᵣ_ + + data _≤ᵣ_ : Rel Weight 0ℓ where + below-invalid : ∀ {r} → r ≤ᵣ invalid + below : ∀ {v w} → v OV.≤ w → valid v ≤ᵣ valid w + + ≤ᵣ-total : ∀ r s → r ≤ᵣ s ⊎ s ≤ᵣ r + ≤ᵣ-total r invalid = inj₁ below-invalid + ≤ᵣ-total invalid (valid w) = inj₂ below-invalid + ≤ᵣ-total (valid v) (valid w) with OV.total v w + ... | inj₁ v≤w = inj₁ (below v≤w) + ... | inj₂ w≤v = inj₂ (below w≤v) + + ≤ᵣ-refl : ∀ {r} → r ≤ᵣ r + ≤ᵣ-refl {invalid} = below-invalid + ≤ᵣ-refl {valid v} = below OV.refl + + ≤ᵣ-trans : ∀ {r s t} → r ≤ᵣ s → s ≤ᵣ t → r ≤ᵣ t + ≤ᵣ-trans _ below-invalid = below-invalid + ≤ᵣ-trans (below v≤w) (below w≤x) = below (OV.trans v≤w w≤x) + + ≤ᵣ-antisym : ∀ {r s} → r ≤ᵣ s → s ≤ᵣ r → r ≡ s + ≤ᵣ-antisym below-invalid below-invalid = refl + ≤ᵣ-antisym (below v≤w) (below w≤v) = cong valid (OV.antisym v≤w w≤v) + + ≤ᵣ-totalOrder : TotalOrder 0ℓ 0ℓ 0ℓ + ≤ᵣ-totalOrder = record + { Carrier = Weight + ; _≈_ = _≡_ + ; _≤_ = _≤ᵣ_ + ; isTotalOrder = record + { isPartialOrder = record + { isPreorder = record + { isEquivalence = isEquivalence + ; reflexive = λ { refl → ≤ᵣ-refl } + ; trans = ≤ᵣ-trans + } + ; antisym = ≤ᵣ-antisym + } + ; total = ≤ᵣ-total + } + } + + -- A node keeps the lower of two routes. + open Min ≤ᵣ-totalOrder public using () renaming (_⊓_ to _⊕_) + private + module M = Min ≤ᵣ-totalOrder + + ------------------------------------------------------------------------ + -- Equality is decidable + + _≟ᵣ_ : Decidable {A = Weight} _≡_ + invalid ≟ᵣ invalid = yes refl + invalid ≟ᵣ valid _ = no λ () + valid _ ≟ᵣ invalid = no λ () + valid v ≟ᵣ valid w = map′ (cong valid) (λ { refl → refl }) (v OV.≟ w) + + ------------------------------------------------------------------------ + -- The trivial route is the least, the invalid one the greatest + + private + ≤-∨ : ∀ a b → a Boolᵇ.≤ (a ∨ b) + ≤-∨ false b = Bool.≤-minimum b + ≤-∨ true b = Bool.≤-reflexive refl + + []-least : ∀ p → Ordered._≤_ (shortlex OP) [] p + []-least [] = Ordered.refl (shortlex OP) + []-least (e ∷ p) = inj₁ (z≤n , λ ()) + + trivial-least : Minimum _≤ᵣ_ trivial + trivial-least invalid = below-invalid + trivial-least (valid w) = below + (lex-≤ bool O₂ (Bool.≤-minimum (draining w)) λ _ → + lex-≤ nat O₃ z≤n λ _ → + lex-≤ nat O₄ z≤n λ _ → + lex-≤ (shortlex OP) OE ([]-least (path w)) λ _ → + e₀-least (extra w)) + + invalid-greatest : Maximum _≤ᵣ_ invalid + invalid-greatest _ = below-invalid + + ------------------------------------------------------------------------ + -- Crossing a link never improves a route + + extend-increasing : ∀ f e r → r ≤ᵣ extend f e r + extend-increasing f e invalid = below-invalid + extend-increasing f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v + ... | no _ | _ | _ = below-invalid + ... | yes _ | yes _ | _ = below-invalid + ... | yes _ | no _ | true = below-invalid + ... | yes _ | no _ | false = below + (lex-≤ bool O₂ (≤-∨ (draining v) _) λ _ → + lex-≤ nat O₃ (ℕ.m≤n⊔m (P.penalty f) (penalty v)) λ _ → + lex-≤ nat O₄ (ℕ.m≤n+m (cost v) (P.cost f)) λ _ → + lex-≤ (shortlex OP) OE (shortlex-∷ OP (i , j) (path v)) λ eq → + contradiction eq p≉i∷p) + + ------------------------------------------------------------------------ + -- The routing algebra + + algebra : RawRoutingAlgebra 0ℓ 0ℓ 0ℓ + algebra = record + { PathWeight = Weight + ; Step = λ _ _ → Link + ; _≈_ = _≡_ + ; _⊕_ = _⊕_ + ; _▷_ = λ {_} {i} {j} f r → extend f (toℕ i , toℕ j) r + ; 0# = trivial + ; ∞# = invalid + ; f∞ = λ _ _ → down + ; ≈-isDecEquivalence = record { isEquivalence = isEquivalence ; _≟_ = _≟ᵣ_ } + ; ⊕-cong = cong₂ _⊕_ + ; ▷-cong = λ _ → cong _ + ; f∞-reject = λ i j → down-rejects (toℕ i , toℕ j) + } + where + down-rejects : ∀ e r → extend down e r ≡ invalid + down-rejects e invalid = refl + down-rejects (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses down (i , j) v | down-refuses (i , j) v + ... | no _ | _ | _ | _ = refl + ... | yes _ | yes _ | _ | _ = refl + ... | yes _ | no _ | true | _ = refl + ... | yes _ | no _ | false | () + + isRoutingAlgebra : IsRoutingAlgebra algebra + isRoutingAlgebra = record + { ⊕-sel = M.⊓-sel + ; ⊕-comm = M.⊓-comm + ; ⊕-assoc = M.⊓-assoc + ; ⊕-zeroʳ = M.⊓-zeroʳ trivial-least + ; ⊕-identityʳ = M.⊓-identityʳ invalid-greatest + ; ▷-fixedPoint = λ _ → refl + } + + isIncreasing : IsIncreasing algebra + isIncreasing {i = i} {j} f r = sym (M.x≤y⇒y⊓x≈x (extend-increasing f (toℕ i , toℕ j) r)) + + ------------------------------------------------------------------------ + -- The path algebra + + pathOf : Weight → PathI.Path + pathOf invalid = PathI.invalid + pathOf (valid v) = PathI.valid (path v) + + private + valid-injective : ∀ {p q : Path} → PathI.valid p ≡ PathI.valid q → p ≡ q + valid-injective refl = refl + + path-reject : ∀ (i j : ℕ) f {r p} → pathOf r ≡ PathI.valid p → + (¬ (i , j) PathI.⇿ᵥ p) ⊎ i PathI.∈ᵥₚ p → extend f (i , j) r ≡ invalid + path-reject i j f {invalid} () _ + path-reject i j f {valid v} eq bad with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v + ... | no _ | _ | _ = refl + ... | yes _ | yes _ | _ = refl + ... | yes _ | no _ | true = refl + ... | yes ij⇿ | no i∉ | false with valid-injective eq | bad + ... | refl | inj₁ ¬ij⇿ = contradiction ij⇿ ¬ij⇿ + ... | refl | inj₂ i∈ = contradiction i∈ i∉ + + path-accept : ∀ (i j : ℕ) f {r p} → pathOf r ≡ PathI.valid p → + extend f (i , j) r ≢ invalid → pathOf (extend f (i , j) r) ≡ PathI.valid ((i , j) ∷ p) + path-accept i j f {invalid} () _ + path-accept i j f {valid v} eq ok with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v + ... | no _ | _ | _ = contradiction refl ok + ... | yes _ | yes _ | _ = contradiction refl ok + ... | yes _ | no _ | true = contradiction refl ok + ... | yes _ | no _ | false with valid-injective eq + ... | refl = refl + + isPathAlgebra : IsPathAlgebra algebra + isPathAlgebra = record + { path = pathOf + ; path-cong = cong pathOf + ; r≈0⇒path[r]≈[] = λ { refl → refl } + ; r≈∞⇒path[r]≈∅ = λ { refl → refl } + ; path[r]≈∅⇒r≈∞ = λ { {invalid} _ → refl ; {valid _} () } + ; path-reject = λ {_} {i} {j} f → path-reject (toℕ i) (toℕ j) f + ; path-accept = λ {_} {i} {j} f → path-accept (toℕ i) (toℕ j) f + } + + ------------------------------------------------------------------------ + -- The theorem + + -- Daggitt and Griffin, Theorem 5: on every network, from every state, under + -- every schedule, the asynchronous iteration reaches the unique fixed point of + -- each epoch that lasts long enough. + convergent : Convergent algebra + convergent = incrPaths⇒convergent isRoutingAlgebra isPathAlgebra isIncreasing + + -- And the synchronous iteration settles within n² rounds on n nodes. + converges-n² : SynchronouslyConvergesIn algebra (λ n → n ^ 2) + converges-n² = incrPaths⇒syncConvergesIn-n² isRoutingAlgebra isPathAlgebra isIncreasing diff --git a/rs/moq-net/verify/route-algebra/Order.agda b/rs/moq-net/verify/route-algebra/Order.agda new file mode 100644 index 00000000000..c6c3ce5d8a5 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Order.agda @@ -0,0 +1,121 @@ +-------------------------------------------------------------------------------- +-- Decidable total orders whose equality is _≡_, and the two ways the route +-- algebra builds one from smaller ones: lexicographically, and through an +-- injective key. +-------------------------------------------------------------------------------- + +module Order where + +import Data.Bool.Base as Boolᵇ +open Boolᵇ using (Bool) +import Data.Bool.Properties as Bool +open import Data.List.Base using (List; _∷_; length) +import Data.List.Relation.Binary.Lex.NonStrict as ListLex +open import Data.List.Relation.Binary.Pointwise using (Pointwise-≡⇒≡; ≡⇒Pointwise-≡) +import Data.Nat.Base as ℕᵇ +open ℕᵇ using (ℕ) +import Data.Nat.Properties as ℕ +open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) +import Data.Product.Relation.Binary.Lex.NonStrict as ProductLex +open import Data.Product.Relation.Binary.Pointwise.NonDependent using (≡×≡⇒≡; ≡⇒≡×≡) +open import Data.Sum.Base using (inj₁; inj₂) +open import Level using (0ℓ) +open import Relation.Binary.Core using (Rel; _⇒_) +open import Relation.Binary.Definitions using (Decidable) +open import Relation.Binary.PropositionalEquality.Core using (_≡_; _≢_; refl; cong) +import Relation.Binary.PropositionalEquality.Properties as ≡ +open import Relation.Binary.Structures using (IsDecTotalOrder) +open import Relation.Nullary.Decidable.Core using (yes; no; map′) + +-- A decidable total order on A whose equality is _≡_. +record Ordered (A : Set) : Set₁ where + field + _≤_ : Rel A 0ℓ + isDecTotalOrder : IsDecTotalOrder _≡_ _≤_ + + open IsDecTotalOrder isDecTotalOrder public + +-- An order whose equality is pointwise _≡_ is an order over _≡_. +via≡ : ∀ {A : Set} {_≈_ _≤_ : Rel A 0ℓ} → + _≈_ ⇒ _≡_ → _≡_ ⇒ _≈_ → IsDecTotalOrder _≈_ _≤_ → Ordered A +via≡ {_≈_ = _≈_} {_≤_} to from o = record + { _≤_ = _≤_ + ; isDecTotalOrder = record + { isTotalOrder = record + { isPartialOrder = record + { isPreorder = record + { isEquivalence = ≡.isEquivalence + ; reflexive = λ eq → O.reflexive (from eq) + ; trans = O.trans + } + ; antisym = λ x≤y y≤x → to (O.antisym x≤y y≤x) + } + ; total = O.total + } + ; _≟_ = λ x y → map′ to from (x O.≟ y) + ; _≤?_ = O._≤?_ + } + } + where module O = IsDecTotalOrder o + +bool : Ordered Bool +bool = record { _≤_ = Boolᵇ._≤_ ; isDecTotalOrder = Bool.≤-isDecTotalOrder } + +nat : Ordered ℕ +nat = record { _≤_ = ℕᵇ._≤_ ; isDecTotalOrder = ℕ.≤-isDecTotalOrder } + +-- Compare the first components, and the second only between equal firsts. +lex : ∀ {A B : Set} → Ordered A → Ordered B → Ordered (A × B) +lex OA OB = via≡ ≡×≡⇒≡ ≡⇒≡×≡ (ProductLex.×-isDecTotalOrder OA.isDecTotalOrder OB.isDecTotalOrder) + where module OA = Ordered OA; module OB = Ordered OB + +-- Lexicographic, a prefix first. +list : ∀ {A : Set} → Ordered A → Ordered (List A) +list OA = via≡ Pointwise-≡⇒≡ ≡⇒Pointwise-≡ (ListLex.≤-isDecTotalOrder OA.isDecTotalOrder) + where module OA = Ordered OA + +-- Order A by an injective key into B. +keyed : ∀ {A B : Set} (f : A → B) → (∀ {x y} → f x ≡ f y → x ≡ y) → Ordered B → Ordered A +keyed f inj OB = record + { _≤_ = λ x y → f x OB.≤ f y + ; isDecTotalOrder = record + { isTotalOrder = record + { isPartialOrder = record + { isPreorder = record + { isEquivalence = ≡.isEquivalence + ; reflexive = λ { refl → OB.refl } + ; trans = OB.trans + } + ; antisym = λ x≤y y≤x → inj (OB.antisym x≤y y≤x) + } + ; total = λ x y → OB.total (f x) (f y) + } + ; _≟_ = λ x y → map′ inj (cong f) (f x OB.≟ f y) + ; _≤?_ = λ x y → f x OB.≤? f y + } + } + where module OB = Ordered OB + +-- Shorter lists first, then by the given order: a list is always below +-- itself with one more element in front. +shortlex : ∀ {A : Set} → Ordered (List A) → Ordered (List A) +shortlex OL = keyed (λ xs → length xs , xs) (λ eq → cong proj₂ eq) (lex nat OL) + +------------------------------------------------------------------------ +-- Building a lexicographic comparison one component at a time + +module _ {A B : Set} (OA : Ordered A) (OB : Ordered B) where + private + module OA = Ordered OA + module OB = Ordered OB + module OL = Ordered (lex OA OB) + + -- First components in order, and the second ones too when the first are equal. + lex-≤ : ∀ {a a' b b'} → a OA.≤ a' → (a ≡ a' → b OB.≤ b') → (a , b) OL.≤ (a' , b') + lex-≤ {a} {a'} a≤a' k with a OA.≟ a' + ... | yes eq = inj₂ (eq , k eq) + ... | no ne = inj₁ (a≤a' , ne) + +-- A list is below itself with one more element in front. +shortlex-∷ : ∀ {A : Set} (OL : Ordered (List A)) x xs → Ordered._≤_ (shortlex OL) xs (x ∷ xs) +shortlex-∷ OL x xs = inj₁ (ℕ.n≤1+n (length xs) , ℕ.<⇒≢ (ℕ.n<1+n (length xs))) diff --git a/rs/moq-net/verify/route-algebra/route-algebra.agda-lib b/rs/moq-net/verify/route-algebra/route-algebra.agda-lib new file mode 100644 index 00000000000..fce99676a5e --- /dev/null +++ b/rs/moq-net/verify/route-algebra/route-algebra.agda-lib @@ -0,0 +1,4 @@ +name: moq-route-algebra +depend: standard-library-2.0 routing-library +include: . +flags: --safe From c96394b651daa29ef39b04b6f98082242df63272 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 03:39:50 -0800 Subject: [PATCH 03/11] proof(moq-net): the route and claim instances, bound to the prototype by a property test and Agda vectors Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/route/tests/algebra.rs | 502 ++++++ rs/moq-net/src/route/tests/mod.rs | 1 + rs/moq-net/src/route/tests/multi.rs | 205 ++- rs/moq-net/verify/route-algebra/Claim.agda | 61 + .../verify/route-algebra/Everything.agda | 4 + rs/moq-net/verify/route-algebra/Route.agda | 146 ++ rs/moq-net/verify/route-algebra/Sim.agda | 20 + rs/moq-net/verify/route-algebra/Vectors.agda | 1421 +++++++++++++++++ 8 files changed, 2280 insertions(+), 80 deletions(-) create mode 100644 rs/moq-net/src/route/tests/algebra.rs create mode 100644 rs/moq-net/verify/route-algebra/Claim.agda create mode 100644 rs/moq-net/verify/route-algebra/Route.agda create mode 100644 rs/moq-net/verify/route-algebra/Sim.agda create mode 100644 rs/moq-net/verify/route-algebra/Vectors.agda diff --git a/rs/moq-net/src/route/tests/algebra.rs b/rs/moq-net/src/route/tests/algebra.rs new file mode 100644 index 00000000000..b8f6d9bca44 --- /dev/null +++ b/rs/moq-net/src/route/tests/algebra.rs @@ -0,0 +1,502 @@ +//! Binds the route proof (`rs/moq-net/verify/route-algebra`) to the prototype rule. +//! +//! The proof states the multicast rule as an increasing path algebra and applies +//! Daggitt and Griffin's convergence theorem to it. A route there is what a node +//! would offer: [`Offer::own`], or its best route as [`Offer::onward`] sends it. One +//! step of the algebra is that offer crossing [`Here::arrive`] at a neighbour, and +//! [`order`] picks between the results. Those are the functions the router calls. +//! These tests check them against the algebra's axioms on random links and routes, +//! and write a fixed sample of their results into `Vectors.agda`, each a `refl` +//! that the nightly Agda check must accept, so the two cannot drift apart unseen. + +use std::{ + cmp::Reverse, + collections::{BTreeMap, BTreeSet}, + fmt::Write as _, + path::PathBuf, +}; + +use super::compare::Arm; +use super::multi::{Best, Change, Claim, Here, Hop, Msg, Offer, Port, Role, Router, Tune, floor_of, order, started}; +use super::*; + +/// The rule the epic picked: floor, epoch, batch, drain, and claimed. +const KEPT: Tune = match Arm::KEPT { + Arm::Multi(tune) => tune, + Arm::Path(_) => panic!("the picked rule is the prototype's"), +}; + +/// The node receiving every route here: relay 0 at its first start. +const ME: Id = 1_000; + +/// The checked-in sample, which `ROUTE_VECTORS=write` regenerates. +fn vectors_path() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("verify/route-algebra/Vectors.agda") +} + +/// xorshift64, so a seed always draws the same cases. +struct Rng(u64); + +impl Rng { + fn below(&mut self, n: u64) -> u64 { + self.0 ^= self.0 << 13; + self.0 ^= self.0 >> 7; + self.0 ^= self.0 << 17; + self.0 % n + } + + /// True one time in `n`. + fn one_in(&mut self, n: u64) -> bool { + self.below(n) == 0 + } + + fn pick(&mut self, items: &[T]) -> T { + items[self.below(items.len() as u64) as usize] + } +} + +const PRIORITIES: [i8; 5] = [i8::MIN, -1, 0, 5, i8::MAX]; + +/// A node: relays 1 to `relays` at their first or second start, as `hop` names them. +fn node(rng: &mut Rng, relays: u64) -> Id { + 1_000 * (1 + rng.below(2)) + 1 + rng.below(relays) +} + +/// What a neighbour holds for one forwarding node. +#[derive(Clone, Debug)] +struct Held { + /// The neighbour. + node: Id, + /// Its session to its next hop. + session: u64, + /// Its best route, or `None` for its route to itself. + best: Option, + /// It announces a claim. + claimed: bool, +} + +impl Held { + /// What it sends the receiver over a link it marked `upstream`, as the router does. + fn sent(&self, upstream: bool) -> Option { + match &self.best { + None => Offer::own(self.node, KEPT, self.claimed), + Some(best) => best.onward(self.node, self.session, ME, upstream), + } + } +} + +/// The receiver's side of the link to one neighbour. +#[derive(Clone, Debug)] +struct Link { + port: Port, + /// The neighbour sent GOAWAY. + draining: bool, + /// The neighbour marked the link. + marked_there: bool, + /// The receiver's session on the link. + session: u64, +} + +/// What the receiver holds. +#[derive(Clone, Debug, Default)] +struct State { + closed: BTreeMap<(Id, Id), (u64, u64)>, + dead: BTreeMap, + suspects: BTreeMap>, + draining: BTreeSet, +} + +impl State { + fn here(&self) -> Here<'_> { + Here { + me: ME, + tune: KEPT, + closed: &self.closed, + dead: &self.dead, + suspects: &self.suspects, + draining: &self.draining, + } + } +} + +fn held(rng: &mut Rng, neighbour: Id) -> Held { + let best = (!rng.one_in(4)).then(|| { + // Now and then long enough to reach the hop limit, without the receiver on + // it so that nothing else refuses it. + let (relays, len, looped) = match rng.one_in(20) { + true => (40, MAX_HOPS as u64 - 3 + rng.below(4), 0), + false => (6, 1 + rng.below(4), 10), + }; + let mut path: Vec = Vec::new(); + while (path.len() as u64) < len { + let id = match looped > 0 && rng.one_in(looped) { + true => ME, + false => node(rng, relays), + }; + if id != neighbour && path.iter().all(|hop| started(hop.node).0 != started(id).0) { + let session = if path.is_empty() { 0 } else { 1 + rng.below(3) }; + path.push(Hop { node: id, session }); + } + } + Offer { + path, + draining: rng.one_in(4), + priority: rng.pick(&PRIORITIES), + cost: rng.below(12), + marked: rng.one_in(3), + } + }); + Held { + node: neighbour, + session: 1 + rng.below(3), + best, + claimed: !rng.one_in(4), + } +} + +fn link(rng: &mut Rng) -> Link { + Link { + port: Port { + cost: 1 + rng.below(4), + priority: rng.pick(&PRIORITIES), + upstream: rng.one_in(3), + role: Role::Routing, + }, + draining: rng.one_in(4), + marked_there: rng.one_in(3), + session: 1 + rng.below(3), + } +} + +fn state(rng: &mut Rng) -> State { + let mut state = State::default(); + for _ in 0..rng.below(4) { + let pair = (rng.below(7), rng.below(7)); + state.closed.insert(pair, (1 + rng.below(2), rng.below(4))); + } + for _ in 0..rng.below(3) { + state.draining.insert(node(rng, 6)); + } + state +} + +/// One step of the algebra as the router takes it: the offer as the receiver would +/// send it on, or `None` where it is refused. +fn cross(state: &State, link: &Link, held: &Held) -> Option { + let sent = held.sent(link.marked_there)?; + let (mut offer, suspect) = state.here().arrive(&link.port, link.draining, &sent)?; + assert!(!suspect, "the picked rule suspects no one"); + offer.path.push(Hop { + node: ME, + session: link.session, + }); + Some(offer) +} + +/// The neighbour's key, as the simulation's routers name their peers. +fn via(node: Id) -> Node { + started(node).0 as Node +} + +/// The candidate the router picks, with no next hop in use. +fn pick(candidates: &[(Id, Option)]) -> Option { + (candidates.iter()) + .filter_map(|(node, offer)| { + let best = Best { + via: via(*node), + offer: offer.clone()?, + suspect: false, + }; + Some((order(&best, None), best.offer)) + }) + .min_by(|(a, _), (b, _)| a.cmp(b)) + .map(|(_, offer)| offer) +} + +#[test] +fn a_step_never_improves_a_route() { + let mut rng = Rng(0x9e37_79b9_7f4a_7c15); + let mut refused = 0; + for _ in 0..20_000 { + let state = state(&mut rng); + let neighbour = node(&mut rng, 6); + let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); + let Some(sent) = held.sent(link.marked_there) else { + refused += 1; + continue; + }; + let Some(out) = cross(&state, &link, &held) else { + refused += 1; + continue; + }; + // A path naming its receiver is refused, and one taken grows by exactly the + // hop it crossed. + assert!(!sent.path.iter().any(|hop| hop.node == ME), "{sent:?}"); + assert_eq!(out.path[..sent.path.len()], sent.path[..]); + assert_eq!(out.path.len(), sent.path.len() + 1); + // Drain and priority never improve, and the cost strictly rises. + assert!(out.draining >= sent.draining && out.priority <= sent.priority); + assert!(out.cost > sent.cost); + assert!((out.draining, Reverse(out.priority), out.cost) > (sent.draining, Reverse(sent.priority), sent.cost)); + assert!(out.marked >= sent.marked); + } + assert!((2_000..18_000).contains(&refused), "{refused} of 20000 refused"); +} + +/// With `floor`, the dead hops a node keeps refuse nothing the floor does not, since +/// `closed` files every one of them in the floor too. +#[test] +fn the_floor_refuses_every_dead_hop() { + let mut rng = Rng(0x2545_f491_4f6c_dd1d); + for _ in 0..20_000 { + let mut state = state(&mut rng); + let neighbour = node(&mut rng, 6); + let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); + let Some(sent) = held.sent(link.marked_there) else { + continue; + }; + // Name closed some session on the path, as a DEAD message would, and file it + // the way `closed` does. + let mut floored = state.clone(); + for pair in sent.path.windows(2).filter(|_| rng.one_in(2)) { + let (hop, far) = (pair[1], pair[0].node); + floored.dead.insert(hop, far); + let (key, at) = floor_of(KEPT, hop, far); + let highest = floored.closed.entry(key).or_default(); + *highest = (*highest).max(at); + } + state.closed = floored.closed.clone(); + let here = |state: &State| state.here().arrive(&link.port, link.draining, &sent); + assert_eq!(here(&floored), here(&state)); + } +} + +#[test] +fn candidates_order_totally() { + let mut rng = Rng(0x1405_7b7e_f767_814f); + for _ in 0..20_000 { + let state = state(&mut rng); + let (a, b) = (node(&mut rng, 6), node(&mut rng, 6)); + if via(a) == via(b) { + continue; + } + let one = cross(&state, &link(&mut rng), &held(&mut rng, a)); + let two = cross(&state, &link(&mut rng), &held(&mut rng, b)); + let (Some(one), Some(two)) = (one, two) else { + continue; + }; + let key = |node: Id, offer: &Offer| { + order( + &Best { + via: via(node), + offer: offer.clone(), + suspect: false, + }, + None, + ) + }; + assert_ne!(key(a, &one), key(b, &two)); + } +} + +/// Claims across a scoped grant take the same kind of step: the receiving node adds +/// the link's cost, takes the lower priority, keeps a drain, appends itself to the +/// chain, and refuses a claim whose chain names it. +#[test] +fn a_grant_never_improves_a_claim() { + let mut rng = Rng(0xd1b5_4a32_d192_ed03); + for _ in 0..2_000 { + let mut router: Router = Router::new(ME, KEPT); + let (from, to) = (1, 2); + let port = Port { + cost: 1 + rng.below(4), + priority: rng.pick(&PRIORITIES), + upstream: false, + role: Role::Scoped, + }; + router.connect(from, hop(from, 0), port); + router.connect(to, hop(to, 0), Port { cost: 1, ..port }); + router.drain(); + let mut chain: Vec = (0..rng.below(3)).map(|_| node(&mut rng, 6)).collect(); + if rng.one_in(4) { + chain.insert(rng.below(chain.len() as u64 + 1) as usize, ME); + } + let claim = Claim { + cost: rng.below(12), + priority: rng.pick(&PRIORITIES), + draining: rng.one_in(4), + chain, + }; + let broadcast: multi::Broadcast = (7, p("live")); + router.recv( + from, + Msg::Foreign { + changes: vec![(broadcast.clone(), Change::Live(claim.clone()))], + }, + ); + let sent: Vec = (router.drain().into_iter()) + .filter(|(peer, _)| *peer == to) + .flat_map(|(_, msg)| match msg { + Msg::Foreign { changes } => changes, + other => panic!("{other:?} to a scoped neighbour"), + }) + .filter_map(|(_, change)| match change { + Change::Live(claim) => Some(claim), + _ => None, + }) + .collect(); + if claim.chain.contains(&ME) { + assert!(sent.is_empty(), "{sent:?}"); + continue; + } + let [out] = &sent[..] else { + panic!("{sent:?}"); + }; + assert!(out.cost >= claim.cost + port.cost); + assert_eq!(out.priority, claim.priority.min(port.priority)); + assert_eq!(out.draining, claim.draining); + assert_eq!(out.chain[..claim.chain.len()], claim.chain[..]); + assert_eq!(out.chain[claim.chain.len()..], [ME]); + } +} + +/// The Agda term for `offer` as a node sends it: its path from that node to the one +/// it leads to, each link with the session its nearer end holds it on. +fn weight(offer: Option<&Offer>) -> String { + let Some(offer) = offer else { + return "invalid".into(); + }; + let hops = &offer.path; + let mut path = String::new(); + let mut sessions = String::new(); + for pair in hops.windows(2).rev() { + write!(path, "({} , {}) ∷ ", pair[1].node, pair[0].node).unwrap(); + write!(sessions, "{} ∷ ", pair[1].session).unwrap(); + } + format!( + "valid (route {} {} {} ({path}[]) ({} , {sessions}[]))", + offer.draining, + penalty(offer.priority), + offer.cost, + offer.marked + ) +} + +/// How far a priority sits below the highest. +fn penalty(priority: i8) -> i16 { + i16::from(i8::MAX) - i16::from(priority) +} + +fn agda_link(state: &State, link: &Link, held: &Held) -> String { + let mut floors = String::new(); + for ((near, far), (start, session)) in &state.closed { + write!(floors, "floor {near} {far} {start} {session} ∷ ").unwrap(); + } + let mut draining = String::new(); + for node in &state.draining { + write!(draining, "{node} ∷ ").unwrap(); + } + format!( + "link true {} {} {} ({draining}[]) ({floors}[]) {} {} {} {}", + link.port.cost, + penalty(link.port.priority), + link.draining, + link.port.upstream, + link.marked_there, + held.claimed, + link.session, + ) +} + +fn agda_step(state: &State, link: &Link, held: &Held) -> String { + // The neighbour's route as the algebra holds it: before its own mark filter, + // which the link applies. + let route = match &held.best { + None => Some(Offer::own(held.node, KEPT, true).expect("own route")), + Some(best) => { + let mut offer = best.clone(); + offer.path.push(Hop { + node: held.node, + session: held.session, + }); + Some(offer) + } + }; + format!( + "extend ({}) ({ME} , {}) ({})", + agda_link(state, link, held), + held.node, + weight(route.as_ref()) + ) +} + +/// The sample: single steps, then picks between two neighbours' offers. +fn vectors() -> String { + let mut out = String::from( + "-- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit.\n\ + -- Each case is a result the Rust prototype computed, which the algebra must compute too.\n\n\ + module Vectors where\n\n\ + open import Data.Bool.Base using (true; false)\n\ + open import Data.List.Base using ([]; _∷_)\n\ + open import Data.Product.Base using (_,_)\n\ + open import Relation.Binary.PropositionalEquality using (_≡_; refl)\n\n\ + open import Sim\n", + ); + let mut rng = Rng(0x0123_4567_89ab_cdef); + for _ in 0..200 { + let state = state(&mut rng); + let neighbour = node(&mut rng, 6); + let (held, link) = (held(&mut rng, neighbour), link(&mut rng)); + let result = cross(&state, &link, &held); + write!( + out, + "\n_ : {}\n ≡ {}\n_ = refl\n", + agda_step(&state, &link, &held), + weight(result.as_ref()) + ) + .unwrap(); + } + for _ in 0..150 { + let state = state(&mut rng); + let (a, b) = (node(&mut rng, 6), node(&mut rng, 6)); + if via(a) == via(b) { + continue; + } + let one = (held(&mut rng, a), link(&mut rng)); + // Half the pairs offer the same route over the same kind of link, so only the + // neighbour breaks the tie. + let two = match rng.one_in(2) { + true => (Held { node: b, ..one.0.clone() }, one.1.clone()), + false => (held(&mut rng, b), link(&mut rng)), + }; + let picked = pick(&[ + (a, cross(&state, &one.1, &one.0)), + (b, cross(&state, &two.1, &two.0)), + ]); + write!( + out, + "\n_ : {}\n ⊕ {}\n ≡ {}\n_ = refl\n", + agda_step(&state, &one.1, &one.0), + agda_step(&state, &two.1, &two.0), + weight(picked.as_ref()) + ) + .unwrap(); + } + out +} + +#[test] +fn the_agda_sample_is_current() { + let path = vectors_path(); + let now = vectors(); + if std::env::var("ROUTE_VECTORS").as_deref() == Ok("write") { + std::fs::write(&path, &now).unwrap(); + return; + } + let checked_in = std::fs::read_to_string(&path).unwrap(); + assert!( + checked_in == now, + "{} is stale: rerun this test with ROUTE_VECTORS=write, then `just test route-proof`", + path.display() + ); +} diff --git a/rs/moq-net/src/route/tests/mod.rs b/rs/moq-net/src/route/tests/mod.rs index 74a6b2326b3..24f8df5b806 100644 --- a/rs/moq-net/src/route/tests/mod.rs +++ b/rs/moq-net/src/route/tests/mod.rs @@ -8,6 +8,7 @@ //! means a wildcard; every lite-07 claim already covers the paths below it, so //! the slash is dropped. +mod algebra; mod bakeoff; mod cache; mod compare; diff --git a/rs/moq-net/src/route/tests/multi.rs b/rs/moq-net/src/route/tests/multi.rs index be57a98471b..cd297210609 100644 --- a/rs/moq-net/src/route/tests/multi.rs +++ b/rs/moq-net/src/route/tests/multi.rs @@ -79,7 +79,7 @@ pub(super) struct Tune { /// The relay a simulated node identity names and how many times it had started, /// as [`hop`] numbers them. A real identity would carry a start that only grows. -fn started(id: Id) -> (Id, u64) { +pub(super) fn started(id: Id) -> (Id, u64) { (id % 1_000, id / 1_000) } @@ -115,6 +115,98 @@ impl Offer { fn rank(&self) -> (bool, Reverse, Metric) { (self.draining, Reverse(self.priority), self.cost) } + + /// The route a node offers to itself, once it has a claim when `tune.claimed`. + pub fn own(me: Id, tune: Tune, announced: bool) -> Option { + if tune.claimed && !announced { + return None; + } + Some(Self { + path: vec![Hop { node: me, session: 0 }], + draining: false, + priority: i8::MAX, + cost: 0, + marked: false, + }) + } + + /// The route `me` holds over its session `session`, as it sends it to neighbour + /// `to` over a link it marked `upstream`: never to a node already on its path, + /// or from one marked link to another. + pub fn onward(&self, me: Id, session: u64, to: Id, upstream: bool) -> Option { + if self.names(to) || (self.marked && upstream) { + return None; + } + let mut offer = self.clone(); + offer.path.push(Hop { node: me, session }); + Some(offer) + } +} + +/// Everything a node holds that decides whether it takes a route and how it ranks it. +pub(super) struct Here<'a> { + pub me: Id, + pub tune: Tune, + pub closed: &'a BTreeMap<(Id, Id), (u64, u64)>, + pub dead: &'a BTreeMap, + pub suspects: &'a BTreeMap>, + pub draining: &'a BTreeSet, +} + +impl Here<'_> { + /// `offer`, heard from a neighbour on `port` that sent GOAWAY when `draining`, as + /// it stands here, and whether it crosses a suspected node; `None` when this node + /// refuses it. + pub fn arrive(&self, port: &Port, draining: bool, offer: &Offer) -> Option<(Offer, bool)> { + let floored = offer.path.windows(2).any(|pair| { + let (key, at) = floor_of(self.tune, pair[1], pair[0].node); + self.closed.get(&key).is_some_and(|highest| at <= *highest) + }); + if floored + || offer.names(self.me) + || offer.path.len() >= MAX_HOPS + || offer.path.iter().any(|hop| self.dead.contains_key(hop)) + { + return None; + } + let named = |nodes: &dyn Fn(&Id) -> bool| offer.path.iter().any(|hop| nodes(&hop.node)); + let suspect = named(&|node| self.suspects.contains_key(node)); + let flagged = suspect && self.tune.suspect == Suspect::Flagged; + let offer = Offer { + path: offer.path.clone(), + draining: offer.draining || draining || flagged || named(&|node| self.draining.contains(node)), + priority: offer.priority.min(port.priority), + cost: offer.cost + port.cost, + marked: offer.marked || port.upstream, + }; + Some((offer, suspect)) + } +} + +/// How a candidate route orders, lower first: rank, then the next hop in use +/// (`current`), the shorter path, and the neighbour. +pub(super) fn order(best: &Best, current: Option) -> Order { + let (draining, priority, cost) = best.rank(); + ( + draining, + priority, + cost, + current != Some(best.via), + best.offer.path.len(), + best.via, + ) +} + +/// The pair of nodes `hop`'s session joins, as the floor files it, and where the +/// session stands in that pair's order. +pub(super) fn floor_of(tune: Tune, hop: Hop, far: Id) -> ((Id, Id), (u64, u64)) { + match tune.epoch { + true => { + let ((near, start), (far, _)) = (started(hop.node), started(far)); + ((near, far), (start, hop.session)) + } + false => ((hop.node, far), (0, hop.session)), + } } /// A claim as a forwarding node announces it. @@ -201,15 +293,15 @@ struct Heard { /// The route this node uses, as it stands here: the heard offer with the link added. #[derive(Clone, Debug, PartialEq, Eq)] -struct Best { - via: N, - offer: Offer, +pub(super) struct Best { + pub via: N, + pub offer: Offer, /// It crosses a node this node suspects, which no offer says. - suspect: bool, + pub suspect: bool, } impl Best { - fn rank(&self) -> (bool, Reverse, Metric) { + pub fn rank(&self) -> (bool, Reverse, Metric) { let (draining, priority, cost) = self.offer.rank(); (draining || self.suspect, priority, cost) } @@ -236,7 +328,7 @@ impl Default for Known { /// How candidate routes order, lower first: rank, then the next hop in use, the /// shorter path, and the neighbour. -type Order = (bool, Reverse, Metric, bool, usize, N); +pub(super) type Order = (bool, Reverse, Metric, bool, usize, N); /// Where a request for a broadcast goes next. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -354,6 +446,18 @@ impl Router { router } + /// What this node holds that decides how it takes a route. + fn here(&self) -> Here<'_> { + Here { + me: self.me, + tune: self.tune, + closed: &self.closed, + dead: &self.dead, + suspects: &self.suspects, + draining: &self.draining, + } + } + /// What to send, with every route as it stands now. pub fn drain(&mut self) -> Vec<(N, Msg)> { self.advertise(); @@ -788,18 +892,6 @@ impl Router { self.publish(me, vec![(broadcast, change)]); } - /// The pair of nodes `hop`'s session joins, as the floor files it, and where the - /// session stands in that pair's order. - fn floor_of(&self, hop: Hop, far: Id) -> ((Id, Id), (u64, u64)) { - match self.tune.epoch { - true => { - let ((near, start), (far, _)) = (started(hop.node), started(far)); - ((near, far), (start, hop.session)) - } - false => ((hop.node, far), (0, hop.session)), - } - } - /// A session closed: this node's own when `from` is `None`. fn closed(&mut self, hop: Hop, far: Id, from: Option) { self.work += 1; @@ -810,7 +902,7 @@ impl Router { } } if self.tune.floor { - let (pair, at) = self.floor_of(hop, far); + let (pair, at) = floor_of(self.tune, hop, far); let highest = self.closed.entry(pair).or_default(); *highest = (*highest).max(at); } @@ -892,56 +984,26 @@ impl Router { fn reselect(&mut self, origin: Id) { let current = self.best.get(&origin).map(|best| best.via); let mut pick: Option<(Best, Order)> = None; + let here = self.here(); + let mut visited = 0; for (&via, heard) in self.heard.get(&origin).into_iter().flatten() { - self.work += 1; + visited += 1; let Some(peer) = self.peers.get(&via) else { continue; }; - let offer = &heard.offer; - let floored = offer.path.windows(2).any(|pair| { - let (key, at) = self.floor_of(pair[1], pair[0].node); - self.closed.get(&key).is_some_and(|highest| at <= *highest) - }); - if heard.ended || floored { - continue; - } - if offer.names(self.me) - || offer.path.len() >= MAX_HOPS - || offer.path.iter().any(|hop| self.dead.contains_key(hop)) - { + if heard.ended || (self.tune.agree && !self.agrees(origin, via, &heard.offer)) { continue; } - if self.tune.agree && !self.agrees(origin, via, offer) { + let Some((offer, suspect)) = here.arrive(&peer.port, peer.draining, &heard.offer) else { continue; - } - let named = |nodes: &dyn Fn(&Id) -> bool| offer.path.iter().any(|hop| nodes(&hop.node)); - let suspect = named(&|node| self.suspects.contains_key(node)); - let flagged = suspect && self.tune.suspect == Suspect::Flagged; - let mine = Best { - via, - offer: Offer { - path: offer.path.clone(), - draining: offer.draining || peer.draining || flagged || named(&|node| self.draining.contains(node)), - priority: offer.priority.min(peer.port.priority), - cost: offer.cost + peer.port.cost, - marked: offer.marked || peer.port.upstream, - }, - suspect, }; - let (draining, priority, cost) = mine.rank(); - // Among equal ranks a node stays on its next hop. - let key = ( - draining, - priority, - cost, - current != Some(via), - mine.offer.path.len(), - via, - ); + let mine = Best { via, offer, suspect }; + let key = order(&mine, current); if pick.as_ref().is_none_or(|(_, best)| key < *best) { pick = Some((mine, key)); } } + self.work += visited; let pick = pick.map(|(best, _)| best); if self.best.get(&origin) == pick.as_ref() { return; @@ -984,32 +1046,15 @@ impl Router { fn offer_for(&self, origin: Id, peer: N) -> Option { let to = self.peers.get(&peer).filter(|to| to.port.role == Role::Routing)?; if origin == self.me { - if self.tune.claimed && !self.announced { - return None; - } - return Some(Offer { - path: vec![Hop { - node: self.me, - session: 0, - }], - draining: false, - priority: i8::MAX, - cost: 0, - marked: false, - }); + return Offer::own(self.me, self.tune, self.announced); } let best = self.best.get(&origin)?; - // Never back over the session it came on, to a node already on its path, or - // from one marked link to another. - if best.via == peer || best.offer.names(to.id) || (best.offer.marked && to.port.upstream) { + // Never back over the session it came on: its sender is the last hop on its + // path, so `onward` refuses it too. + if best.via == peer { return None; } - let mut offer = best.offer.clone(); - offer.path.push(Hop { - node: self.me, - session: self.peers[&best.via].session, - }); - Some(offer) + best.offer.onward(self.me, self.peers[&best.via].session, to.id, to.port.upstream) } fn advertise_to(&mut self, origin: Id, peer: N) { diff --git a/rs/moq-net/verify/route-algebra/Claim.agda b/rs/moq-net/verify/route-algebra/Claim.agda new file mode 100644 index 00000000000..7e2e4f892a4 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Claim.agda @@ -0,0 +1,61 @@ +-------------------------------------------------------------------------------- +-- Claims across trust boundaries: the same algebra at the grain of the nodes +-- that hand a claim on. +-- +-- A claim's route is its draining, penalty, and cost from the publisher, and the +-- path of nodes that handed it on. A link here is a step a claim takes: from an +-- endpoint to the relay announcing it, from a node to the claim of an announcer +-- in its routing domain over the node's settled route there, or across a scoped +-- grant. Each step only adds: it may make the claim draining, raise its penalty, +-- add cost, and prepends the node that took it, which refuses a claim that names +-- it already. How Rust's claims map onto this, and where Rust's chain names fewer +-- nodes than this path, is in `rs/moq-net/verify/README.md`. +-------------------------------------------------------------------------------- + +module Claim where + +open import Data.Bool.Base using (Bool; true; false; not) +open import Data.Nat.Base using (ℕ) +open import Data.Unit.Base using (⊤; tt) +import Data.Unit.Properties as Unit +open import Relation.Binary.PropositionalEquality using (_≡_; refl) + +open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (≤ₗₑₓ-isDecTotalOrder) + +open import Order + +private + OE : Ordered ⊤ + OE = record { _≤_ = _≡_ ; isDecTotalOrder = Unit.≡-isDecTotalOrder } + + -- Among equal ranks and lengths, by the nodes on the path, nearest first. + OP = record { _≤_ = _ ; isDecTotalOrder = ≤ₗₑₓ-isDecTotalOrder } + +open import Increasing OE tt (λ _ → refl) OP public + +-- One step a claim can take. +record Step : Set where + constructor step + field + up : Bool + cost : ℕ + penalty : ℕ + drains : Bool + +private + module S = Step + +policy : Policy +policy = record + { Link = Step + ; down = step false 0 0 false + ; cost = S.cost + ; penalty = S.penalty + ; drains = S.drains + ; marks = λ _ _ _ → false + ; refuses = λ f _ _ → not (S.up f) + ; down-refuses = λ _ _ → refl + ; tag = λ _ _ → tt + } + +open Rule policy public diff --git a/rs/moq-net/verify/route-algebra/Everything.agda b/rs/moq-net/verify/route-algebra/Everything.agda index 961bd52fdc0..54f56c7e729 100644 --- a/rs/moq-net/verify/route-algebra/Everything.agda +++ b/rs/moq-net/verify/route-algebra/Everything.agda @@ -2,3 +2,7 @@ module Everything where import Order import Increasing +import Route +import Claim +import Sim +import Vectors diff --git a/rs/moq-net/verify/route-algebra/Route.agda b/rs/moq-net/verify/route-algebra/Route.agda new file mode 100644 index 00000000000..a57d2c2ff09 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Route.agda @@ -0,0 +1,146 @@ +-------------------------------------------------------------------------------- +-- Routes between forwarding nodes, as the multicast epic's rule ranks and +-- extends them (`rs/moq-net/src/route/tests/multi.rs`, every `Tune` the epic +-- picked on: floor, epoch, batch, drain, claimed). +-- +-- A node is one start of one relay: a restart is a new node, as a restarted +-- relay names itself afresh. `relay` and `start` read the two back from a node, +-- since the floor files a closed session by relays and orders it by start. +-- +-- A route at node i is what i would offer: its path names i first, then i's next +-- hop, and so on to the forwarding node it leads to. `extra` carries whether a +-- marked link is on the path and, beside each link, the session the nearer node +-- holds it on. The link from i to j carries what i and j hold about it and what i +-- knows: closed sessions (floors) and nodes named draining. +-------------------------------------------------------------------------------- + +open import Data.Bool.Base using (Bool; true; false; _∨_; _∧_; not; if_then_else_) +open import Data.List.Base using (List; []; _∷_; map; any; zip; null; length) +open import Data.Nat.Base using (ℕ; suc; _≡ᵇ_; _<ᵇ_; _≤ᵇ_) +open import Data.Product.Base using (_×_; _,_; proj₁; proj₂) +open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong) + +open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) + +open import Order + +module Route + (relay start : ℕ → ℕ) + (relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n) + where + +import Data.Bool.Properties as Bool +open import Data.List.Properties using (map-injective) +open import Data.List.Relation.Binary.Lex.Core using (base; halt) +open import Data.Product.Properties using (,-injectiveˡ; ,-injectiveʳ) + +-- The longest path a node takes, counting the node it leads to (`MAX_HOPS`). +max-hops : ℕ +max-hops = 32 + +------------------------------------------------------------------------ +-- What a route carries beyond its rank and path + +-- A marked link is on the path, and the session beside each link. +Extra : Set +Extra = Bool × List ℕ + +OE : Ordered Extra +OE = lex bool (list nat) + +e₀ : Extra +e₀ = false , [] + +e₀-least : ∀ e → Ordered._≤_ OE e₀ e +e₀-least (m , ss) = lex-≤ bool (list nat) (Bool.≤-minimum m) λ _ → least ss + where + least : ∀ ss → Ordered._≤_ (list nat) [] ss + least [] = base _ + least (_ ∷ _) = halt + +-- Among equal ranks and lengths, by the neighbour: its relay, then its start. +-- No two candidates at one node share a neighbour, so the rest of the path +-- never decides between them. +OP : Ordered Path +OP = keyed (map neighbour) (map-injective neighbour-injective) (list (lex nat (lex nat nat))) + where + neighbour : Edge → ℕ × ℕ × ℕ + neighbour (a , b) = a , relay b , start b + + neighbour-injective : ∀ {x y} → neighbour x ≡ neighbour y → x ≡ y + neighbour-injective {a , b} {c , d} eq with ,-injectiveˡ eq + ... | refl = cong (a ,_) (relay-start-injective + (,-injectiveˡ (,-injectiveʳ eq)) (,-injectiveʳ (,-injectiveʳ eq))) + +open import Increasing OE e₀ e₀-least OP public + +------------------------------------------------------------------------ +-- The link + +-- The highest session known closed from relay `near` to relay `far`: the start +-- of near it was held by (`started`), and its number there. +record Floor : Set where + constructor floor + field + near far : ℕ + started session : ℕ + +-- The link from the receiver to the neighbour that offers it a route. +record Link : Set where + constructor link + field + up : Bool -- false for a link that is down + cost : ℕ -- the receiver's port cost, at least 1 in Rust + penalty : ℕ -- 127 minus the receiver's port priority + drains : Bool -- the neighbour sent GOAWAY + draining : List ℕ -- nodes the receiver knows draining + floors : List Floor -- the receiver's closed sessions + marked-here : Bool -- the receiver marked the link + marked-there : Bool -- the neighbour marked the link + claimed : Bool -- the neighbour announces a claim + session : ℕ -- the receiver's session number on the link + +private + module L = Link + + _∈ᵇ_ : ℕ → List ℕ → Bool + n ∈ᵇ ns = any (n ≡ᵇ_) ns + + -- Whether `floors` hold the session from `a` to `b` numbered `s` closed. + closed : List Floor → Edge × ℕ → Bool + closed fs ((a , b) , s) = any at-or-below fs + where + at-or-below : Floor → Bool + at-or-below (floor n f st se) = + (relay a ≡ᵇ n) ∧ (relay b ≡ᵇ f) ∧ ((start a <ᵇ st) ∨ ((start a ≡ᵇ st) ∧ (s ≤ᵇ se))) + +-- A link refuses a route when it is down, when the route is the neighbour's +-- route to itself and the neighbour announces no claim, when the route crossed a +-- marked link and this one is marked at the neighbour, when the path would grow +-- past `max-hops`, or when it names a session the receiver knows closed. +refuses : Link → Edge → Valid → Bool +refuses f _ v = + not (L.up f) + ∨ (null (path v) ∧ not (L.claimed f)) + ∨ (proj₁ (extra v) ∧ L.marked-there f) + ∨ (max-hops ≤ᵇ suc (length (path v))) + ∨ any (closed (L.floors f)) (zip (path v) (proj₂ (extra v))) + +-- The receiver ranks a route draining when it names a node known draining. +marks : Link → Edge → Path → Bool +marks f (_ , j) p = any (_∈ᵇ L.draining f) (j ∷ map proj₂ p) + +policy : Policy +policy = record + { Link = Link + ; down = link false 0 0 false [] [] false false false 0 + ; cost = L.cost + ; penalty = L.penalty + ; drains = L.drains + ; marks = marks + ; refuses = refuses + ; down-refuses = λ _ _ → refl + ; tag = λ f (m , ss) → (m ∨ L.marked-here f) , (L.session f ∷ ss) + } + +open Rule policy public diff --git a/rs/moq-net/verify/route-algebra/Sim.agda b/rs/moq-net/verify/route-algebra/Sim.agda new file mode 100644 index 00000000000..5514f5cc59f --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Sim.agda @@ -0,0 +1,20 @@ +-------------------------------------------------------------------------------- +-- The route rule as the Rust prototype runs it: a node is named +-- 1000 × start + relay, as `hop` in `rs/moq-net/src/route/tests/mod.rs` names it. +-------------------------------------------------------------------------------- + +module Sim where + +open import Data.Nat.Base using (ℕ; _%_; _/_; _+_; _*_) +open import Data.Nat.DivMod using (m≡m%n+[m/n]*n) +open import Relation.Binary.PropositionalEquality using (_≡_; cong₂; trans; sym) + +relay start : ℕ → ℕ +relay n = n % 1000 +start n = n / 1000 + +relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n +relay-start-injective {m} {n} r s = trans (m≡m%n+[m/n]*n m 1000) + (trans (cong₂ (λ a b → a + b * 1000) r s) (sym (m≡m%n+[m/n]*n n 1000))) + +open import Route relay start relay-start-injective public diff --git a/rs/moq-net/verify/route-algebra/Vectors.agda b/rs/moq-net/verify/route-algebra/Vectors.agda new file mode 100644 index 00000000000..356ba32218d --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Vectors.agda @@ -0,0 +1,1421 @@ +-- Generated by `rs/moq-net/src/route/tests/algebra.rs` (`ROUTE_VECTORS=write`); do not edit. +-- Each case is a result the Rust prototype computed, which the algebra must compute too. + +module Vectors where + +open import Data.Bool.Base using (true; false) +open import Data.List.Base using ([]; _∷_) +open import Data.Product.Base using (_,_) +open import Relation.Binary.PropositionalEquality using (_≡_; refl) + +open import Sim + +_ : extend (link true 2 0 false (1006 ∷ []) ([]) false false true 1) (1000 , 1003) (valid (route true 128 2 ((1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 128 4 ((1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 127 true (1002 ∷ []) (floor 0 2 1 2 ∷ floor 2 0 1 2 ∷ []) true false false 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 255 true (1001 ∷ []) ([]) true false true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 1 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 128 true (1005 ∷ []) (floor 5 5 1 1 ∷ []) false true false 2) (1000 , 1001) (valid (route true 0 10 ((1001 , 1004) ∷ (1004 , 1000) ∷ (1000 , 1002) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false (1004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 3 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1004 ∷ []) (floor 3 1 1 1 ∷ floor 6 1 1 3 ∷ floor 6 4 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 1 ((1000 , 1005) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (2002 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 10 ((1006 , 1000) ∷ (1000 , 1001) ∷ []) (false , 2 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 122 false (2001 ∷ 2005 ∷ []) ([]) false true true 2) (1000 , 2005) (valid (route true 122 6 ((2005 , 1004) ∷ (1004 , 1003) ∷ []) (false , 1 ∷ 3 ∷ []))) + ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 1004) ∷ (1004 , 1003) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (2006 ∷ []) (floor 0 1 1 1 ∷ []) false false false 3) (1000 , 1002) (valid (route true 128 10 ((1002 , 2004) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 128 11 ((1000 , 1002) ∷ (1002 , 2004) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1004 ∷ []) ([]) true false true 3) (1000 , 2001) (valid (route false 128 1 ((2001 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 255 true (1001 ∷ 1003 ∷ []) ([]) true true true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 3 ((1000 , 2002) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (1004 ∷ []) (floor 1 5 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 122 0 ((1004 , 1015) ∷ (1015 , 2021) ∷ (2021 , 1008) ∷ (1008 , 2037) ∷ (2037 , 2020) ∷ (2020 , 1040) ∷ (1040 , 1025) ∷ (1025 , 2028) ∷ (2028 , 1024) ∷ (1024 , 1013) ∷ (1013 , 2001) ∷ (2001 , 2010) ∷ (2010 , 2014) ∷ (2014 , 1032) ∷ (1032 , 1012) ∷ (1012 , 1038) ∷ (1038 , 1017) ∷ (1017 , 2007) ∷ (2007 , 2022) ∷ (2022 , 1034) ∷ (1034 , 2031) ∷ (2031 , 1009) ∷ (1009 , 1019) ∷ (1019 , 1026) ∷ (1026 , 1005) ∷ (1005 , 1027) ∷ (1027 , 1006) ∷ (1006 , 1036) ∷ (1036 , 1016) ∷ (1016 , 1002) ∷ (1002 , 1003) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 true (1006 ∷ []) ([]) false true false 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false (2002 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route false 0 11 ((1004 , 2005) ∷ (2005 , 1003) ∷ []) (false , 3 ∷ 2 ∷ []))) + ≡ valid (route false 122 14 ((1000 , 1004) ∷ (1004 , 2005) ∷ (2005 , 1003) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 122 true (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 127 3 ((2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (true , 3 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 127 7 ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false (1006 ∷ 2003 ∷ []) (floor 6 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 122 1 ((2002 , 2003) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 122 5 ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (true , 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 127 true (1005 ∷ 1006 ∷ []) (floor 3 1 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 3 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false ([]) (floor 5 6 1 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 3 ((1000 , 2003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false ([]) (floor 4 3 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 3 ∷ []) true true true 3) (1000 , 1003) (valid (route false 127 1 ((1003 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1004) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 true (1001 ∷ []) (floor 0 5 1 3 ∷ []) false false true 2) (1000 , 2003) (valid (route true 0 11 ((2003 , 1000) ∷ []) (false , 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 true (2001 ∷ []) (floor 1 2 1 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 122 4 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 true ([]) (floor 3 4 2 2 ∷ []) true false false 3) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route false 0 0 ((2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route true 0 2 ((1000 , 2004) ∷ (2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (2004 ∷ []) (floor 2 5 1 2 ∷ floor 4 1 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 3 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ floor 1 5 1 0 ∷ []) true true false 1) (1000 , 2001) (valid (route false 122 3 ((2001 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 0 false (1004 ∷ []) ([]) true false true 3) (1000 , 2006) (valid (route false 122 3 ((2006 , 1003) ∷ (1003 , 1000) ∷ []) (true , 3 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 128 true (2002 ∷ []) (floor 2 1 1 0 ∷ []) false true true 2) (1000 , 2005) (valid (route true 255 9 ((2005 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 5 2 1 1 ∷ []) true false true 1) (1000 , 1004) (valid (route false 255 10 ((1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 ((1000 , 1004) ∷ (1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false (1004 ∷ 2003 ∷ []) (floor 1 2 2 0 ∷ floor 3 6 2 3 ∷ []) true false true 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 0 4 ((1000 , 2003) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 0 4 2 2 ∷ floor 6 1 1 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 11 ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 255 false (1003 ∷ 1006 ∷ []) (floor 0 2 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 128 10 ((2005 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 255 false (2006 ∷ []) (floor 1 5 2 3 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 2 ((1000 , 2001) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 3 ((2001 , 2006) ∷ (2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1000) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false ([]) ([]) true false false 3) (1000 , 1005) (valid (route false 128 5 ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route false 128 6 ((1000 , 1005) ∷ (1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 2 1 3 ∷ []) false true true 2) (1000 , 2006) (valid (route false 0 9 ((2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 128 10 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (2006 ∷ []) (floor 0 5 2 3 ∷ floor 3 1 2 1 ∷ floor 6 5 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 1 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true ([]) ([]) false false false 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (1005 ∷ []) ([]) false false true 1) (1000 , 1002) (valid (route false 122 3 ((1002 , 2002) ∷ (2002 , 2001) ∷ []) (false , 1 ∷ 3 ∷ []))) + ≡ valid (route false 127 6 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false (1001 ∷ 1004 ∷ []) ([]) true false true 2) (1000 , 1002) (valid (route true 122 1 ((1002 , 1006) ∷ (1006 , 2002) ∷ []) (false , 3 ∷ 1 ∷ []))) + ≡ valid (route true 122 5 ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (1002 ∷ 2006 ∷ []) (floor 6 0 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 4 ((2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 122 5 ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (1002 ∷ 2004 ∷ []) (floor 5 6 2 3 ∷ floor 6 5 2 3 ∷ []) false false true 2) (1000 , 2004) (valid (route true 127 3 ((2004 , 2002) ∷ (2002 , 1005) ∷ (1005 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 2 1 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (1003 ∷ 2002 ∷ []) (floor 3 6 1 3 ∷ floor 5 1 2 3 ∷ floor 6 4 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 127 10 ((1005 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false (1005 ∷ []) (floor 0 0 2 1 ∷ floor 1 3 1 3 ∷ floor 4 1 1 2 ∷ []) false false false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 true (1001 ∷ []) (floor 1 3 1 2 ∷ floor 6 5 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 4 ((1000 , 1005) ∷ []) (true , 3 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false (1005 ∷ 1006 ∷ []) (floor 1 1 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 1) (1000 , 2003) (valid (route false 122 7 ((2003 , 1003) ∷ (1003 , 1001) ∷ []) (false , 2 ∷ 2 ∷ []))) + ≡ valid (route false 128 9 ((1000 , 2003) ∷ (2003 , 1003) ∷ (1003 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 255 false ([]) (floor 1 2 2 1 ∷ floor 6 1 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 2 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false ([]) (floor 3 5 2 0 ∷ floor 5 4 2 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 2 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false (1004 ∷ 1006 ∷ []) (floor 0 3 1 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 1 ((2004 , 2005) ∷ (2005 , 1001) ∷ []) (false , 1 ∷ 2 ∷ []))) + ≡ valid (route false 128 4 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false ([]) (floor 1 0 2 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 0 true (2004 ∷ []) ([]) false false false 2) (1000 , 1002) (valid (route false 122 1 ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route true 122 2 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false (2001 ∷ 2003 ∷ []) (floor 3 5 2 1 ∷ floor 4 2 2 0 ∷ floor 6 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 2 ((1000 , 2006) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false (2001 ∷ []) (floor 3 3 1 2 ∷ []) true false true 1) (1000 , 2006) (valid (route false 122 0 ((2006 , 2003) ∷ (2003 , 2004) ∷ []) (false , 2 ∷ 3 ∷ []))) + ≡ valid (route false 128 3 ((1000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2004) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1003 ∷ 2005 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ []) true false true 3) (1000 , 1003) (valid (route false 127 0 ((1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 128 4 ((1000 , 1003) ∷ (1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (true , 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (1003 ∷ 1005 ∷ []) (floor 5 4 1 1 ∷ []) false false true 1) (1000 , 2006) (valid (route false 127 8 ((2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 9 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (false , 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (1004 ∷ []) (floor 2 1 2 3 ∷ []) false false true 1) (1000 , 1006) (valid (route false 122 2 ((1006 , 2002) ∷ []) (true , 2 ∷ []))) + ≡ valid (route false 122 4 ((1000 , 1006) ∷ (1006 , 2002) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (2005 ∷ []) (floor 5 6 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route true 0 10 ((1005 , 2003) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 127 11 ((1000 , 1005) ∷ (1005 , 2003) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 0 1 0 ∷ floor 6 4 1 0 ∷ []) false false true 3) (1000 , 1004) (valid (route false 128 6 ((1004 , 2004) ∷ (2004 , 1001) ∷ (1001 , 1005) ∷ (1005 , 2006) ∷ []) (false , 2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (2005 ∷ 2006 ∷ []) (floor 3 2 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 0 10 ((1004 , 1006) ∷ []) (true , 3 ∷ []))) + ≡ valid (route false 127 11 ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 0 true (2001 ∷ 2003 ∷ []) ([]) false false true 3) (1000 , 2005) (valid (route true 127 3 ((2005 , 1006) ∷ (1006 , 2001) ∷ (2001 , 1000) ∷ (1000 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 0 false (2002 ∷ 2006 ∷ []) (floor 6 2 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 2 ((1000 , 2003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false (1006 ∷ []) (floor 1 1 2 2 ∷ floor 4 5 1 0 ∷ floor 5 6 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 122 7 ((2004 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 127 false ([]) (floor 6 4 1 1 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 2 ((1000 , 2002) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false ([]) (floor 0 4 1 1 ∷ floor 2 6 2 2 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 0 ((2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 127 3 ((1000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 127 8 ((2001 , 2005) ∷ (2005 , 2003) ∷ []) (true , 3 ∷ 3 ∷ []))) + ≡ valid (route false 127 9 ((1000 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2003) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 255 true (2001 ∷ 2003 ∷ []) ([]) false false true 2) (1000 , 2002) (valid (route false 128 3 ((2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 255 5 ((1000 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (1005 ∷ []) ([]) false false true 1) (1000 , 2005) (valid (route false 122 7 ((2005 , 2004) ∷ (2004 , 1005) ∷ []) (true , 1 ∷ 1 ∷ []))) + ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1005) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (1001 ∷ 1004 ∷ []) (floor 2 5 2 0 ∷ floor 4 5 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route false 128 9 ((2005 , 2006) ∷ []) (false , 1 ∷ []))) + ≡ valid (route false 128 11 ((1000 , 2005) ∷ (2005 , 2006) ∷ []) (false , 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false ([]) (floor 1 2 2 0 ∷ floor 4 3 2 3 ∷ floor 6 3 1 1 ∷ []) false false false 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 true (1005 ∷ 2005 ∷ []) (floor 1 4 1 1 ∷ floor 6 1 2 0 ∷ []) false false false 3) (1000 , 1003) (valid (route false 128 3 ((1003 , 2005) ∷ (2005 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2006) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 0 false (1002 ∷ 1005 ∷ []) ([]) false true true 1) (1000 , 1006) (valid (route false 0 4 ((1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 0 5 ((1000 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 0 true (1002 ∷ []) ([]) false false true 2) (1000 , 2005) (valid (route false 127 11 ((2005 , 1004) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 127 13 ((1000 , 2005) ∷ (2005 , 1004) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false (2002 ∷ []) (floor 1 5 1 2 ∷ floor 3 0 1 2 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1001) (valid (route false 255 6 ((1001 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1004) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (2004 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 3 ((1006 , 1002) ∷ []) (true , 1 ∷ []))) + ≡ valid (route false 128 6 ((1000 , 1006) ∷ (1006 , 1002) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 4 0 2 1 ∷ floor 4 5 2 0 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2001) (valid (route false 122 5 ((2001 , 2002) ∷ []) (true , 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (1005 ∷ []) (floor 3 3 1 3 ∷ []) true true false 3) (1000 , 1001) (valid (route true 122 0 ((1001 , 1036) ∷ (1036 , 2016) ∷ (2016 , 2025) ∷ (2025 , 2032) ∷ (2032 , 2017) ∷ (2017 , 1027) ∷ (1027 , 2039) ∷ (2039 , 2035) ∷ (2035 , 2020) ∷ (2020 , 1023) ∷ (1023 , 1024) ∷ (1024 , 2007) ∷ (2007 , 2009) ∷ (2009 , 1011) ∷ (1011 , 1010) ∷ (1010 , 2004) ∷ (2004 , 2030) ∷ (2030 , 1008) ∷ (1008 , 1019) ∷ (1019 , 1003) ∷ (1003 , 1038) ∷ (1038 , 2012) ∷ (2012 , 1021) ∷ (1021 , 1034) ∷ (1034 , 2015) ∷ (2015 , 2022) ∷ (2022 , 1018) ∷ (1018 , 2014) ∷ (2014 , 1028) ∷ (1028 , 1031) ∷ (1031 , 1013) ∷ (1013 , 2029) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 128 false ([]) (floor 6 3 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 255 8 ((2005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) + ≡ valid (route false 255 12 ((1000 , 2005) ∷ (2005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 5 1 3 ∷ floor 4 3 1 2 ∷ []) false true false 2) (1000 , 2006) (valid (route true 255 8 ((2006 , 1003) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 255 9 ((1000 , 2006) ∷ (2006 , 1003) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1006 ∷ []) (floor 3 5 1 0 ∷ []) true true true 2) (1000 , 2006) (valid (route true 0 7 ((2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 128 11 ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 0 true ([]) (floor 0 5 1 0 ∷ floor 4 4 1 0 ∷ floor 6 0 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 255 4 ((2004 , 1004) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 255 7 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false ([]) (floor 2 4 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 1 ((1000 , 2003) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false ([]) (floor 0 6 2 3 ∷ []) false true true 3) (1000 , 2001) (valid (route false 122 0 ((2001 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1000) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false ([]) (floor 2 0 2 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 3 ((1000 , 2006) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false (1002 ∷ 2005 ∷ []) (floor 1 5 2 3 ∷ floor 3 4 1 0 ∷ floor 5 4 2 2 ∷ []) true false true 1) (1000 , 2003) (valid (route false 127 9 ((2003 , 1000) ∷ []) (true , 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (1004 ∷ 2006 ∷ []) (floor 5 3 1 3 ∷ []) false true true 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 2004) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2005 ∷ []) (floor 0 3 2 1 ∷ floor 5 3 1 0 ∷ floor 6 3 1 1 ∷ []) true false false 1) (1000 , 2006) (valid (route false 128 5 ((2006 , 1005) ∷ (1005 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 3 5 2 3 ∷ floor 5 2 2 1 ∷ floor 6 3 2 2 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 10 ((2002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1000) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 122 false (1004 ∷ 1006 ∷ []) ([]) true false false 2) (1000 , 1001) (valid (route false 127 0 ((1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 127 1 ((1000 , 1001) ∷ (1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (2001 ∷ []) (floor 1 4 2 0 ∷ floor 4 1 2 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 122 0 ((1004 , 2003) ∷ (2003 , 2002) ∷ []) (false , 1 ∷ 1 ∷ []))) + ≡ valid (route true 127 1 ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false ([]) (floor 2 0 1 0 ∷ floor 5 5 2 3 ∷ floor 6 6 1 2 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 1 ((1005 , 2004) ∷ (2004 , 1003) ∷ []) (true , 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 5 ((1000 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 true ([]) (floor 1 3 2 0 ∷ []) true false true 1) (1000 , 2005) (valid (route true 122 5 ((2005 , 1005) ∷ (1005 , 2001) ∷ []) (false , 2 ∷ 1 ∷ []))) + ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 1005) ∷ (1005 , 2001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 255 true (2004 ∷ []) (floor 1 3 2 0 ∷ floor 3 6 1 1 ∷ []) false true false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 255 false ([]) ([]) false false true 1) (1000 , 1004) (valid (route false 127 3 ((1004 , 2003) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 255 5 ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 1 0 2 2 ∷ floor 6 6 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 122 2 ((1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route false 127 3 ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 0 1 1 3 ∷ floor 4 5 2 1 ∷ []) false true true 1) (1000 , 1004) (valid (route false 255 8 ((1004 , 1000) ∷ (1000 , 1001) ∷ (1001 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 127 false (1003 ∷ 2002 ∷ []) (floor 0 5 1 1 ∷ floor 5 1 2 1 ∷ []) false false true 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 4 ((1000 , 1003) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false ([]) (floor 0 4 1 1 ∷ floor 6 0 1 0 ∷ []) false false true 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 2 ((1000 , 2005) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false (2004 ∷ []) (floor 1 2 1 3 ∷ []) false false true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 4 ((1000 , 2002) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 true (2005 ∷ []) (floor 2 4 1 3 ∷ floor 3 2 2 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 0 3 ((2002 , 1005) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 0 5 ((1000 , 2002) ∷ (2002 , 1005) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1004 ∷ 1005 ∷ []) (floor 1 1 1 0 ∷ floor 3 3 1 2 ∷ floor 6 1 2 2 ∷ []) false false false 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 255 false (1005 ∷ 1006 ∷ []) ([]) false false false 1) (1000 , 1003) (valid (route false 122 10 ((1003 , 2028) ∷ (2028 , 2002) ∷ (2002 , 2036) ∷ (2036 , 1026) ∷ (1026 , 2003) ∷ (2003 , 2020) ∷ (2020 , 2021) ∷ (2021 , 1034) ∷ (1034 , 2012) ∷ (2012 , 1011) ∷ (1011 , 2006) ∷ (2006 , 1025) ∷ (1025 , 1017) ∷ (1017 , 1032) ∷ (1032 , 1008) ∷ (1008 , 1005) ∷ (1005 , 2016) ∷ (2016 , 2038) ∷ (2038 , 2013) ∷ (2013 , 2015) ∷ (2015 , 1022) ∷ (1022 , 1035) ∷ (1035 , 2030) ∷ (2030 , 1019) ∷ (1019 , 2001) ∷ (2001 , 1039) ∷ (1039 , 2029) ∷ (2029 , 2023) ∷ (2023 , 2010) ∷ (2010 , 2031) ∷ (2031 , 1009) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false (2002 ∷ []) (floor 5 2 2 2 ∷ []) false true false 1) (1000 , 1002) (valid (route false 128 11 ((1002 , 1005) ∷ (1005 , 1001) ∷ []) (true , 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 true ([]) (floor 0 2 2 3 ∷ floor 4 3 1 1 ∷ floor 6 1 2 0 ∷ []) true false true 2) (1000 , 1003) (valid (route false 128 9 ((1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 128 12 ((1000 , 1003) ∷ (1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (2001 ∷ []) ([]) false false true 3) (1000 , 2006) (valid (route false 255 2 ((2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route true 255 6 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 127 false ([]) (floor 1 1 1 1 ∷ floor 6 6 2 2 ∷ []) false false true 3) (1000 , 2004) (valid (route false 255 2 ((2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 4 ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (1003 ∷ []) ([]) true false false 2) (1000 , 2004) (valid (route false 127 6 ((2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 127 7 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 true (1002 ∷ 2006 ∷ []) (floor 4 3 2 1 ∷ []) true true true 1) (1000 , 2001) (valid (route false 0 2 ((2001 , 1000) ∷ (1000 , 2005) ∷ (2005 , 2004) ∷ []) (true , 3 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 true ([]) ([]) false false true 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 3 ((1000 , 2005) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1003 ∷ 2004 ∷ []) (floor 1 1 2 0 ∷ floor 2 5 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 122 9 ((1003 , 2002) ∷ (2002 , 2006) ∷ (2006 , 2003) ∷ (2003 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 128 true ([]) ([]) false false false 3) (1000 , 2001) (valid (route false 128 6 ((2001 , 2004) ∷ []) (true , 3 ∷ []))) + ≡ valid (route true 128 8 ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false ([]) (floor 0 3 1 2 ∷ floor 2 1 2 2 ∷ []) false true true 3) (1000 , 1001) (valid (route false 127 10 ((1001 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 1000) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false (1004 ∷ 1006 ∷ []) (floor 6 3 2 0 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 10 ((1002 , 1005) ∷ (1005 , 1006) ∷ (1006 , 1000) ∷ []) (true , 3 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 255 true (2002 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 1002) (valid (route true 128 10 ((1002 , 2006) ∷ (2006 , 2005) ∷ []) (true , 1 ∷ 3 ∷ []))) + ≡ valid (route true 255 13 ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2005) ∷ []) (true , 1 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false ([]) (floor 5 1 2 3 ∷ floor 5 3 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 255 11 ((2002 , 2004) ∷ (2004 , 1000) ∷ (1000 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 255 false (1002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 255 8 ((1004 , 1000) ∷ (1000 , 1002) ∷ (1002 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (2006 ∷ []) ([]) true false false 2) (1000 , 1003) (valid (route false 255 11 ((1003 , 2005) ∷ []) (true , 3 ∷ []))) + ≡ valid (route false 255 14 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (2005 ∷ []) (floor 1 2 1 2 ∷ floor 3 6 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 128 false (1006 ∷ []) (floor 0 5 2 0 ∷ floor 5 5 2 2 ∷ []) false true true 1) (1000 , 2003) (valid (route false 128 5 ((2003 , 1002) ∷ []) (true , 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 128 false (1005 ∷ 2005 ∷ []) (floor 2 1 2 2 ∷ floor 3 5 1 0 ∷ floor 5 0 1 3 ∷ []) true false true 2) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 4 ((1000 , 1001) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2005 ∷ 2006 ∷ []) ([]) false false true 2) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 2 ((1000 , 1001) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 128 true (2004 ∷ []) (floor 1 3 2 3 ∷ floor 4 0 1 3 ∷ floor 5 4 2 1 ∷ []) true false true 1) (1000 , 1002) (valid (route false 122 8 ((1002 , 2002) ∷ (2002 , 2006) ∷ []) (true , 2 ∷ 3 ∷ []))) + ≡ valid (route true 128 11 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2006) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true (1005 ∷ 2002 ∷ []) (floor 1 2 1 3 ∷ floor 5 0 1 1 ∷ []) true true true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 128 2 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false (1006 ∷ 2006 ∷ []) (floor 4 5 1 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 2 ((1002 , 2005) ∷ (2005 , 1003) ∷ []) (true , 3 ∷ 1 ∷ []))) + ≡ valid (route false 0 6 ((1000 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1003) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false ([]) (floor 2 1 2 1 ∷ floor 5 1 1 2 ∷ floor 6 3 2 2 ∷ []) true true false 3) (1000 , 1001) (valid (route false 255 10 ((1001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 2005) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 122 false (2001 ∷ []) (floor 6 4 2 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 122 7 ((2005 , 1002) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 122 9 ((1000 , 2005) ∷ (2005 , 1002) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (2005 ∷ []) (floor 1 4 2 3 ∷ floor 1 6 1 2 ∷ floor 2 4 2 2 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 0 true ([]) ([]) false false false 1) (1000 , 2005) (valid (route false 122 8 ((2005 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1000) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 127 false (1003 ∷ 2003 ∷ []) (floor 1 1 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 127 11 ((1003 , 2005) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 127 13 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false (1004 ∷ 2004 ∷ []) (floor 5 4 2 3 ∷ floor 6 5 2 2 ∷ []) true true true 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 3 ((1000 , 1001) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (1004 ∷ 2004 ∷ []) (floor 2 0 1 1 ∷ floor 2 5 2 2 ∷ floor 6 5 1 3 ∷ []) false true true 3) (1000 , 2003) (valid (route false 255 8 ((2003 , 2002) ∷ []) (false , 1 ∷ []))) + ≡ valid (route false 255 9 ((1000 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 0 true (2002 ∷ []) (floor 2 4 1 1 ∷ floor 3 5 1 0 ∷ floor 6 1 1 0 ∷ []) true true true 3) (1000 , 1006) (valid (route true 255 7 ((1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 255 8 ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (2006 ∷ []) (floor 4 5 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 255 5 ((1003 , 2005) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 255 6 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 122 true ([]) (floor 2 5 2 3 ∷ []) false false false 1) (1000 , 2005) (valid (route false 127 7 ((2005 , 1000) ∷ (1000 , 2004) ∷ []) (true , 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 false (1004 ∷ []) (floor 0 2 2 0 ∷ floor 0 5 1 0 ∷ floor 4 6 1 1 ∷ []) false false false 3) (1000 , 1001) (valid (route false 255 9 ((1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 255 13 ((1000 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 255 true (2005 ∷ []) ([]) false false true 3) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 2 ((1000 , 2002) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (2006 ∷ []) (floor 5 2 1 3 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 128 4 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 255 false (2004 ∷ []) (floor 1 0 2 2 ∷ floor 3 5 2 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 7 ((1002 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2003) ∷ (2003 , 1000) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false ([]) (floor 0 6 1 1 ∷ floor 1 0 1 0 ∷ []) true false true 3) (1000 , 2002) (valid (route true 128 8 ((2002 , 2003) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 128 11 ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (true , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 255 true (1001 ∷ 2004 ∷ []) (floor 1 3 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 128 7 ((2001 , 1003) ∷ (1003 , 1000) ∷ (1000 , 2006) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 128 false ([]) ([]) true false true 1) (1000 , 1005) (valid (route true 255 0 ((1005 , 2002) ∷ (2002 , 1000) ∷ (1000 , 2005) ∷ (2005 , 1001) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false (1006 ∷ []) (floor 5 1 2 1 ∷ []) true false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 false ([]) (floor 2 5 1 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 1 ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 255 5 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (1004 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1001) (valid (route false 255 8 ((1001 , 2003) ∷ []) (true , 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 false ([]) (floor 1 4 2 0 ∷ []) true true true 3) (1000 , 2002) (valid (route false 127 0 ((2002 , 1000) ∷ []) (false , 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 0 false (2001 ∷ []) (floor 0 0 2 2 ∷ floor 2 2 2 0 ∷ floor 6 1 2 1 ∷ []) false true true 1) (1000 , 2003) (valid (route false 127 2 ((2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1006 ∷ 2004 ∷ []) ([]) true true true 2) (1000 , 1004) (valid (route false 128 0 ((1004 , 2005) ∷ []) (false , 1 ∷ []))) + ≡ valid (route false 128 4 ((1000 , 1004) ∷ (1004 , 2005) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 127 false (1002 ∷ 1005 ∷ []) (floor 2 2 2 3 ∷ floor 3 0 2 3 ∷ floor 6 2 1 2 ∷ []) false false true 3) (1000 , 1004) (valid (route true 127 9 ((1004 , 2003) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 127 11 ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1003 ∷ []) (floor 4 0 2 3 ∷ floor 5 3 2 2 ∷ floor 5 5 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 10 ((2004 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 0 false ([]) (floor 1 0 2 0 ∷ floor 2 5 1 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 122 9 ((2006 , 2002) ∷ (2002 , 1003) ∷ []) (true , 1 ∷ 1 ∷ []))) + ≡ valid (route false 122 10 ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1003) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 255 false ([]) (floor 0 3 2 2 ∷ floor 4 2 2 0 ∷ floor 6 1 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 2 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (1005 ∷ 2001 ∷ []) (floor 6 1 1 3 ∷ []) true false false 2) (1000 , 1004) (valid (route true 255 0 ((1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 255 1 ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 true (1005 ∷ []) (floor 4 1 2 0 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 128 1 ((1000 , 2002) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 127 false (2002 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 1 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 122 9 ((2006 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1000) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 128 false (1006 ∷ 2003 ∷ []) (floor 2 5 1 0 ∷ floor 2 6 1 3 ∷ []) false true true 1) (1000 , 2002) (valid (route false 128 1 ((2002 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 255 11 ((2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 14 ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2006 ∷ []) (floor 4 0 2 0 ∷ floor 5 6 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route true 0 5 ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 0 7 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (false , 1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false ([]) (floor 3 5 2 3 ∷ floor 5 1 1 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 128 10 ((2005 , 1000) ∷ (1000 , 1004) ∷ (1004 , 2001) ∷ (2001 , 1002) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 0 false ([]) (floor 0 3 1 3 ∷ floor 4 1 2 2 ∷ floor 5 0 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 1 ((1000 , 2004) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (2001 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route true 0 4 ((2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 122 5 ((1000 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 2 1 0 ∷ floor 4 0 1 3 ∷ floor 6 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 2 ((1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 128 5 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 true (1004 ∷ []) ([]) true true true 1) (1000 , 1002) (valid (route false 122 2 ((1002 , 2002) ∷ []) (true , 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (2002 ∷ 2006 ∷ []) ([]) false true true 3) (1000 , 1002) (valid (route false 128 10 ((1002 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 2 ∷ []))) + ≡ valid (route false 128 11 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false (2003 ∷ []) (floor 3 2 2 1 ∷ floor 5 3 2 0 ∷ []) false true true 3) (1000 , 2004) (valid (route false 255 0 ((2004 , 2005) ∷ []) (true , 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (2004 ∷ []) (floor 4 1 2 0 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 3 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false ([]) (floor 0 4 1 1 ∷ []) true true true 2) (1000 , 1004) (valid (route false 127 10 ((1004 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2003) ∷ []) (true , 1 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (2005 ∷ []) (floor 3 0 1 2 ∷ []) false false true 3) (1000 , 2004) (valid (route true 122 5 ((2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 true ([]) (floor 0 1 2 3 ∷ floor 6 4 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 128 5 ((2002 , 2031) ∷ (2031 , 1010) ∷ (1010 , 2011) ∷ (2011 , 1027) ∷ (1027 , 2022) ∷ (2022 , 1040) ∷ (1040 , 1029) ∷ (1029 , 1020) ∷ (1020 , 1017) ∷ (1017 , 1001) ∷ (1001 , 1007) ∷ (1007 , 1037) ∷ (1037 , 2019) ∷ (2019 , 2015) ∷ (2015 , 2039) ∷ (2039 , 2026) ∷ (2026 , 2016) ∷ (2016 , 1013) ∷ (1013 , 1002) ∷ (1002 , 2038) ∷ (2038 , 1008) ∷ (1008 , 2018) ∷ (2018 , 2036) ∷ (2036 , 2014) ∷ (2014 , 1004) ∷ (1004 , 2033) ∷ (2033 , 2003) ∷ (2003 , 1034) ∷ (1034 , 2032) ∷ (2032 , 1023) ∷ (1023 , 1009) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (1003 ∷ 1006 ∷ []) (floor 4 5 2 3 ∷ floor 6 5 1 2 ∷ []) false false false 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 128 false (1003 ∷ []) ([]) false false true 3) (1000 , 1001) (valid (route false 0 0 ((1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 128 2 ((1000 , 1001) ∷ (1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 0 true ([]) ([]) false true false 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 2 2 2 1 ∷ floor 6 2 2 0 ∷ []) false false false 3) (1000 , 2001) (valid (route false 122 0 ((2001 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1002) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 true (2003 ∷ 2005 ∷ []) (floor 1 1 1 0 ∷ floor 6 5 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 128 7 ((2004 , 1004) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 128 10 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 6 0 2 2 ∷ floor 6 6 2 1 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (2005 ∷ []) ([]) true true true 1) (1000 , 2005) (valid (route false 122 4 ((2005 , 2003) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 127 8 ((1000 , 2005) ∷ (2005 , 2003) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false ([]) (floor 0 2 1 0 ∷ floor 1 4 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 1 ((1000 , 1001) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 127 5 ((2003 , 1004) ∷ (1004 , 2006) ∷ []) (false , 3 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false ([]) (floor 3 6 1 3 ∷ []) false true true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 1 ((1000 , 1005) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false ([]) ([]) false false true 1) (1000 , 2004) (valid (route false 127 4 ((2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 127 5 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false ([]) ([]) false false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 true ([]) (floor 2 0 2 0 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 2006) (valid (route false 128 8 ((2006 , 2002) ∷ (2002 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) + ≡ valid (route true 128 9 ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (2002 ∷ []) (floor 2 4 2 3 ∷ floor 5 5 2 3 ∷ []) false true true 3) (1000 , 1004) (valid (route false 128 8 ((1004 , 2004) ∷ (2004 , 1006) ∷ []) (true , 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 127 false (2006 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 0 6 ((1003 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 false ([]) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 4 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1003 ∷ 1006 ∷ []) (floor 0 4 1 0 ∷ floor 4 0 2 2 ∷ floor 4 1 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 6 ((1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 128 10 ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 6 1 1 ∷ floor 2 6 2 1 ∷ floor 3 6 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 127 7 ((1003 , 1000) ∷ (1000 , 1004) ∷ []) (true , 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 127 false (2005 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 255 0 ((2006 , 2004) ∷ (2004 , 1006) ∷ []) (false , 2 ∷ 3 ∷ []))) + ≡ valid (route false 255 4 ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false ([]) (floor 0 0 2 0 ∷ floor 2 6 2 0 ∷ floor 3 3 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 4 ((1000 , 2001) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 4 122 true (1005 ∷ 2006 ∷ []) (floor 1 2 1 1 ∷ floor 6 6 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route true 128 5 ((1003 , 1004) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 128 9 ((1000 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (1003 ∷ []) (floor 0 1 1 3 ∷ floor 1 0 2 3 ∷ floor 6 0 2 3 ∷ []) true false true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 1 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (1003 ∷ 2004 ∷ []) (floor 1 0 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 2 ∷ []) false true true 2) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 1 ((1000 , 1005) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 true (2001 ∷ 2005 ∷ []) (floor 2 4 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 255 11 ((1004 , 1005) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 255 13 ((1000 , 1004) ∷ (1004 , 1005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (2002 ∷ []) (floor 1 6 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 127 9 ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 127 11 ((1000 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1004 ∷ []) (floor 0 4 2 3 ∷ floor 1 3 1 0 ∷ floor 6 6 2 0 ∷ []) false false true 2) (1000 , 1005) (valid (route true 128 8 ((1005 , 2012) ∷ (2012 , 2029) ∷ (2029 , 2039) ∷ (2039 , 2028) ∷ (2028 , 2040) ∷ (2040 , 2011) ∷ (2011 , 2003) ∷ (2003 , 1024) ∷ (1024 , 2014) ∷ (2014 , 2002) ∷ (2002 , 2008) ∷ (2008 , 2015) ∷ (2015 , 1026) ∷ (1026 , 2007) ∷ (2007 , 1009) ∷ (1009 , 1038) ∷ (1038 , 2034) ∷ (2034 , 1022) ∷ (1022 , 2036) ∷ (2036 , 1001) ∷ (1001 , 2025) ∷ (2025 , 2020) ∷ (2020 , 1018) ∷ (1018 , 1013) ∷ (1013 , 1017) ∷ (1017 , 2023) ∷ (2023 , 1035) ∷ (1035 , 1027) ∷ (1027 , 2005) ∷ (2005 , 2016) ∷ (2016 , 1019) ∷ (1019 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 128 false (2004 ∷ []) (floor 0 1 1 3 ∷ floor 0 5 2 2 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 2 1 3 ∷ floor 3 3 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route false 122 8 ((1006 , 1002) ∷ (1002 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) + ≡ valid (route true 127 9 ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (1005 ∷ 2003 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 255 3 ((2003 , 1006) ∷ (1006 , 2002) ∷ []) (false , 2 ∷ 3 ∷ []))) + ≡ valid (route true 255 4 ((1000 , 2003) ∷ (2003 , 1006) ∷ (1006 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 128 false (1006 ∷ []) (floor 2 1 1 3 ∷ floor 2 6 2 1 ∷ []) false false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 122 false (2001 ∷ []) (floor 2 6 2 3 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 1 ((1000 , 2003) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 3 127 true ([]) (floor 1 0 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 127 3 ((1000 , 1006) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) ([]) true false true 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 2006) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 true (1002 ∷ []) (floor 4 5 1 1 ∷ []) true false true 3) (1000 , 2001) (valid (route false 122 2 ((2001 , 1006) ∷ (1006 , 1002) ∷ []) (true , 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 127 false (1002 ∷ []) (floor 4 5 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 2004) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 2006) (valid (route false 127 11 ((2006 , 1006) ∷ []) (true , 1 ∷ []))) + ⊕ extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 1004) (valid (route false 127 11 ((1004 , 1006) ∷ []) (true , 1 ∷ []))) + ≡ valid (route false 128 12 ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (true , 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 0 false (1005 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 255 6 ((1002 , 1000) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 4 127 true (1005 ∷ 2005 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 255 4 ((1003 , 2002) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 255 8 ((1000 , 1003) ∷ (1003 , 2002) ∷ []) (false , 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 4 ((1000 , 2001) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 2) (1000 , 1001) (valid (route false 122 4 ((1001 , 1006) ∷ (1006 , 1003) ∷ []) (false , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 3) (1000 , 2005) (valid (route false 122 2 ((2005 , 2001) ∷ []) (false , 3 ∷ []))) + ≡ valid (route false 122 6 ((1000 , 2005) ∷ (2005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 2001) (valid (route true 128 6 ((2001 , 2003) ∷ []) (false , 3 ∷ []))) + ⊕ extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 1002) (valid (route true 128 6 ((1002 , 2003) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 128 10 ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 255 true (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 8 ((1001 , 1002) ∷ (1002 , 1005) ∷ []) (true , 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 127 false (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 128 5 ((1004 , 2006) ∷ (2006 , 1005) ∷ []) (false , 3 ∷ 3 ∷ []))) + ≡ valid (route true 128 9 ((1000 , 1004) ∷ (1004 , 2006) ∷ (2006 , 1005) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 128 0 ((1003 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 0 true ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 0 2 ((1000 , 1006) ∷ []) (true , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1006 ∷ 2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 122 8 ((2003 , 1004) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 4 128 false (1006 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 1002) (valid (route true 128 0 ((1002 , 1004) ∷ (1004 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1001) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 128 9 ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false (1006 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route true 128 3 ((1004 , 1005) ∷ []) (true , 3 ∷ []))) + ⊕ extend (link true 2 0 false (1006 ∷ []) ([]) true false false 3) (1000 , 1002) (valid (route false 127 1 ((1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (true , 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route false 127 3 ((1000 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 128 2 ((2006 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2002) (valid (route false 128 2 ((2002 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 255 false ([]) (floor 3 1 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 10 ((1005 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 3 0 true ([]) (floor 3 1 1 3 ∷ []) true true true 2) (1000 , 2004) (valid (route false 122 11 ((2004 , 1004) ∷ (1004 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 ((1000 , 1005) ∷ (1005 , 2005) ∷ (2005 , 1002) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 2004) (valid (route false 0 8 ((2004 , 2002) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 1002) (valid (route false 0 8 ((1002 , 2002) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 255 12 ((1000 , 1002) ∷ (1002 , 2002) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 2006) (valid (route false 127 0 ((2006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1005) ∷ (1005 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 122 false ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 2 ((1000 , 1002) ∷ []) (true , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 128 2 ((1003 , 1000) ∷ []) (true , 2 ∷ []))) + ⊕ extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 128 2 ((1001 , 1000) ∷ []) (true , 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 122 10 ((2004 , 1003) ∷ []) (true , 3 ∷ []))) + ⊕ extend (link true 4 128 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false false 2) (1000 , 1005) (valid (route true 128 2 ((1005 , 2006) ∷ []) (true , 2 ∷ []))) + ≡ valid (route false 122 12 ((1000 , 2004) ∷ (2004 , 1003) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route true 128 7 ((1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 2006) (valid (route true 128 7 ((2006 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route true 128 9 ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2003) (valid (route true 128 6 ((2003 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2002) (valid (route true 128 6 ((2002 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 128 false (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) true true false 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 122 1 ((1000 , 2003) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false ([]) (floor 3 2 2 0 ∷ []) false false true 3) (1000 , 1005) (valid (route true 0 7 ((1005 , 2006) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 3 2 2 0 ∷ []) false false false 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 122 9 ((1000 , 1005) ∷ (1005 , 2006) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (1005 ∷ 2002 ∷ []) ([]) false false false 2) (1000 , 2003) (valid (route false 127 3 ((2003 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1005 ∷ 2002 ∷ []) ([]) false true true 3) (1000 , 1006) (valid (route true 122 1 ((1006 , 2005) ∷ (2005 , 2001) ∷ []) (false , 1 ∷ 3 ∷ []))) + ≡ valid (route true 122 4 ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 2001) ∷ []) (true , 2 ∷ []))) + ⊕ extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 127 8 ((1004 , 2001) ∷ []) (true , 2 ∷ []))) + ≡ valid (route false 128 10 ((1000 , 2003) ∷ (2003 , 2001) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 true ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) true true false 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 127 false ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) false true true 3) (1000 , 1001) (valid (route false 128 9 ((1001 , 1000) ∷ (1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1003) (valid (route false 127 5 ((1003 , 1002) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1004) (valid (route false 127 5 ((1004 , 1002) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 127 6 ((1000 , 1004) ∷ (1004 , 1002) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 1003) (valid (route true 0 9 ((1003 , 2004) ∷ []) (true , 1 ∷ []))) + ⊕ extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 2001) (valid (route true 0 9 ((2001 , 2004) ∷ []) (true , 1 ∷ []))) + ≡ valid (route true 128 13 ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2005) (valid (route false 122 3 ((2005 , 1001) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 1006) (valid (route false 122 3 ((1006 , 1001) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 122 7 ((1000 , 2005) ∷ (2005 , 1001) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 2 ((2003 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 4 255 true (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 128 3 ((2001 , 1001) ∷ (1001 , 1005) ∷ []) (false , 2 ∷ 2 ∷ []))) + ≡ valid (route true 255 7 ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1005) (valid (route false 127 2 ((1005 , 1000) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1004) (valid (route false 127 2 ((1004 , 1000) ∷ []) (false , 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 true (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true false 3) (1000 , 2004) (valid (route false 0 6 ((2004 , 2002) ∷ (2002 , 2005) ∷ []) (true , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 2 0 false (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true true 1) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 2 ((1000 , 1003) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 8 ((2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 3 127 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 255 4 ((2004 , 2003) ∷ (2003 , 2006) ∷ []) (false , 3 ∷ 1 ∷ []))) + ≡ valid (route true 128 10 ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1006) (valid (route false 122 11 ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1003) (valid (route false 122 11 ((1003 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 128 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 4 ((2003 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1005) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 122 3 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 122 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 122 6 ((2003 , 1004) ∷ []) (true , 3 ∷ []))) + ≡ valid (route false 122 7 ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 127 false (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false true 1) (1000 , 1001) (valid (route false 122 9 ((1001 , 2004) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 3 127 true (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false false 2) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 128 false (2003 ∷ 2006 ∷ []) ([]) true true false 2) (1000 , 2003) (valid (route false 128 9 ((2003 , 1006) ∷ (1006 , 1000) ∷ (1000 , 2005) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (2003 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 3 ((1000 , 1002) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 4 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1001) (valid (route true 127 4 ((1001 , 2001) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1002) (valid (route true 127 4 ((1002 , 2001) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 127 7 ((1000 , 1001) ∷ (1001 , 2001) ∷ []) (true , 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 8 ((1004 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2001) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false false 3) (1000 , 2002) (valid (route false 255 1 ((2002 , 1002) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 255 5 ((1000 , 2002) ∷ (2002 , 1002) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false ([]) (floor 0 6 1 3 ∷ []) false false true 3) (1000 , 2002) (valid (route false 0 9 ((2002 , 2004) ∷ (2004 , 2006) ∷ []) (true , 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 0 false ([]) (floor 0 6 1 3 ∷ []) true true true 1) (1000 , 1005) (valid (route false 128 2 ((1005 , 2001) ∷ (2001 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) + ≡ valid (route false 127 12 ((1000 , 2002) ∷ (2002 , 2004) ∷ (2004 , 2006) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 1004) (valid (route true 0 10 ((1004 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 2 ∷ []))) + ⊕ extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 2001) (valid (route true 0 10 ((2001 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 2 ∷ []))) + ≡ valid (route true 255 13 ((1000 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 0 3 ((2001 , 2002) ∷ []) (true , 3 ∷ []))) + ⊕ extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 1006) (valid (route false 0 3 ((1006 , 2002) ∷ []) (true , 3 ∷ []))) + ≡ valid (route false 0 6 ((1000 , 2001) ∷ (2001 , 2002) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1003) (valid (route true 255 6 ((1003 , 1005) ∷ (1005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ []))) + ⊕ extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route true 255 6 ((1004 , 1005) ∷ (1005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ []))) + ≡ valid (route true 255 9 ((1000 , 1003) ∷ (1003 , 1005) ∷ (1005 , 2001) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 3 ((1000 , 1001) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false false true 3) (1000 , 2002) (valid (route true 127 1 ((2002 , 1002) ∷ []) (true , 1 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false true true 3) (1000 , 1006) (valid (route false 0 1 ((1006 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ []))) + ≡ valid (route true 122 2 ((1000 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2006) (valid (route false 255 7 ((2006 , 1005) ∷ []) (true , 3 ∷ []))) + ⊕ extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2001) (valid (route false 255 7 ((2001 , 1005) ∷ []) (true , 3 ∷ []))) + ≡ valid (route false 255 11 ((1000 , 2001) ∷ (2001 , 1005) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 2005) (valid (route true 122 10 ((2005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 1002) (valid (route true 122 10 ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route true 122 11 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 255 true (1004 ∷ []) ([]) true false false 1) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 255 true (1004 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 127 11 ((2001 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1005) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 1002) (valid (route true 128 2 ((1002 , 1001) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 2001) (valid (route true 128 2 ((2001 , 1001) ∷ []) (false , 1 ∷ []))) + ≡ valid (route true 255 4 ((1000 , 2001) ∷ (2001 , 1001) ∷ []) (true , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 true (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false true true 3) (1000 , 2004) (valid (route false 128 6 ((2004 , 2002) ∷ (2002 , 2003) ∷ []) (true , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 1 255 false (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 1 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2001) (valid (route false 0 2 ((2001 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2002) (valid (route false 0 2 ((2002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 1002) (valid (route false 0 0 ((1002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 0 ((2005 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 0 true (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 127 5 ((1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 128 false (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route true 122 2 ((1006 , 1002) ∷ (1002 , 1003) ∷ []) (false , 1 ∷ 2 ∷ []))) + ≡ valid (route true 127 9 ((1000 , 1001) ∷ (1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 3 ((2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 127 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 7 ((2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 255 6 ((1000 , 2002) ∷ (2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ []) false false true 3) (1000 , 1004) (valid (route false 122 6 ((1004 , 1003) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 2 127 false ([]) (floor 1 1 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 0 ((1002 , 1006) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 255 2 ((1000 , 1002) ∷ (1002 , 1006) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 128 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 3) (1000 , 2006) (valid (route false 122 5 ((2006 , 1000) ∷ (1000 , 1002) ∷ []) (false , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 2) (1000 , 1001) (valid (route false 255 10 ((1001 , 2003) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 255 11 ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false true true 2) (1000 , 1006) (valid (route true 255 5 ((1006 , 2006) ∷ (2006 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 1 128 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 128 1 ((1000 , 1004) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 127 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 255 2 ((2002 , 2004) ∷ (2004 , 2005) ∷ []) (true , 2 ∷ 3 ∷ []))) + ≡ valid (route false 0 2 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 2 122 true (2005 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 2001) (valid (route false 128 7 ((2001 , 1006) ∷ (1006 , 1005) ∷ []) (true , 1 ∷ 3 ∷ []))) + ⊕ extend (link true 2 255 false (2005 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1003) (valid (route false 0 0 ((1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route false 255 2 ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 128 true (1001 ∷ []) ([]) false false true 3) (1000 , 1005) (valid (route false 0 4 ((1005 , 1000) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 3 127 false (1001 ∷ []) ([]) false false false 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1002) (valid (route false 127 7 ((1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1005) (valid (route false 127 7 ((1005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 127 8 ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route true 128 10 ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 10 ((2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 255 11 ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 ((2001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 ((1002 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 122 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) true false false 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 127 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) false false false 1) (1000 , 2002) (valid (route false 255 3 ((2002 , 1004) ∷ (1004 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 128 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 10 ((2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 255 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) true false true 2) (1000 , 1004) (valid (route false 122 3 ((1004 , 1000) ∷ (1000 , 1006) ∷ (1006 , 1005) ∷ (1005 , 2002) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 128 14 ((1000 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 9 ((2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 1006) (valid (route false 0 9 ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 122 12 ((1000 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 2001) (valid (route false 128 3 ((2001 , 2003) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 1005) (valid (route false 128 3 ((1005 , 2003) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 128 5 ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route true 0 1 ((1004 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 2003) (valid (route true 0 1 ((2003 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 4 ((1000 , 2001) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2006) (valid (route true 127 11 ((2006 , 1005) ∷ []) (false , 3 ∷ []))) + ⊕ extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2004) (valid (route true 127 11 ((2004 , 1005) ∷ []) (false , 3 ∷ []))) + ≡ valid (route true 128 15 ((1000 , 2004) ∷ (2004 , 1005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 8 ((2004 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2003) (valid (route false 255 8 ((2003 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 true (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 3 ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 122 false (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) true true false 2) (1000 , 2005) (valid (route true 0 6 ((2005 , 2003) ∷ (2003 , 1000) ∷ []) (false , 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 255 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 122 false (1006 ∷ []) ([]) false false true 2) (1000 , 2006) (valid (route false 127 11 ((2006 , 2001) ∷ (2001 , 1006) ∷ (1006 , 1000) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 4 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 255 3 ((1000 , 2004) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 2 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1004 ∷ []) ([]) true false true 1) (1000 , 1001) (valid (route false 0 7 ((1001 , 2003) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 4 122 true (1004 ∷ []) ([]) true false true 2) (1000 , 1005) (valid (route true 255 1 ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 1 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 128 8 ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (true , 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2004) (valid (route true 127 10 ((2004 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2001) (valid (route true 127 10 ((2001 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 128 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 255 4 ((1003 , 2001) ∷ (2001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 7 ((1006 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 7 ((2001 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 1 255 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false true true 1) (1000 , 2001) (valid (route true 122 2 ((2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 255 3 ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 128 true (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 0 5 ((2004 , 2005) ∷ (2005 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 3) (1000 , 2002) (valid (route false 127 10 ((2002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ (1005 , 1000) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 128 8 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false ([]) (floor 3 2 1 2 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 8 ((2001 , 2006) ∷ []) (false , 1 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 3 2 1 2 ∷ []) false true true 1) (1000 , 1003) (valid (route false 255 3 ((1003 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1006) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 ((1000 , 2001) ∷ (2001 , 2006) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false true 3) (1000 , 1004) (valid (route true 0 8 ((1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 127 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 122 10 ((1000 , 1004) ∷ (1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 255 4 ((1000 , 2001) ∷ []) (true , 3 ∷ [])) +_ = refl + +_ : extend (link true 1 127 false (2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 255 false (2002 ∷ []) ([]) false false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 1 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) false true true 2) (1000 , 1006) (valid (route false 122 7 ((1006 , 2005) ∷ (2005 , 1003) ∷ (1003 , 1001) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 1 ((2003 , 2004) ∷ (2004 , 1001) ∷ []) (true , 1 ∷ 2 ∷ []))) + ≡ valid (route true 128 4 ((1000 , 2003) ∷ (2003 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 1 128 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route false 255 9 ((1002 , 1001) ∷ (1001 , 1005) ∷ []) (false , 3 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true false 3) (1000 , 1006) (valid (route false 255 0 ((1006 , 1000) ∷ []) (false , 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 127 10 ((1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 10 ((2005 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 127 13 ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2001) (valid (route false 255 9 ((2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2006) (valid (route false 255 9 ((2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 255 13 ((1000 , 2001) ∷ (2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 3 255 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 1) (1000 , 2001) (valid (route true 255 5 ((2001 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1002) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 3 128 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route true 128 11 ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2003) (valid (route false 127 3 ((2003 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2004) (valid (route false 127 3 ((2004 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ []))) + ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 4 ((2006 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 122 4 ((2004 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 3 ((2005 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2003) (valid (route false 0 3 ((2003 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 2 ∷ []))) + ≡ valid (route true 127 4 ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route true 0 3 ((2005 , 1004) ∷ []) (false , 2 ∷ []))) + ⊕ extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2004) (valid (route true 0 3 ((2004 , 1004) ∷ []) (false , 2 ∷ []))) + ≡ valid (route true 122 7 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2001) (valid (route false 127 8 ((2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 127 11 ((1000 , 2001) ∷ (2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2002) (valid (route false 128 1 ((2002 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2006) (valid (route false 128 1 ((2006 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2003) (valid (route false 122 8 ((2003 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2006) (valid (route false 122 8 ((2006 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 128 true (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) false false false 1) (1000 , 2004) (valid (route true 122 2 ((2004 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 false (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) true false false 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 128 3 ((1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 2005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false ([]) (floor 3 3 1 1 ∷ []) false false false 1) (1000 , 1006) (valid (route false 255 10 ((1006 , 1000) ∷ (1000 , 1005) ∷ []) (true , 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 128 false ([]) (floor 3 3 1 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 6 ((1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 128 7 ((1000 , 1002) ∷ (1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ = refl + +_ : extend (link true 3 127 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 3 ((2003 , 2006) ∷ (2006 , 2001) ∷ []) (false , 3 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 0 2 ((1000 , 1005) ∷ []) (false , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 2 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1004) (valid (route false 128 6 ((1004 , 1005) ∷ []) (false , 2 ∷ []))) + ≡ valid (route false 0 3 ((1000 , 2001) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) + ≡ invalid +_ = refl + +_ : extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1005) (valid (route true 0 6 ((1005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1001) (valid (route true 0 6 ((1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 128 8 ((1000 , 1001) ∷ (1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 255 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 3) (1000 , 2003) (valid (route false 255 9 ((2003 , 1005) ∷ (1005 , 1003) ∷ (1003 , 1002) ∷ (1002 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 3 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ = refl + +_ : extend (link true 2 255 false ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 128 6 ((1006 , 1002) ∷ (1002 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 0 true ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1003) (valid (route false 127 0 ((1003 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1002) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 255 8 ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2006) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) true false true 1) (1000 , 1005) (valid (route true 0 0 ((1005 , 1001) ∷ []) (true , 3 ∷ []))) + ⊕ extend (link true 4 0 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 5 ((2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 122 9 ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 false (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 1004) (valid (route false 127 11 ((1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 false (1001 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 127 13 ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false ([]) ([]) true false true 3) (1000 , 2004) (valid (route false 128 10 ((2004 , 2001) ∷ (2001 , 1005) ∷ []) (false , 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 127 false ([]) ([]) false true true 3) (1000 , 2005) (valid (route false 127 5 ((2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route false 127 9 ((1000 , 2005) ∷ (2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 122 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) true false false 3) (1000 , 1005) (valid (route false 0 9 ((1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 4 0 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) false true false 3) (1000 , 2006) (valid (route false 255 9 ((2006 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2003) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 122 10 ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 1001) (valid (route false 128 8 ((1001 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 2004) (valid (route false 128 8 ((2004 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 1 ∷ []))) + ≡ invalid +_ = refl + +_ : extend (link true 1 122 true ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true true true 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 0 false ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true false true 3) (1000 , 1003) (valid (route false 122 8 ((1003 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 3 ∷ []))) + ≡ valid (route true 122 1 ((1000 , 1006) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 1 127 true (1003 ∷ 2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 4 122 true (1003 ∷ 2002 ∷ []) ([]) false true false 3) (1000 , 2003) (valid (route false 122 6 ((2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 122 10 ((1000 , 2003) ∷ (2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 3 255 false (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true false true 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ⊕ extend (link true 3 0 true (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true true true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route true 0 3 ((1000 , 2006) ∷ []) (true , 1 ∷ [])) +_ = refl + +_ : extend (link true 2 122 false ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false true 1) (1000 , 1002) (valid (route false 128 11 ((1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 255 true ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false false 1) (1000 , 2001) (valid (route true 127 0 ((2001 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2004) ∷ (2004 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 128 13 ((1000 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ = refl + +_ : extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1006) (valid (route false 255 1 ((1006 , 2006) ∷ (2006 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) + ⊕ extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 255 1 ((1005 , 2006) ∷ (2006 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) + ≡ valid (route false 255 2 ((1000 , 1006) ∷ (1006 , 2006) ∷ (2006 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ [])) +_ = refl + +_ : extend (link true 1 255 true (1006 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1004) (valid (route false 122 8 ((1004 , 2004) ∷ (2004 , 1002) ∷ []) (false , 2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 122 false (1006 ∷ 2002 ∷ []) ([]) true true true 3) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) + ≡ valid (route false 122 2 ((1000 , 1002) ∷ []) (true , 3 ∷ [])) +_ = refl From 6a00be08525f08ef9bf79febc2dea6a58654adea Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 03:48:19 -0800 Subject: [PATCH 04/11] proof(moq-net): floors and named drains leave the rule's fixed point unchanged Co-Authored-By: Claude Opus 5.5 --- .../verify/route-algebra/Accelerate.agda | 219 ++++++++++++++++++ .../verify/route-algebra/Everything.agda | 1 + .../verify/route-algebra/Increasing.agda | 53 +++-- rs/moq-net/verify/route-algebra/Route.agda | 20 +- 4 files changed, 256 insertions(+), 37 deletions(-) create mode 100644 rs/moq-net/verify/route-algebra/Accelerate.agda diff --git a/rs/moq-net/verify/route-algebra/Accelerate.agda b/rs/moq-net/verify/route-algebra/Accelerate.agda new file mode 100644 index 00000000000..7edfef7a320 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/Accelerate.agda @@ -0,0 +1,219 @@ +-------------------------------------------------------------------------------- +-- The floor and the named drains only make the rule arrive sooner. +-- +-- Both are what a node learns about links other than its own: sessions known +-- closed, and nodes named draining. Without them (`plain`) the rule is the same +-- algebra over the same network, so it converges too. Every route at a fixed +-- point of `plain` crosses only live links, each beside the session it is live +-- on, and is draining wherever a link on it carries a GOAWAY (`sound`). So a floor +-- that holds only closed sessions refuses none of those routes, and naming a node +-- draining once it sent GOAWAY on every live link marks none of them draining that +-- was not. The fixed point of `plain` is then a fixed point with both +-- (`accelerated-fixed`): neither removes or demotes a route the iteration itself +-- would keep. +-------------------------------------------------------------------------------- + +open import Data.Nat.Base using (ℕ) +open import Relation.Binary.PropositionalEquality using (_≡_) + +module Accelerate + (relay start : ℕ → ℕ) + (relay-start-injective : ∀ {m n} → relay m ≡ relay n → start m ≡ start n → m ≡ n) + where + +open import Data.Bool.Base using (Bool; true; false; _∨_; _∧_; not) +import Data.Bool.Properties as Bool +open import Data.Fin.Base using (Fin; toℕ) +open import Data.List.Base using (List; []; _∷_; map; any; zip; length; foldr; tabulate; null) +open import Data.List.Properties using (tabulate-cong) +open import Data.List.Relation.Unary.All using (All; []; _∷_) +import Data.List.Relation.Unary.All as All +open import Data.Nat.Base using (zero; suc; _<_; _≤ᵇ_) +import Data.Nat.Properties as ℕ +open import Data.Product.Base using (_×_; _,_; ∃₂; proj₁; proj₂) +open import Data.Sum.Base using (_⊎_; inj₁; inj₂) +open import Data.Unit.Base using (⊤; tt) +open import Relation.Binary.PropositionalEquality using (refl; sym; trans; cong; subst) +open import Relation.Nullary.Decidable.Core using (yes; no) + +open import RoutingLib.Routing.Basics.Path.Uncertified using (Path; Edge) +open import RoutingLib.Routing.Basics.Path.Uncertified.Properties using (_⇿?_; _∈ₚ?_) +open import RoutingLib.Routing.Basics.Network using (AdjacencyMatrix) + +open import Route relay start relay-start-injective + +private + -- A link refuses every route while it is down. + refuses-up : ∀ f e x → refuses f e x ≡ false → Link.up f ≡ true + refuses-up (link true _ _ _ _ _ _ _ _ _) e x _ = refl + refuses-up (link false _ _ _ _ _ _ _ _ _) e x () + + -- No floor, no refusal; no one named draining, no one marked. + no-floor : ∀ zs → any (closed []) zs ≡ false + no-floor [] = refl + no-floor (_ ∷ zs) = no-floor zs + + no-drain : ∀ ns → any (_∈ᵇ []) ns ≡ false + no-drain [] = refl + no-drain (_ ∷ ns) = no-drain ns + + ∨-true : ∀ a {b} → b ≡ true → a ∨ b ≡ true + ∨-true false refl = refl + ∨-true true _ = refl + + absorb : ∀ a b → a ∨ b ≡ true → a ∨ (b ∨ true) ≡ a ∨ (b ∨ false) + absorb true _ _ = refl + absorb false true _ = refl + absorb false false () + +module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where + + -- A's links, with no floors and no node named draining. + plain : AdjacencyMatrix algebra n + plain i k = record (A i k) { floors = [] ; draining = [] } + + open import RoutingLib.Routing.VectorBased.Synchronous algebra A using (F; RoutingMatrix; I; Iᵢⱼ≈0⊎∞) + open import RoutingLib.Routing.VectorBased.Synchronous algebra plain using () renaming (F to F₀) + open import RoutingLib.Routing.VectorBased.Synchronous.DistanceVector.Properties isRoutingAlgebra plain + using (FXᵢⱼ≈Aᵢₖ▷Xₖⱼ⊎Iᵢⱼ) + + ------------------------------------------------------------------------ + -- What the two must respect + + -- A floor holds no session live on a link. + FloorsClosed : Set + FloorsClosed = ∀ i k (u v : Fin n) → Link.up (A u v) ≡ true → + closed (Link.floors (A i k)) ((toℕ u , toℕ v) , Link.session (A u v)) ≡ false + + -- A node is named draining only once it sent GOAWAY on every live link. + DrainNamed : Set + DrainNamed = ∀ i k (u v : Fin n) → toℕ v ∈ᵇ Link.draining (A i k) ≡ true → + Link.up (A u v) ≡ true → Link.drains (A u v) ≡ true + + ------------------------------------------------------------------------ + -- Routes that name only live links + + -- A link on a route: live, beside the session it is live on, and the route is + -- draining (`d`) if the link carries a GOAWAY. + Holds : Bool → Edge × ℕ → Set + Holds d ((u , v) , s) = ∃₂ λ (u′ v′ : Fin n) → + toℕ u′ ≡ u × toℕ v′ ≡ v × Link.up (A u′ v′) ≡ true × Link.session (A u′ v′) ≡ s × + (Link.drains (A u′ v′) ≡ true → d ≡ true) + + Sound : Weight → Set + Sound invalid = ⊤ + Sound (valid x) = length (proj₂ (extra x)) ≡ length (path x) × + All (Holds (draining x)) (zip (path x) (proj₂ (extra x))) + + private + weaken : ∀ {d d′} → (d ≡ true → d′ ≡ true) → ∀ {z} → Holds d z → Holds d′ z + weaken f (u′ , v′ , eu , ev , up , s , dr) = u′ , v′ , eu , ev , up , s , λ x → f (dr x) + + size : Weight → ℕ + size invalid = 0 + size (valid x) = length (path x) + + -- A step of `plain` keeps a route sound, where it needs the route it extends to be. + extend-sound : ∀ (k m : Fin n) w → (∀ {y} → extend (plain k m) (toℕ k , toℕ m) w ≡ valid y → Sound w) → + Sound (extend (plain k m) (toℕ k , toℕ m) w) + extend-sound k m invalid _ = tt + extend-sound k m (valid x) need + with (toℕ k , toℕ m) ⇿? path x | toℕ k ∈ₚ? path x + ... | no _ | _ = tt + ... | yes _ | yes _ = tt + ... | yes _ | no _ with refuses (plain k m) (toℕ k , toℕ m) x in eq + ... | true = tt + ... | false with need refl + ... | len , holds = cong suc len , + (k , m , refl , refl , refuses-up (plain k m) (toℕ k , toℕ m) x eq , refl , + λ dr → ∨-true (draining x) (subst (λ b → b ∨ _ ≡ true) (sym dr) refl)) ∷ + All.map (weaken λ d → subst (λ b → b ∨ _ ≡ true) (sym d) refl) holds + + -- A step lengthens the path it takes. + extend-size : ∀ f e w {y} → extend f e w ≡ valid y → size w < length (path y) + extend-size f e invalid () + extend-size f (i , j) (valid x) with (i , j) ⇿? path x | i ∈ₚ? path x + ... | no _ | _ = λ () + ... | yes _ | yes _ = λ () + ... | yes _ | no _ with refuses f (i , j) x + ... | true = λ () + ... | false = λ { refl → ℕ.n<1+n _ } + + -- Every route at a fixed point of `plain` is sound. + module _ (X : RoutingMatrix) (fixed : ∀ i j → F₀ X i j ≡ X i j) where + + private + sound′ : ∀ fuel k j → size (X k j) < fuel → Sound (X k j) + sound′ (suc fuel) k j lt with FXᵢⱼ≈Aᵢₖ▷Xₖⱼ⊎Iᵢⱼ X k j + ... | inj₂ FX≡I = subst Sound (trans (sym FX≡I) (fixed k j)) (identity (Iᵢⱼ≈0⊎∞ k j)) + where + identity : ∀ {r} → (r ≡ trivial) ⊎ (r ≡ invalid) → Sound r + identity (inj₁ refl) = refl , [] + identity (inj₂ refl) = tt + ... | inj₁ (m , FX≡) = subst Sound (trans (sym FX≡) (fixed k j)) (extend-sound k m (X m j) need) + where + need : ∀ {y} → extend (plain k m) (toℕ k , toℕ m) (X m j) ≡ valid y → Sound (X m j) + need eq = sound′ fuel m j (ℕ.<-≤-trans (extend-size _ _ (X m j) eq) + (ℕ.≤-pred (subst (λ r → size r < suc fuel) (trans (sym (fixed k j)) (trans FX≡ eq)) lt))) + + sound : ∀ k j → Sound (X k j) + sound k j = sound′ (suc (size (X k j))) k j (ℕ.n<1+n _) + + ------------------------------------------------------------------------ + -- The floor and the named drains change no sound route + + module _ (floors-closed : FloorsClosed) (drain-named : DrainNamed) where + + private + floors-silent : ∀ i k {d} zs → All (Holds d) zs → any (closed (Link.floors (A i k))) zs ≡ false + floors-silent i k [] [] = refl + floors-silent i k (_ ∷ zs) ((u′ , v′ , refl , refl , up , refl , _) ∷ hs) + rewrite floors-closed i k u′ v′ up = floors-silent i k zs hs + + named-drained : ∀ i k {d} p ss → length ss ≡ length p → All (Holds d) (zip p ss) → + any (_∈ᵇ Link.draining (A i k)) (map proj₂ p) ≡ true → d ≡ true + named-drained i k [] _ _ _ () + named-drained i k (_ ∷ _) [] () _ _ + named-drained i k (_ ∷ p) (_ ∷ ss) len ((u′ , v′ , refl , refl , up , refl , dr) ∷ hs) named + with toℕ v′ ∈ᵇ Link.draining (A i k) in vin + ... | true = dr (drain-named i k u′ v′ vin up) + ... | false = named-drained i k p ss (ℕ.suc-injective len) hs named + + -- A link of A refuses a sound route exactly when `plain` does. + same-refusal : ∀ i k x → All (Holds (draining x)) (zip (path x) (proj₂ (extra x))) → + refuses (A i k) (toℕ i , toℕ k) x ≡ refuses (plain i k) (toℕ i , toℕ k) x + same-refusal i k x holds = trans (cong prefix (floors-silent i k _ holds)) (sym (cong prefix (no-floor (zip (path x) (proj₂ (extra x)))))) + where + prefix : Bool → Bool + prefix b = not (Link.up (A i k)) ∨ (null (path x) ∧ not (Link.claimed (A i k))) + ∨ (proj₁ (extra x) ∧ Link.marked-there (A i k)) ∨ (max-hops ≤ᵇ suc (length (path x))) ∨ b + + -- One step across a link of A takes a sound route as `plain` does. + neutral : ∀ i k w → Sound w → extend (A i k) (toℕ i , toℕ k) w ≡ extend (plain i k) (toℕ i , toℕ k) w + neutral i k invalid _ = refl + neutral i k (valid x) (len , holds) + with (toℕ i , toℕ k) ⇿? path x | toℕ i ∈ₚ? path x + ... | no _ | _ = refl + ... | yes _ | yes _ = refl + ... | yes _ | no _ rewrite same-refusal i k x holds with refuses (plain i k) (toℕ i , toℕ k) x in eq + ... | true = refl + ... | false rewrite no-drain (map proj₂ (path x)) = cong (λ d → valid (route d _ _ _ _)) drained + where + up = refuses-up (plain i k) (toℕ i , toℕ k) x eq + -- What the drains add, given the route is already draining where they would. + drained : draining x ∨ (Link.drains (A i k) ∨ marks (A i k) (toℕ i , toℕ k) (path x)) + ≡ draining x ∨ (Link.drains (A i k) ∨ false) + drained with marks (A i k) (toℕ i , toℕ k) (path x) in m + ... | false = refl + ... | true = absorb (draining x) (Link.drains (A i k)) (named m) + where + named : marks (A i k) (toℕ i , toℕ k) (path x) ≡ true → draining x ∨ Link.drains (A i k) ≡ true + named m′ with toℕ k ∈ᵇ Link.draining (A i k) in kin + ... | true = ∨-true (draining x) (drain-named i k i k kin up) + ... | false = subst (λ b → b ∨ _ ≡ true) (sym (named-drained i k (path x) _ len holds m′)) refl + + -- The fixed point of `plain` is a fixed point of A. + accelerated-fixed : (X : RoutingMatrix) → (∀ i j → F₀ X i j ≡ X i j) → ∀ i j → F X i j ≡ X i j + accelerated-fixed X fixed i j = trans + (cong (foldr _⊕_ (I i j)) (tabulate-cong λ k → neutral i k (X k j) (sound X fixed k j))) + (fixed i j) diff --git a/rs/moq-net/verify/route-algebra/Everything.agda b/rs/moq-net/verify/route-algebra/Everything.agda index 54f56c7e729..a6cc126871b 100644 --- a/rs/moq-net/verify/route-algebra/Everything.agda +++ b/rs/moq-net/verify/route-algebra/Everything.agda @@ -6,3 +6,4 @@ import Route import Claim import Sim import Vectors +import Accelerate diff --git a/rs/moq-net/verify/route-algebra/Increasing.agda b/rs/moq-net/verify/route-algebra/Increasing.agda index ec3cd46778c..5e547bf5e83 100644 --- a/rs/moq-net/verify/route-algebra/Increasing.agda +++ b/rs/moq-net/verify/route-algebra/Increasing.agda @@ -17,7 +17,7 @@ -- enough (`convergent`). -------------------------------------------------------------------------------- -open import Data.Bool.Base using (Bool; true; false; _∨_) +open import Data.Bool.Base using (Bool; true; false; _∨_; if_then_else_) open import Data.List.Base using (List; []; _∷_) open import Data.Nat.Base using (ℕ; zero; suc; _+_; _⊔_; z≤n; _^_) @@ -106,11 +106,10 @@ module Rule (P : Policy) where -- that offered it. extend : Link → Edge → Weight → Weight extend f e invalid = invalid - extend f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v - ... | no _ | _ | _ = invalid - ... | yes _ | yes _ | _ = invalid - ... | yes _ | no _ | true = invalid - ... | yes _ | no _ | false = valid (route + extend f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v + ... | no _ | _ = invalid + ... | yes _ | yes _ = invalid + ... | yes _ | no _ = if refuses f (i , j) v then invalid else valid (route (draining v ∨ drains f ∨ marks f (i , j) (path v)) (P.penalty f ⊔ penalty v) (P.cost f + cost v) @@ -223,11 +222,12 @@ module Rule (P : Policy) where extend-increasing : ∀ f e r → r ≤ᵣ extend f e r extend-increasing f e invalid = below-invalid - extend-increasing f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v - ... | no _ | _ | _ = below-invalid - ... | yes _ | yes _ | _ = below-invalid - ... | yes _ | no _ | true = below-invalid - ... | yes _ | no _ | false = below + extend-increasing f (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v + ... | no _ | _ = below-invalid + ... | yes _ | yes _ = below-invalid + ... | yes _ | no _ with refuses f (i , j) v + ... | true = below-invalid + ... | false = below (lex-≤ bool O₂ (≤-∨ (draining v) _) λ _ → lex-≤ nat O₃ (ℕ.m≤n⊔m (P.penalty f) (penalty v)) λ _ → lex-≤ nat O₄ (ℕ.m≤n+m (cost v) (P.cost f)) λ _ → @@ -255,11 +255,10 @@ module Rule (P : Policy) where where down-rejects : ∀ e r → extend down e r ≡ invalid down-rejects e invalid = refl - down-rejects (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v | refuses down (i , j) v | down-refuses (i , j) v - ... | no _ | _ | _ | _ = refl - ... | yes _ | yes _ | _ | _ = refl - ... | yes _ | no _ | true | _ = refl - ... | yes _ | no _ | false | () + down-rejects (i , j) (valid v) with (i , j) ⇿? path v | i ∈ₚ? path v + ... | no _ | _ = refl + ... | yes _ | yes _ = refl + ... | yes _ | no _ rewrite down-refuses (i , j) v = refl isRoutingAlgebra : IsRoutingAlgebra algebra isRoutingAlgebra = record @@ -288,23 +287,23 @@ module Rule (P : Policy) where path-reject : ∀ (i j : ℕ) f {r p} → pathOf r ≡ PathI.valid p → (¬ (i , j) PathI.⇿ᵥ p) ⊎ i PathI.∈ᵥₚ p → extend f (i , j) r ≡ invalid path-reject i j f {invalid} () _ - path-reject i j f {valid v} eq bad with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v - ... | no _ | _ | _ = refl - ... | yes _ | yes _ | _ = refl - ... | yes _ | no _ | true = refl - ... | yes ij⇿ | no i∉ | false with valid-injective eq | bad + path-reject i j f {valid v} eq bad with (i , j) ⇿? path v | i ∈ₚ? path v + ... | no _ | _ = refl + ... | yes _ | yes _ = refl + ... | yes ij⇿ | no i∉ with valid-injective eq | bad ... | refl | inj₁ ¬ij⇿ = contradiction ij⇿ ¬ij⇿ ... | refl | inj₂ i∈ = contradiction i∈ i∉ path-accept : ∀ (i j : ℕ) f {r p} → pathOf r ≡ PathI.valid p → extend f (i , j) r ≢ invalid → pathOf (extend f (i , j) r) ≡ PathI.valid ((i , j) ∷ p) path-accept i j f {invalid} () _ - path-accept i j f {valid v} eq ok with (i , j) ⇿? path v | i ∈ₚ? path v | refuses f (i , j) v - ... | no _ | _ | _ = contradiction refl ok - ... | yes _ | yes _ | _ = contradiction refl ok - ... | yes _ | no _ | true = contradiction refl ok - ... | yes _ | no _ | false with valid-injective eq - ... | refl = refl + path-accept i j f {valid v} eq ok with (i , j) ⇿? path v | i ∈ₚ? path v + ... | no _ | _ = contradiction refl ok + ... | yes _ | yes _ = contradiction refl ok + ... | yes _ | no _ with refuses f (i , j) v + ... | true = contradiction refl ok + ... | false with valid-injective eq + ... | refl = refl isPathAlgebra : IsPathAlgebra algebra isPathAlgebra = record diff --git a/rs/moq-net/verify/route-algebra/Route.agda b/rs/moq-net/verify/route-algebra/Route.agda index a57d2c2ff09..8dc5399a27c 100644 --- a/rs/moq-net/verify/route-algebra/Route.agda +++ b/rs/moq-net/verify/route-algebra/Route.agda @@ -103,16 +103,16 @@ record Link : Set where private module L = Link - _∈ᵇ_ : ℕ → List ℕ → Bool - n ∈ᵇ ns = any (n ≡ᵇ_) ns - - -- Whether `floors` hold the session from `a` to `b` numbered `s` closed. - closed : List Floor → Edge × ℕ → Bool - closed fs ((a , b) , s) = any at-or-below fs - where - at-or-below : Floor → Bool - at-or-below (floor n f st se) = - (relay a ≡ᵇ n) ∧ (relay b ≡ᵇ f) ∧ ((start a <ᵇ st) ∨ ((start a ≡ᵇ st) ∧ (s ≤ᵇ se))) +_∈ᵇ_ : ℕ → List ℕ → Bool +n ∈ᵇ ns = any (n ≡ᵇ_) ns + +-- Whether `floors` hold the session from `a` to `b` numbered `s` closed. +closed : List Floor → Edge × ℕ → Bool +closed fs ((a , b) , s) = any at-or-below fs + where + at-or-below : Floor → Bool + at-or-below (floor n f st se) = + (relay a ≡ᵇ n) ∧ (relay b ≡ᵇ f) ∧ ((start a <ᵇ st) ∨ ((start a ≡ᵇ st) ∧ (s ≤ᵇ se))) -- A link refuses a route when it is down, when the route is the neighbour's -- route to itself and the neighbour announces no claim, when the route crossed a From 01dee32135773c918afc82f3a43c877325232199 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 03:55:48 -0800 Subject: [PATCH 05/11] test(moq-net): the next hop in use settles on a best rank, and can leave a neighbour without a route Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/route/tests/algebra.rs | 8 +- rs/moq-net/src/route/tests/mod.rs | 1 + rs/moq-net/src/route/tests/multi.rs | 50 +++-- rs/moq-net/src/route/tests/sticky.rs | 263 ++++++++++++++++++++++++++ 4 files changed, 301 insertions(+), 21 deletions(-) create mode 100644 rs/moq-net/src/route/tests/sticky.rs diff --git a/rs/moq-net/src/route/tests/algebra.rs b/rs/moq-net/src/route/tests/algebra.rs index b8f6d9bca44..f0c299424f2 100644 --- a/rs/moq-net/src/route/tests/algebra.rs +++ b/rs/moq-net/src/route/tests/algebra.rs @@ -35,10 +35,10 @@ fn vectors_path() -> PathBuf { } /// xorshift64, so a seed always draws the same cases. -struct Rng(u64); +pub(super) struct Rng(pub u64); impl Rng { - fn below(&mut self, n: u64) -> u64 { + pub fn below(&mut self, n: u64) -> u64 { self.0 ^= self.0 << 13; self.0 ^= self.0 >> 7; self.0 ^= self.0 << 17; @@ -46,11 +46,11 @@ impl Rng { } /// True one time in `n`. - fn one_in(&mut self, n: u64) -> bool { + pub fn one_in(&mut self, n: u64) -> bool { self.below(n) == 0 } - fn pick(&mut self, items: &[T]) -> T { + pub fn pick(&mut self, items: &[T]) -> T { items[self.below(items.len() as u64) as usize] } } diff --git a/rs/moq-net/src/route/tests/mod.rs b/rs/moq-net/src/route/tests/mod.rs index 24f8df5b806..f8540ff3b28 100644 --- a/rs/moq-net/src/route/tests/mod.rs +++ b/rs/moq-net/src/route/tests/mod.rs @@ -22,6 +22,7 @@ mod residual; mod routing; mod scope; mod search; +mod sticky; use std::{ collections::{BTreeMap, BTreeSet, VecDeque}, diff --git a/rs/moq-net/src/route/tests/multi.rs b/rs/moq-net/src/route/tests/multi.rs index cd297210609..c9159a82699 100644 --- a/rs/moq-net/src/route/tests/multi.rs +++ b/rs/moq-net/src/route/tests/multi.rs @@ -974,37 +974,44 @@ impl Router { } fn reselect_all(&mut self) { - let origins: BTreeSet = self.heard.keys().chain(self.best.keys()).copied().collect(); - for origin in origins { + for origin in self.origins() { self.reselect(origin); } } - /// Pick the route to `origin` and tell every neighbour what changed. - fn reselect(&mut self, origin: Id) { - let current = self.best.get(&origin).map(|best| best.via); - let mut pick: Option<(Best, Order)> = None; + /// The routes to `origin` this node may take from what its neighbours last said. + pub fn candidates(&self, origin: Id) -> Vec> { let here = self.here(); - let mut visited = 0; + let mut out = Vec::new(); for (&via, heard) in self.heard.get(&origin).into_iter().flatten() { - visited += 1; let Some(peer) = self.peers.get(&via) else { continue; }; if heard.ended || (self.tune.agree && !self.agrees(origin, via, &heard.offer)) { continue; } - let Some((offer, suspect)) = here.arrive(&peer.port, peer.draining, &heard.offer) else { - continue; - }; - let mine = Best { via, offer, suspect }; - let key = order(&mine, current); - if pick.as_ref().is_none_or(|(_, best)| key < *best) { - pick = Some((mine, key)); + if let Some((offer, suspect)) = here.arrive(&peer.port, peer.draining, &heard.offer) { + out.push(Best { via, offer, suspect }); } } - self.work += visited; - let pick = pick.map(|(best, _)| best); + out + } + + /// The route this node uses to `origin`. + pub fn best(&self, origin: Id) -> Option<&Best> { + self.best.get(&origin) + } + + /// Every forwarding node this node has heard a route to or uses one to. + pub fn origins(&self) -> BTreeSet { + self.heard.keys().chain(self.best.keys()).copied().collect() + } + + /// Pick the route to `origin` and tell every neighbour what changed. + fn reselect(&mut self, origin: Id) { + let current = self.best.get(&origin).map(|best| best.via); + self.work += self.heard.get(&origin).map_or(0, BTreeMap::len); + let pick = (self.candidates(origin).into_iter()).min_by_key(|best| order(best, current)); if self.best.get(&origin) == pick.as_ref() { return; } @@ -1489,6 +1496,15 @@ impl MultiSim { self.held.insert((from, to)); } + pub fn release(&mut self, from: Node, to: Node) { + self.held.remove(&(from, to)); + } + + /// Whether `a` and `b` have a session open. + pub fn is_up(&self, a: Node, b: Node) -> bool { + self.up.contains(&Self::pair(a, b)) + } + pub fn ready(&self) -> Vec<((Node, Node), usize)> { (self.queues.iter()) .filter(|(key, queue)| !queue.is_empty() && !self.held.contains(key)) diff --git a/rs/moq-net/src/route/tests/sticky.rs b/rs/moq-net/src/route/tests/sticky.rs new file mode 100644 index 00000000000..118ae578b01 --- /dev/null +++ b/rs/moq-net/src/route/tests/sticky.rs @@ -0,0 +1,263 @@ +//! The route rule as the prototype runs it, with the next hop in use ahead of the +//! path length and the neighbour in [`order`](super::multi::order). +//! +//! The route proof (`rs/moq-net/verify/route-algebra`) breaks ties between routes +//! of equal draining, priority, and cost by a fixed order, so it has one fixed +//! point. Staying on the next hop in use makes the choice depend on what came +//! first, which the proof does not cover. `rs/moq-net/verify/README.md` argues on +//! paper that the rule still settles; these tests check it, and show that which +//! of two equal routes a node sits on can change what a neighbour is offered. + +use super::algebra::Rng; +use super::compare::Arm; +use super::multi::{Best, MultiSim, Tie, Tune}; +use super::*; + +/// The rule the epic picked: floor, epoch, batch, drain, and claimed. +const KEPT: Tune = match Arm::KEPT { + Arm::Multi(tune) => tune, + Arm::Path(_) => panic!("the picked rule is the prototype's"), +}; + +/// More deliveries than any network here needs to settle. +const LIMIT: usize = 200_000; + +/// A random network: relays first, then publishers, each relay linked to an +/// earlier one and a few more links besides, costs of 1 or 2 so equal ranks are +/// common, and one link in four marked upstream. +struct Net { + relays: usize, + publishers: usize, + links: Vec<(Node, Node, Metric, Tie)>, +} + +impl Net { + fn draw(rng: &mut Rng) -> Self { + let relays = 4 + rng.below(5) as usize; + let publishers = 1 + rng.below(2) as usize; + let mut links = Vec::new(); + let joined = |a: Node, b: Node, links: &mut Vec<(Node, Node, Metric, Tie)>, rng: &mut Rng| { + if a == b || links.iter().any(|&(x, y, _, _)| (x, y) == (a, b) || (x, y) == (b, a)) { + return; + } + let tie = match rng.below(8) { + 0 | 1 => Tie::Up, + 2 => Tie::Scoped, + _ => Tie::Peer, + }; + links.push((a, b, 1 + rng.below(2), tie)); + }; + for relay in 1..relays { + let earlier = rng.below(relay as u64) as Node; + joined(relay, earlier, &mut links, rng); + } + for _ in 0..relays / 2 { + let (a, b) = (rng.below(relays as u64) as Node, rng.below(relays as u64) as Node); + joined(a, b, &mut links, rng); + } + for publisher in relays..relays + publishers { + for _ in 0..1 + rng.below(2) { + let relay = rng.below(relays as u64) as Node; + if !links.iter().any(|&(x, y, _, _)| (x, y) == (publisher, relay)) { + links.push((publisher, relay, 1, Tie::Peer)); + } + } + } + Self { + relays, + publishers, + links, + } + } + + fn build(&self) -> MultiSim { + let mut net = MultiSim::new(KEPT, self.relays + self.publishers); + for publisher in self.relays..self.relays + self.publishers { + net.client(publisher); + net.publish(publisher, 100 + publisher as Id); + } + for &(a, b, cost, tie) in &self.links { + net.link(a, b, cost, tie); + } + for publisher in self.relays..self.relays + self.publishers { + net.claim(publisher, "live/0", true); + } + net + } +} + +/// Deliver one message at a time from a random queue, reading a burst before +/// answering as `batch` does, until nothing is left. False if it never settles. +fn settle(net: &mut MultiSim, rng: &mut Rng) -> bool { + for _ in 0..LIMIT { + let ready = net.ready(); + if ready.is_empty() { + net.flush(); + if net.ready().is_empty() { + return true; + } + continue; + } + let ((from, to), _) = rng.pick(&ready); + net.deliver(from, to); + if rng.one_in(3) { + net.flush(); + } + } + false +} + +/// Links close and reopen, relays restart or send GOAWAY, all while messages are +/// in flight; then every closed link reopens. +fn churn(net: &mut MultiSim, plan: &Net, rng: &mut Rng) { + let mut down = Vec::new(); + for _ in 0..rng.below(6) { + for _ in 0..rng.below(40) { + let ready = net.ready(); + if ready.is_empty() { + break; + } + let ((from, to), _) = rng.pick(&ready); + net.deliver(from, to); + } + net.flush(); + let relay = rng.below(plan.relays as u64) as Node; + match rng.below(5) { + 0 => { + let links: Vec<_> = (plan.links.iter()) + .filter(|&&(a, b, _, _)| (a == relay || b == relay) && net.is_up(a, b)) + .map(|&(a, b, _, _)| (a, b)) + .collect(); + net.reset(relay); + down.extend(links); + } + 1 => net.goaway(relay), + _ => { + let &(a, b, _, _) = &plan.links[rng.below(plan.links.len() as u64) as usize]; + if net.is_up(a, b) { + net.close(a, b); + down.push((a, b)); + } + } + } + } + for (a, b) in down { + if !net.is_up(a, b) { + net.open(a, b); + } + } +} + +/// Every relay sits on a route of the best draining, priority, and cost among those +/// its neighbours last offered it, and the routes in use form trees: each one's +/// path is its next hop's route with that hop added. +fn check(net: &MultiSim, plan: &Net) -> Result<(), String> { + for node in 0..plan.relays { + let router = net.router(node).expect("a relay"); + for origin in router.origins() { + let candidates = router.candidates(origin); + let best = router.best(origin); + let lowest = candidates.iter().map(Best::rank).min(); + let Some(best) = best else { + if lowest.is_some() { + return Err(format!("{node} uses no route to {origin} of {candidates:?}")); + } + continue; + }; + if !candidates.contains(best) || Some(best.rank()) != lowest { + return Err(format!("{node} uses {best:?} to {origin} of {candidates:?}")); + } + let path = &best.offer.path; + if path.len() > 1 { + let next = net.router(best.via).expect("a relay"); + let theirs = next.best(origin).map(|best| &best.offer.path[..]); + if theirs != Some(&path[..path.len() - 1]) { + return Err(format!("{node}'s route to {origin} is {path:?}; {} uses {theirs:?}", best.via)); + } + } + } + } + Ok(()) +} + +/// The rule as it runs settles under any delivery order, through churn, on a +/// route of the best rank it was offered at every node. Which of two equal routes +/// it settles on varies with the order: printed, for how often that reaches past +/// the node. +#[test] +fn the_next_hop_in_use_settles_on_a_best_rank() { + let (mut settled, mut moved, mut ranked, mut reached) = (0, 0, 0, 0); + for seed in 1..=150 { + let mut rng = Rng(0x9e37_79b9_7f4a_7c15 ^ seed); + let plan = Net::draw(&mut rng); + + let mut net = plan.build(); + churn(&mut net, &plan, &mut rng); + assert!(settle(&mut net, &mut rng), "seed {seed} never settles"); + if let Err(err) = check(&net, &plan) { + panic!("seed {seed} after churn: {err}"); + } + + // The same network twice from cold, in two delivery orders. + let mut runs = Vec::new(); + for _ in 0..2 { + let mut net = plan.build(); + assert!(settle(&mut net, &mut rng), "seed {seed} never settles"); + if let Err(err) = check(&net, &plan) { + panic!("seed {seed}: {err}"); + } + runs.push(net); + } + for node in 0..plan.relays { + let [a, b] = [&runs[0], &runs[1]].map(|net| net.router(node).expect("a relay")); + for origin in a.origins().union(&b.origins()) { + settled += 1; + let [x, y] = [a.best(*origin), b.best(*origin)]; + moved += usize::from(x.map(|x| x.via) != y.map(|y| y.via)); + ranked += usize::from(x.map(Best::rank) != y.map(Best::rank)); + reached += usize::from(x.is_some() != y.is_some()); + } + } + } + println!( + "of {settled} routes settled twice: {moved} on another next hop, {ranked} at another rank, {reached} reachable once" + ); +} + +/// A route learned over an upstream link is marked, and a marked route is never +/// sent over another upstream link. Relay 3 hears two routes of equal rank to +/// relay 0: through 2, over a link it marked upstream, and through 1, over a peer +/// link. The fixed order picks 1, the lower neighbour, and 3 offers it to 4, its +/// own upstream. Staying on the next hop in use keeps whichever came first: if 2's +/// came first, 4 is offered nothing and has no route to 0. +#[test] +fn an_equal_route_in_use_can_leave_a_neighbour_without_one() { + let build = || { + let mut net = MultiSim::new(KEPT, 6); + net.client(5); + net.publish(5, 100); + net.link(5, 0, 1, Tie::Peer); + net.link(0, 1, 1, Tie::Peer); + net.link(0, 2, 1, Tie::Peer); + net.link(3, 2, 1, Tie::Up); + net.link(3, 1, 1, Tie::Peer); + net.link(3, 4, 1, Tie::Up); + net + }; + let origin = hop(0, 0); + let mut rng = Rng(7); + let mut settled = |first: Node, second: Node| { + let mut net = build(); + net.hold(second, 3); + net.claim(5, "live/0", true); + assert!(settle(&mut net, &mut rng)); + assert_eq!(net.router(3).and_then(|r| r.best(origin)).map(|best| best.via), Some(first)); + net.release(second, 3); + assert!(settle(&mut net, &mut rng)); + let via = net.router(3).and_then(|r| r.best(origin)).map(|best| best.via); + let reached = net.router(4).and_then(|r| r.best(origin)).is_some(); + (via, reached) + }; + assert_eq!(settled(1, 2), (Some(1), true), "the fixed order's choice"); + assert_eq!(settled(2, 1), (Some(2), false), "the first heard, kept"); +} From 7a3abe45ae5c1be4f2043506638a2eca8cd985b6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 05:50:10 -0800 Subject: [PATCH 06/11] ci(nightly): type-check the route proof with its pinned Agda Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 19 +++++++++++++++++++ test/justfile | 4 ++++ 2 files changed, 23 insertions(+) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 08f40a14952..8d6192579da 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -31,6 +31,11 @@ name: Nightly # edit no test notices; each edit rebuilds moq-net's tests, about 27 runner-hours # for the full set, so it rotates (see sh/rs/mutants.sh). # +# `route-proof` type-checks the route rule's convergence proof with Agda, about +# two minutes. The Rust side of its binding, the generated `Vectors.agda`, is +# checked current by every PR's tests; the proof itself only changes when the +# rule does, which review checks. +# # `quic-interop` runs moq-quic against other QUIC stacks through the QUIC # Interop Runner, an hour of simulated links per peer, which only a moq-quic # change or a bumped pin moves. @@ -506,6 +511,20 @@ jobs: env: TLA_CACHE: .tmp/tla-cache + route-proof: + name: Route proof (Agda) + runs-on: ubuntu-24.04-arm + timeout-minutes: 30 + steps: + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: ./.github/actions/nix + # No dev shell: the proof brings its own Agda pin (nix/route-proof.nix). + - name: Type-check + run: nix shell --inputs-from . nixpkgs#just --command just test route-proof + # Media QA with a Firefox player against a Chromium fixture. The Chromium # player already runs in interop.yml, nightly and on release PRs. WebKit has # engine defects this cannot pass; see test/interop/README.md. diff --git a/test/justfile b/test/justfile index 72b38b941c5..69e03d465b3 100644 --- a/test/justfile +++ b/test/justfile @@ -315,6 +315,10 @@ resume-model: tla *paths: bash ../sh/tla.sh {{ paths }} +# Type-check the route rule's convergence proof (rs/moq-net/verify/route-algebra) with its own pinned Agda. +route-proof: + nix build ..#route-proof --no-link --print-build-logs + # Prove the route key model, and that each variant breaks the lemmas it names. route-key-model: bash route-key-model.sh From 7b49e3fb9c4b370ed90f64950ce47a41301295bb Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 05:50:10 -0800 Subject: [PATCH 07/11] fix(moq-net): at equal rank, a route with no marked link beats a marked one Decided by the coordinator on 2026-11-16 while the maintainer is away, pending their confirmation. The order is now draining, priority, cost, marked, next hop in use, shorter path, neighbour, in the prototype's `order` and in the Agda algebra (the mark leaves `extra` and sits after cost; the theorem stays --safe with no postulates). Before, a relay holding two routes of equal rank, one learned over an upstream link, kept whichever arrived first, so a neighbour behind its own upstream link was reachable or not by arrival order; the fixed order decided it by neighbour key instead. Sticky sweep, 150 seeds, each network settled twice from cold in two delivery orders, compared at relays that announced in both: before: 1866 routes, 59 on another next hop, 13 at another rank, 13 reachable once after: 2272 routes, 29 on another next hop, 0 at another rank, 0 marked once, 0 reachable once; asserted The 13 came from 2 relays that announced in only one order: `claimed` latches a relay's announcement on its first claim, and a relay with no endpoint gets one across a scoped grant only if it hears the grant before its peer prefers the relay's own echo. A fixture shows it, and that the relay then keeps a route to itself with no claim behind it. Bake-off, every arm and shape, settled results unchanged (right, loops, offline, hops, lasting). Failure transients moved on peered `tiers` only, never `tiers_unpeered`: tiers 15/42 home_dies, every multi arm: route messages +5, claim items +1, unavailable events +1 (KEPT 220->225, 4->5, 19->20) tiers 32/128 home_dies, floor+batch arms: route messages 974->943, claim items 11->6 (KEPT 954->924, 10->6) tiers 32/128 partition, floor+batch arms without claimed: route messages 7549->7588 Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/route/tests/algebra.rs | 15 +- rs/moq-net/src/route/tests/multi.rs | 18 +- rs/moq-net/src/route/tests/sticky.rs | 92 +- .../verify/route-algebra/Accelerate.agda | 12 +- rs/moq-net/verify/route-algebra/Claim.agda | 1 + .../verify/route-algebra/Increasing.agda | 34 +- rs/moq-net/verify/route-algebra/Route.agda | 27 +- rs/moq-net/verify/route-algebra/Vectors.agda | 1324 ++++++++--------- 8 files changed, 798 insertions(+), 725 deletions(-) diff --git a/rs/moq-net/src/route/tests/algebra.rs b/rs/moq-net/src/route/tests/algebra.rs index f0c299424f2..2208bbf7f44 100644 --- a/rs/moq-net/src/route/tests/algebra.rs +++ b/rs/moq-net/src/route/tests/algebra.rs @@ -374,7 +374,7 @@ fn weight(offer: Option<&Offer>) -> String { write!(sessions, "{} ∷ ", pair[1].session).unwrap(); } format!( - "valid (route {} {} {} ({path}[]) ({} , {sessions}[]))", + "valid (route {} {} {} {} ({path}[]) ({sessions}[]))", offer.draining, penalty(offer.priority), offer.cost, @@ -466,13 +466,16 @@ fn vectors() -> String { // Half the pairs offer the same route over the same kind of link, so only the // neighbour breaks the tie. let two = match rng.one_in(2) { - true => (Held { node: b, ..one.0.clone() }, one.1.clone()), + true => ( + Held { + node: b, + ..one.0.clone() + }, + one.1.clone(), + ), false => (held(&mut rng, b), link(&mut rng)), }; - let picked = pick(&[ - (a, cross(&state, &one.1, &one.0)), - (b, cross(&state, &two.1, &two.0)), - ]); + let picked = pick(&[(a, cross(&state, &one.1, &one.0)), (b, cross(&state, &two.1, &two.0))]); write!( out, "\n_ : {}\n ⊕ {}\n ≡ {}\n_ = refl\n", diff --git a/rs/moq-net/src/route/tests/multi.rs b/rs/moq-net/src/route/tests/multi.rs index c9159a82699..6e10d7a5a75 100644 --- a/rs/moq-net/src/route/tests/multi.rs +++ b/rs/moq-net/src/route/tests/multi.rs @@ -183,7 +183,8 @@ impl Here<'_> { } } -/// How a candidate route orders, lower first: rank, then the next hop in use +/// How a candidate route orders, lower first: rank, then one with no marked link +/// on its path, which more neighbours may be sent, then the next hop in use /// (`current`), the shorter path, and the neighbour. pub(super) fn order(best: &Best, current: Option) -> Order { let (draining, priority, cost) = best.rank(); @@ -191,6 +192,7 @@ pub(super) fn order(best: &Best, current: Option) -> Order { draining, priority, cost, + best.offer.marked, current != Some(best.via), best.offer.path.len(), best.via, @@ -326,9 +328,9 @@ impl Default for Known { } } -/// How candidate routes order, lower first: rank, then the next hop in use, the -/// shorter path, and the neighbour. -pub(super) type Order = (bool, Reverse, Metric, bool, usize, N); +/// How candidate routes order, lower first: rank, then unmarked, the next hop in +/// use, the shorter path, and the neighbour. +pub(super) type Order = (bool, Reverse, Metric, bool, bool, usize, N); /// Where a request for a broadcast goes next. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -997,6 +999,11 @@ impl Router { out } + /// Whether it offers a route to itself under `tune.claimed`: it has announced a claim. + pub fn announced(&self) -> bool { + self.announced + } + /// The route this node uses to `origin`. pub fn best(&self, origin: Id) -> Option<&Best> { self.best.get(&origin) @@ -1061,7 +1068,8 @@ impl Router { if best.via == peer { return None; } - best.offer.onward(self.me, self.peers[&best.via].session, to.id, to.port.upstream) + best.offer + .onward(self.me, self.peers[&best.via].session, to.id, to.port.upstream) } fn advertise_to(&mut self, origin: Id, peer: N) { diff --git a/rs/moq-net/src/route/tests/sticky.rs b/rs/moq-net/src/route/tests/sticky.rs index 118ae578b01..b9731439397 100644 --- a/rs/moq-net/src/route/tests/sticky.rs +++ b/rs/moq-net/src/route/tests/sticky.rs @@ -2,11 +2,11 @@ //! path length and the neighbour in [`order`](super::multi::order). //! //! The route proof (`rs/moq-net/verify/route-algebra`) breaks ties between routes -//! of equal draining, priority, and cost by a fixed order, so it has one fixed -//! point. Staying on the next hop in use makes the choice depend on what came -//! first, which the proof does not cover. `rs/moq-net/verify/README.md` argues on -//! paper that the rule still settles; these tests check it, and show that which -//! of two equal routes a node sits on can change what a neighbour is offered. +//! of equal draining, priority, cost, and mark by a fixed order, so it has one +//! fixed point. Staying on the next hop in use makes the choice depend on what +//! came first, which the proof does not cover. `rs/moq-net/verify/README.md` +//! argues on paper that the rule still settles, at every node on the rank and mark +//! the fixed order would give it; these tests check both. use super::algebra::Rng; use super::compare::Arm; @@ -172,7 +172,10 @@ fn check(net: &MultiSim, plan: &Net) -> Result<(), String> { let next = net.router(best.via).expect("a relay"); let theirs = next.best(origin).map(|best| &best.offer.path[..]); if theirs != Some(&path[..path.len() - 1]) { - return Err(format!("{node}'s route to {origin} is {path:?}; {} uses {theirs:?}", best.via)); + return Err(format!( + "{node}'s route to {origin} is {path:?}; {} uses {theirs:?}", + best.via + )); } } } @@ -182,11 +185,14 @@ fn check(net: &MultiSim, plan: &Net) -> Result<(), String> { /// The rule as it runs settles under any delivery order, through churn, on a /// route of the best rank it was offered at every node. Which of two equal routes -/// it settles on varies with the order: printed, for how often that reaches past -/// the node. +/// it settles on varies with the order, but never its rank, its mark, or whether +/// it has one: only the next hop, which no neighbour's offer depends on. What can +/// vary is which relays announce at all (see +/// [`whether_a_relay_announces_hangs_on_arrival_order`]), so routes are compared +/// only to relays that announced in both orders. #[test] fn the_next_hop_in_use_settles_on_a_best_rank() { - let (mut settled, mut moved, mut ranked, mut reached) = (0, 0, 0, 0); + let (mut settled, mut moved, mut ranked, mut marked, mut reached, mut announced) = (0, 0, 0, 0, 0, 0); for seed in 1..=150 { let mut rng = Rng(0x9e37_79b9_7f4a_7c15 ^ seed); let plan = Net::draw(&mut rng); @@ -208,30 +214,77 @@ fn the_next_hop_in_use_settles_on_a_best_rank() { } runs.push(net); } + let both: Vec = (0..plan.relays) + .filter(|&relay| { + let [a, b] = [&runs[0], &runs[1]].map(|net| net.router(relay).expect("a relay").announced()); + announced += usize::from(a != b); + a && b + }) + .map(|relay| hop(relay, 0)) + .collect(); for node in 0..plan.relays { let [a, b] = [&runs[0], &runs[1]].map(|net| net.router(node).expect("a relay")); - for origin in a.origins().union(&b.origins()) { + for origin in both.iter().filter(|&&origin| origin != hop(node, 0)) { settled += 1; let [x, y] = [a.best(*origin), b.best(*origin)]; moved += usize::from(x.map(|x| x.via) != y.map(|y| y.via)); ranked += usize::from(x.map(Best::rank) != y.map(Best::rank)); + marked += usize::from(x.map(|x| x.offer.marked) != y.map(|y| y.offer.marked)); reached += usize::from(x.is_some() != y.is_some()); } } } println!( - "of {settled} routes settled twice: {moved} on another next hop, {ranked} at another rank, {reached} reachable once" + "of {settled} routes settled twice: {moved} on another next hop, {ranked} at another rank, {marked} marked once, {reached} reachable once; {announced} relays announced in one order only" ); + assert_eq!((ranked, marked, reached), (0, 0, 0)); + assert!(moved > 0, "no two orders settled on different next hops"); +} + +/// Under `claimed` a relay offers a route to itself from its first claim on, for +/// good. Relay 2 has no endpoint: it can only announce a claim relay 1 grants it. +/// Relay 1 grants its closest claim, unless that is the one relay 2 granted it. 2's +/// grant, over 2's cheap route to 0, beats 1's own dear route. If 2's grant reaches +/// 1 first, 1 never grants 2 anything and 2 never announces. If 1 hears 0's claim +/// first, it grants it to 2, which announces; 1 then takes 2's cheaper grant and +/// withdraws its own, and 2 keeps a route to itself with no claim behind it. +#[test] +fn whether_a_relay_announces_hangs_on_arrival_order() { + let build = || { + let mut net = MultiSim::new(KEPT, 4); + net.client(3); + net.publish(3, 100); + net.link(3, 0, 1, Tie::Peer); + net.link(0, 2, 1, Tie::Peer); + net.link(0, 1, 3, Tie::Peer); + net.link(1, 2, 1, Tie::Scoped); + net + }; + let mut rng = Rng(11); + let mut settled = |late: (Node, Node)| { + let mut net = build(); + net.hold(late.0, late.1); + net.claim(3, "live/0", true); + assert!(settle(&mut net, &mut rng)); + net.release(late.0, late.1); + assert!(settle(&mut net, &mut rng)); + let relay = net.router(2).expect("a relay"); + let claimed = relay.step(hop(2, 0), &(100, p("live/0"))).is_some(); + let routed = net.router(0).expect("a relay").best(hop(2, 0)).is_some(); + (relay.announced(), claimed, routed) + }; + assert_eq!(settled((0, 1)), (false, false, false), "2's grant first"); + assert_eq!(settled((2, 1)), (true, false, true), "0's claim first at 1"); } /// A route learned over an upstream link is marked, and a marked route is never /// sent over another upstream link. Relay 3 hears two routes of equal rank to /// relay 0: through 2, over a link it marked upstream, and through 1, over a peer -/// link. The fixed order picks 1, the lower neighbour, and 3 offers it to 4, its -/// own upstream. Staying on the next hop in use keeps whichever came first: if 2's -/// came first, 4 is offered nothing and has no route to 0. +/// link. Were the mark below the next hop in use, 3 would keep whichever came +/// first, and with 2's first 4 would be offered nothing. Unmarked first, 3 moves to +/// 1's route whichever came first, and offers it to 4, its own upstream. #[test] -fn an_equal_route_in_use_can_leave_a_neighbour_without_one() { +fn an_equal_route_in_use_never_leaves_a_neighbour_without_one() { let build = || { let mut net = MultiSim::new(KEPT, 6); net.client(5); @@ -251,13 +304,16 @@ fn an_equal_route_in_use_can_leave_a_neighbour_without_one() { net.hold(second, 3); net.claim(5, "live/0", true); assert!(settle(&mut net, &mut rng)); - assert_eq!(net.router(3).and_then(|r| r.best(origin)).map(|best| best.via), Some(first)); + assert_eq!( + net.router(3).and_then(|r| r.best(origin)).map(|best| best.via), + Some(first) + ); net.release(second, 3); assert!(settle(&mut net, &mut rng)); let via = net.router(3).and_then(|r| r.best(origin)).map(|best| best.via); let reached = net.router(4).and_then(|r| r.best(origin)).is_some(); (via, reached) }; - assert_eq!(settled(1, 2), (Some(1), true), "the fixed order's choice"); - assert_eq!(settled(2, 1), (Some(2), false), "the first heard, kept"); + assert_eq!(settled(1, 2), (Some(1), true), "the unmarked route first"); + assert_eq!(settled(2, 1), (Some(1), true), "the marked route first"); } diff --git a/rs/moq-net/verify/route-algebra/Accelerate.agda b/rs/moq-net/verify/route-algebra/Accelerate.agda index 7edfef7a320..1e53eba1e2c 100644 --- a/rs/moq-net/verify/route-algebra/Accelerate.agda +++ b/rs/moq-net/verify/route-algebra/Accelerate.agda @@ -102,8 +102,8 @@ module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where Sound : Weight → Set Sound invalid = ⊤ - Sound (valid x) = length (proj₂ (extra x)) ≡ length (path x) × - All (Holds (draining x)) (zip (path x) (proj₂ (extra x))) + Sound (valid x) = length (extra x) ≡ length (path x) × + All (Holds (draining x)) (zip (path x) (extra x)) private weaken : ∀ {d d′} → (d ≡ true → d′ ≡ true) → ∀ {z} → Holds d z → Holds d′ z @@ -180,13 +180,13 @@ module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where ... | false = named-drained i k p ss (ℕ.suc-injective len) hs named -- A link of A refuses a sound route exactly when `plain` does. - same-refusal : ∀ i k x → All (Holds (draining x)) (zip (path x) (proj₂ (extra x))) → + same-refusal : ∀ i k x → All (Holds (draining x)) (zip (path x) (extra x)) → refuses (A i k) (toℕ i , toℕ k) x ≡ refuses (plain i k) (toℕ i , toℕ k) x - same-refusal i k x holds = trans (cong prefix (floors-silent i k _ holds)) (sym (cong prefix (no-floor (zip (path x) (proj₂ (extra x)))))) + same-refusal i k x holds = trans (cong prefix (floors-silent i k _ holds)) (sym (cong prefix (no-floor (zip (path x) (extra x))))) where prefix : Bool → Bool prefix b = not (Link.up (A i k)) ∨ (null (path x) ∧ not (Link.claimed (A i k))) - ∨ (proj₁ (extra x) ∧ Link.marked-there (A i k)) ∨ (max-hops ≤ᵇ suc (length (path x))) ∨ b + ∨ (marked x ∧ Link.marked-there (A i k)) ∨ (max-hops ≤ᵇ suc (length (path x))) ∨ b -- One step across a link of A takes a sound route as `plain` does. neutral : ∀ i k w → Sound w → extend (A i k) (toℕ i , toℕ k) w ≡ extend (plain i k) (toℕ i , toℕ k) w @@ -197,7 +197,7 @@ module _ {n : ℕ} (A : AdjacencyMatrix algebra n) where ... | yes _ | yes _ = refl ... | yes _ | no _ rewrite same-refusal i k x holds with refuses (plain i k) (toℕ i , toℕ k) x in eq ... | true = refl - ... | false rewrite no-drain (map proj₂ (path x)) = cong (λ d → valid (route d _ _ _ _)) drained + ... | false rewrite no-drain (map proj₂ (path x)) = cong (λ d → valid (route d _ _ _ _ _)) drained where up = refuses-up (plain i k) (toℕ i , toℕ k) x eq -- What the drains add, given the route is already draining where they would. diff --git a/rs/moq-net/verify/route-algebra/Claim.agda b/rs/moq-net/verify/route-algebra/Claim.agda index 7e2e4f892a4..399b581db84 100644 --- a/rs/moq-net/verify/route-algebra/Claim.agda +++ b/rs/moq-net/verify/route-algebra/Claim.agda @@ -53,6 +53,7 @@ policy = record ; penalty = S.penalty ; drains = S.drains ; marks = λ _ _ _ → false + ; marked = λ _ → false ; refuses = λ f _ _ → not (S.up f) ; down-refuses = λ _ _ → refl ; tag = λ _ _ → tt diff --git a/rs/moq-net/verify/route-algebra/Increasing.agda b/rs/moq-net/verify/route-algebra/Increasing.agda index 5e547bf5e83..f16fb78fff7 100644 --- a/rs/moq-net/verify/route-algebra/Increasing.agda +++ b/rs/moq-net/verify/route-algebra/Increasing.agda @@ -2,13 +2,14 @@ -- The algebra both levels of the route rule share, and the theorem it buys. -- -- A route is invalid or carries whether it is draining, a penalty (the lowest --- priority on its path, counted down from the highest), a cost, its path, and --- whatever else a level carries in `extra`. Routes rank by draining, then --- penalty, then cost, then the shorter path, then a fixed order on paths, then --- `extra`. Crossing a link (`extend`) refuses a route whose path does not start --- at the link's far end or already names its near end, refuses whatever the --- link's own filter refuses, and otherwise can only make the route draining, raise --- its penalty, add to its cost, and prepend the link to its path. +-- priority on its path, counted down from the highest), a cost, whether a marked +-- link is on its path, its path, and whatever else a level carries in `extra`. +-- Routes rank by draining, then penalty, then cost, then unmarked before marked, +-- then the shorter path, then a fixed order on paths, then `extra`. Crossing a +-- link (`extend`) refuses a route whose path does not start at the link's far end +-- or already names its near end, refuses whatever the link's own filter refuses, +-- and otherwise can only make the route draining, raise its penalty, add to its +-- cost, mark it, and prepend the link to its path. -- -- Any such algebra is an increasing path algebra, so Daggitt and Griffin's -- Theorem 5 applies: on every network, from every state, under every schedule @@ -62,6 +63,7 @@ record Valid : Set where draining : Bool penalty : ℕ cost : ℕ + marked : Bool path : Path extra : E @@ -73,7 +75,7 @@ data Weight : Set where -- The route a node has to itself. trivial : Weight -trivial = valid (route false 0 0 [] e₀) +trivial = valid (route false 0 0 false [] e₀) ------------------------------------------------------------------------ -- What crossing a link does @@ -90,6 +92,8 @@ record Policy : Set₁ where -- Whether the receiver ranks the route draining, from the link (near end, -- far end) and the path as offered. marks : Link → Edge → Path → Bool + -- Whether the link marks every route that crosses it. + marked : Link → Bool -- Whether the link refuses the route, from the link and the route as offered. refuses : Link → Edge → Valid → Bool down-refuses : ∀ e v → refuses down e v ≡ true @@ -113,6 +117,7 @@ module Rule (P : Policy) where (draining v ∨ drains f ∨ marks f (i , j) (path v)) (P.penalty f ⊔ penalty v) (P.cost f + cost v) + (marked v ∨ P.marked f) ((i , j) ∷ path v) (tag f (extra v))) @@ -120,18 +125,19 @@ module Rule (P : Policy) where -- The order private - key : Valid → Bool × ℕ × ℕ × Path × E - key v = draining v , penalty v , cost v , path v , extra v + key : Valid → Bool × ℕ × ℕ × Bool × Path × E + key v = draining v , penalty v , cost v , marked v , path v , extra v - O₄ = lex (shortlex OP) OE + O₅ = lex (shortlex OP) OE + O₄ = lex bool O₅ O₃ = lex nat O₄ O₂ = lex nat O₃ - OK : Ordered (Bool × ℕ × ℕ × Path × E) + OK : Ordered (Bool × ℕ × ℕ × Bool × Path × E) OK = lex bool O₂ OV : Ordered Valid - OV = keyed key (λ eq → cong (λ (d , q , c , p , x) → route d q c p x) eq) OK + OV = keyed key (λ eq → cong (λ (d , q , c , m , p , x) → route d q c m p x) eq) OK private module OV = Ordered OV @@ -211,6 +217,7 @@ module Rule (P : Policy) where (lex-≤ bool O₂ (Bool.≤-minimum (draining w)) λ _ → lex-≤ nat O₃ z≤n λ _ → lex-≤ nat O₄ z≤n λ _ → + lex-≤ bool O₅ (Bool.≤-minimum (marked w)) λ _ → lex-≤ (shortlex OP) OE ([]-least (path w)) λ _ → e₀-least (extra w)) @@ -231,6 +238,7 @@ module Rule (P : Policy) where (lex-≤ bool O₂ (≤-∨ (draining v) _) λ _ → lex-≤ nat O₃ (ℕ.m≤n⊔m (P.penalty f) (penalty v)) λ _ → lex-≤ nat O₄ (ℕ.m≤n+m (cost v) (P.cost f)) λ _ → + lex-≤ bool O₅ (≤-∨ (marked v) _) λ _ → lex-≤ (shortlex OP) OE (shortlex-∷ OP (i , j) (path v)) λ eq → contradiction eq p≉i∷p) diff --git a/rs/moq-net/verify/route-algebra/Route.agda b/rs/moq-net/verify/route-algebra/Route.agda index 8dc5399a27c..cd083dc333c 100644 --- a/rs/moq-net/verify/route-algebra/Route.agda +++ b/rs/moq-net/verify/route-algebra/Route.agda @@ -8,9 +8,8 @@ -- since the floor files a closed session by relays and orders it by start. -- -- A route at node i is what i would offer: its path names i first, then i's next --- hop, and so on to the forwarding node it leads to. `extra` carries whether a --- marked link is on the path and, beside each link, the session the nearer node --- holds it on. The link from i to j carries what i and j hold about it and what i +-- hop, and so on to the forwarding node it leads to. `extra` carries, beside each +-- link, the session the nearer node holds it on. The link from i to j carries what i and j hold about it and what i -- knows: closed sessions (floors) and nodes named draining. -------------------------------------------------------------------------------- @@ -41,22 +40,19 @@ max-hops = 32 ------------------------------------------------------------------------ -- What a route carries beyond its rank and path --- A marked link is on the path, and the session beside each link. +-- The session beside each link. Extra : Set -Extra = Bool × List ℕ +Extra = List ℕ OE : Ordered Extra -OE = lex bool (list nat) +OE = list nat e₀ : Extra -e₀ = false , [] +e₀ = [] e₀-least : ∀ e → Ordered._≤_ OE e₀ e -e₀-least (m , ss) = lex-≤ bool (list nat) (Bool.≤-minimum m) λ _ → least ss - where - least : ∀ ss → Ordered._≤_ (list nat) [] ss - least [] = base _ - least (_ ∷ _) = halt +e₀-least [] = base _ +e₀-least (_ ∷ _) = halt -- Among equal ranks and lengths, by the neighbour: its relay, then its start. -- No two candidates at one node share a neighbour, so the rest of the path @@ -122,9 +118,9 @@ refuses : Link → Edge → Valid → Bool refuses f _ v = not (L.up f) ∨ (null (path v) ∧ not (L.claimed f)) - ∨ (proj₁ (extra v) ∧ L.marked-there f) + ∨ (marked v ∧ L.marked-there f) ∨ (max-hops ≤ᵇ suc (length (path v))) - ∨ any (closed (L.floors f)) (zip (path v) (proj₂ (extra v))) + ∨ any (closed (L.floors f)) (zip (path v) (extra v)) -- The receiver ranks a route draining when it names a node known draining. marks : Link → Edge → Path → Bool @@ -138,9 +134,10 @@ policy = record ; penalty = L.penalty ; drains = L.drains ; marks = marks + ; marked = L.marked-here ; refuses = refuses ; down-refuses = λ _ _ → refl - ; tag = λ f (m , ss) → (m ∨ L.marked-here f) , (L.session f ∷ ss) + ; tag = λ f ss → L.session f ∷ ss } open Rule policy public diff --git a/rs/moq-net/verify/route-algebra/Vectors.agda b/rs/moq-net/verify/route-algebra/Vectors.agda index 356ba32218d..b1a6ccd3708 100644 --- a/rs/moq-net/verify/route-algebra/Vectors.agda +++ b/rs/moq-net/verify/route-algebra/Vectors.agda @@ -10,1412 +10,1412 @@ open import Relation.Binary.PropositionalEquality using (_≡_; refl) open import Sim -_ : extend (link true 2 0 false (1006 ∷ []) ([]) false false true 1) (1000 , 1003) (valid (route true 128 2 ((1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 128 4 ((1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false (1006 ∷ []) ([]) false false true 1) (1000 , 1003) (valid (route true 128 2 false ((1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 128 4 false ((1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 true (1002 ∷ []) (floor 0 2 1 2 ∷ floor 2 0 1 2 ∷ []) true false false 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 true (1002 ∷ []) (floor 0 2 1 2 ∷ floor 2 0 1 2 ∷ []) true false false 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 255 true (1001 ∷ []) ([]) true false true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 1 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 1 255 true (1001 ∷ []) ([]) true false true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 1 true ((1000 , 2004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 128 true (1005 ∷ []) (floor 5 5 1 1 ∷ []) false true false 2) (1000 , 1001) (valid (route true 0 10 ((1001 , 1004) ∷ (1004 , 1000) ∷ (1000 , 1002) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 1 128 true (1005 ∷ []) (floor 5 5 1 1 ∷ []) false true false 2) (1000 , 1001) (valid (route true 0 10 false ((1001 , 1004) ∷ (1004 , 1000) ∷ (1000 , 1002) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (1004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 3 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 3 0 false (1004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 3 false ((1000 , 1003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) (floor 3 1 1 1 ∷ floor 6 1 1 3 ∷ floor 6 4 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 1 ((1000 , 1005) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 1 128 false (1004 ∷ []) (floor 3 1 1 1 ∷ floor 6 1 1 3 ∷ floor 6 4 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 1 false ((1000 , 1005) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2002 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 10 ((1006 , 1000) ∷ (1000 , 1001) ∷ []) (false , 2 ∷ 2 ∷ []))) +_ : extend (link true 1 128 false (2002 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 10 false ((1006 , 1000) ∷ (1000 , 1001) ∷ []) (2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 122 false (2001 ∷ 2005 ∷ []) ([]) false true true 2) (1000 , 2005) (valid (route true 122 6 ((2005 , 1004) ∷ (1004 , 1003) ∷ []) (false , 1 ∷ 3 ∷ []))) - ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 1004) ∷ (1004 , 1003) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false (2001 ∷ 2005 ∷ []) ([]) false true true 2) (1000 , 2005) (valid (route true 122 6 false ((2005 , 1004) ∷ (1004 , 1003) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route true 122 8 false ((1000 , 2005) ∷ (2005 , 1004) ∷ (1004 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2006 ∷ []) (floor 0 1 1 1 ∷ []) false false false 3) (1000 , 1002) (valid (route true 128 10 ((1002 , 2004) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 128 11 ((1000 , 1002) ∷ (1002 , 2004) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ : extend (link true 1 122 false (2006 ∷ []) (floor 0 1 1 1 ∷ []) false false false 3) (1000 , 1002) (valid (route true 128 10 false ((1002 , 2004) ∷ []) (1 ∷ []))) + ≡ valid (route true 128 11 false ((1000 , 1002) ∷ (1002 , 2004) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1004 ∷ []) ([]) true false true 3) (1000 , 2001) (valid (route false 128 1 ((2001 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 4 128 false (1004 ∷ []) ([]) true false true 3) (1000 , 2001) (valid (route false 128 1 false ((2001 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 true (1001 ∷ 1003 ∷ []) ([]) true true true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 3 ((1000 , 2002) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 3 255 true (1001 ∷ 1003 ∷ []) ([]) true true true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 3 true ((1000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1004 ∷ []) (floor 1 5 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 122 0 ((1004 , 1015) ∷ (1015 , 2021) ∷ (2021 , 1008) ∷ (1008 , 2037) ∷ (2037 , 2020) ∷ (2020 , 1040) ∷ (1040 , 1025) ∷ (1025 , 2028) ∷ (2028 , 1024) ∷ (1024 , 1013) ∷ (1013 , 2001) ∷ (2001 , 2010) ∷ (2010 , 2014) ∷ (2014 , 1032) ∷ (1032 , 1012) ∷ (1012 , 1038) ∷ (1038 , 1017) ∷ (1017 , 2007) ∷ (2007 , 2022) ∷ (2022 , 1034) ∷ (1034 , 2031) ∷ (2031 , 1009) ∷ (1009 , 1019) ∷ (1019 , 1026) ∷ (1026 , 1005) ∷ (1005 , 1027) ∷ (1027 , 1006) ∷ (1006 , 1036) ∷ (1036 , 1016) ∷ (1016 , 1002) ∷ (1002 , 1003) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) +_ : extend (link true 1 127 true (1004 ∷ []) (floor 1 5 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 122 0 true ((1004 , 1015) ∷ (1015 , 2021) ∷ (2021 , 1008) ∷ (1008 , 2037) ∷ (2037 , 2020) ∷ (2020 , 1040) ∷ (1040 , 1025) ∷ (1025 , 2028) ∷ (2028 , 1024) ∷ (1024 , 1013) ∷ (1013 , 2001) ∷ (2001 , 2010) ∷ (2010 , 2014) ∷ (2014 , 1032) ∷ (1032 , 1012) ∷ (1012 , 1038) ∷ (1038 , 1017) ∷ (1017 , 2007) ∷ (2007 , 2022) ∷ (2022 , 1034) ∷ (1034 , 2031) ∷ (2031 , 1009) ∷ (1009 , 1019) ∷ (1019 , 1026) ∷ (1026 , 1005) ∷ (1005 , 1027) ∷ (1027 , 1006) ∷ (1006 , 1036) ∷ (1036 , 1016) ∷ (1016 , 1002) ∷ (1002 , 1003) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 true (1006 ∷ []) ([]) false true false 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 4 122 true (1006 ∷ []) ([]) false true false 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (2002 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route false 0 11 ((1004 , 2005) ∷ (2005 , 1003) ∷ []) (false , 3 ∷ 2 ∷ []))) - ≡ valid (route false 122 14 ((1000 , 1004) ∷ (1004 , 2005) ∷ (2005 , 1003) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 3 122 false (2002 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route false 0 11 false ((1004 , 2005) ∷ (2005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) + ≡ valid (route false 122 14 false ((1000 , 1004) ∷ (1004 , 2005) ∷ (2005 , 1003) ∷ []) (1 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 122 true (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 127 3 ((2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (true , 3 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 127 7 ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 122 true (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 127 3 true ((2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 127 7 true ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 2001) ∷ (2001 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1006 ∷ 2003 ∷ []) (floor 6 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 122 1 ((2002 , 2003) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 122 5 ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (true , 1 ∷ 3 ∷ [])) +_ : extend (link true 4 0 false (1006 ∷ 2003 ∷ []) (floor 6 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 122 1 false ((2002 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route true 122 5 true ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 true (1005 ∷ 1006 ∷ []) (floor 3 1 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 3 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 3 127 true (1005 ∷ 1006 ∷ []) (floor 3 1 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 3 false ((1000 , 1003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 5 6 1 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 3 ((1000 , 2003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 5 6 1 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 3 false ((1000 , 2003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 4 3 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 3 ∷ []) true true true 3) (1000 , 1003) (valid (route false 127 1 ((1003 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1004) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 4 255 false ([]) (floor 4 3 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 3 ∷ []) true true true 3) (1000 , 1003) (valid (route false 127 1 true ((1003 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1004) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 true (1001 ∷ []) (floor 0 5 1 3 ∷ []) false false true 2) (1000 , 2003) (valid (route true 0 11 ((2003 , 1000) ∷ []) (false , 2 ∷ []))) +_ : extend (link true 3 127 true (1001 ∷ []) (floor 0 5 1 3 ∷ []) false false true 2) (1000 , 2003) (valid (route true 0 11 false ((2003 , 1000) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 true (2001 ∷ []) (floor 1 2 1 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 122 4 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 4 122 true (2001 ∷ []) (floor 1 2 1 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 122 4 false ((1000 , 1006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 255 true ([]) (floor 3 4 2 2 ∷ []) true false false 3) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 255 true ([]) (floor 3 4 2 2 ∷ []) true false false 3) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route false 0 0 ((2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route true 0 2 ((1000 , 2004) ∷ (2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route false 0 0 false ((2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route true 0 2 false ((1000 , 2004) ∷ (2004 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (2004 ∷ []) (floor 2 5 1 2 ∷ floor 4 1 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 3 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 122 false (2004 ∷ []) (floor 2 5 1 2 ∷ floor 4 1 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 3 false ((1000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ floor 1 5 1 0 ∷ []) true true false 1) (1000 , 2001) (valid (route false 122 3 ((2001 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ floor 1 5 1 0 ∷ []) true true false 1) (1000 , 2001) (valid (route false 122 3 false ((2001 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 false (1004 ∷ []) ([]) true false true 3) (1000 , 2006) (valid (route false 122 3 ((2006 , 1003) ∷ (1003 , 1000) ∷ []) (true , 3 ∷ 3 ∷ []))) +_ : extend (link true 4 0 false (1004 ∷ []) ([]) true false true 3) (1000 , 2006) (valid (route false 122 3 true ((2006 , 1003) ∷ (1003 , 1000) ∷ []) (3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 128 true (2002 ∷ []) (floor 2 1 1 0 ∷ []) false true true 2) (1000 , 2005) (valid (route true 255 9 ((2005 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 1 128 true (2002 ∷ []) (floor 2 1 1 0 ∷ []) false true true 2) (1000 , 2005) (valid (route true 255 9 true ((2005 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1001) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) (floor 5 2 1 1 ∷ []) true false true 1) (1000 , 1004) (valid (route false 255 10 ((1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 ((1000 , 1004) ∷ (1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 5 2 1 1 ∷ []) true false true 1) (1000 , 1004) (valid (route false 255 10 false ((1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 true ((1000 , 1004) ∷ (1004 , 1001) ∷ (1001 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2002) ∷ []) (1 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1004 ∷ 2003 ∷ []) (floor 1 2 2 0 ∷ floor 3 6 2 3 ∷ []) true false true 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 0 4 ((1000 , 2003) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 4 0 false (1004 ∷ 2003 ∷ []) (floor 1 2 2 0 ∷ floor 3 6 2 3 ∷ []) true false true 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 0 4 true ((1000 , 2003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 0 4 2 2 ∷ floor 6 1 1 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 11 ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 0 4 2 2 ∷ floor 6 1 1 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 11 false ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1003 ∷ 1006 ∷ []) (floor 0 2 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 128 10 ((2005 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 3 255 false (1003 ∷ 1006 ∷ []) (floor 0 2 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 128 10 true ((2005 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2002) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 255 false (2006 ∷ []) (floor 1 5 2 3 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 2 ((1000 , 2001) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 255 false (2006 ∷ []) (floor 1 5 2 3 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 2 false ((1000 , 2001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 3 ((2001 , 2006) ∷ (2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1000) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 2 0 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 3 false ((2001 , 2006) ∷ (2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1000) ∷ []) (3 ∷ 2 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) ([]) true false false 3) (1000 , 1005) (valid (route false 128 5 ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route false 128 6 ((1000 , 1005) ∷ (1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 127 false ([]) ([]) true false false 3) (1000 , 1005) (valid (route false 128 5 true ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route false 128 6 true ((1000 , 1005) ∷ (1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 2 1 3 ∷ []) false true true 2) (1000 , 2006) (valid (route false 0 9 ((2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 128 10 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 2 1 3 ∷ []) false true true 2) (1000 , 2006) (valid (route false 0 9 false ((2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (3 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 128 10 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2003) ∷ (2003 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 255 false (2006 ∷ []) (floor 0 5 2 3 ∷ floor 3 1 2 1 ∷ floor 6 5 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 1 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 1 255 false (2006 ∷ []) (floor 0 5 2 3 ∷ floor 3 1 2 1 ∷ floor 6 5 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 1 false ((1000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false false 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 2 128 true ([]) ([]) false false false 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (1005 ∷ []) ([]) false false true 1) (1000 , 1002) (valid (route false 122 3 ((1002 , 2002) ∷ (2002 , 2001) ∷ []) (false , 1 ∷ 3 ∷ []))) - ≡ valid (route false 127 6 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 3 127 false (1005 ∷ []) ([]) false false true 1) (1000 , 1002) (valid (route false 122 3 false ((1002 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route false 127 6 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2001) ∷ []) (1 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 122 false (1001 ∷ 1004 ∷ []) ([]) true false true 2) (1000 , 1002) (valid (route true 122 1 ((1002 , 1006) ∷ (1006 , 2002) ∷ []) (false , 3 ∷ 1 ∷ []))) - ≡ valid (route true 122 5 ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 4 122 false (1001 ∷ 1004 ∷ []) ([]) true false true 2) (1000 , 1002) (valid (route true 122 1 false ((1002 , 1006) ∷ (1006 , 2002) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route true 122 5 true ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1002 ∷ 2006 ∷ []) (floor 6 0 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 4 ((2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 122 5 ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 122 false (1002 ∷ 2006 ∷ []) (floor 6 0 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 4 false ((2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 122 5 false ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2002) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1002 ∷ 2004 ∷ []) (floor 5 6 2 3 ∷ floor 6 5 2 3 ∷ []) false false true 2) (1000 , 2004) (valid (route true 127 3 ((2004 , 2002) ∷ (2002 , 1005) ∷ (1005 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 2 0 false (1002 ∷ 2004 ∷ []) (floor 5 6 2 3 ∷ floor 6 5 2 3 ∷ []) false false true 2) (1000 , 2004) (valid (route true 127 3 false ((2004 , 2002) ∷ (2002 , 1005) ∷ (1005 , 1006) ∷ []) (2 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 2 1 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 3 2 0 ∷ floor 5 1 2 1 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (1003 ∷ 2002 ∷ []) (floor 3 6 1 3 ∷ floor 5 1 2 3 ∷ floor 6 4 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 127 10 ((1005 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 3 ∷ []))) +_ : extend (link true 3 127 false (1003 ∷ 2002 ∷ []) (floor 3 6 1 3 ∷ floor 5 1 2 3 ∷ floor 6 4 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 127 10 false ((1005 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (1005 ∷ []) (floor 0 0 2 1 ∷ floor 1 3 1 3 ∷ floor 4 1 1 2 ∷ []) false false false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 0 false (1005 ∷ []) (floor 0 0 2 1 ∷ floor 1 3 1 3 ∷ floor 4 1 1 2 ∷ []) false false false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 255 true (1001 ∷ []) (floor 1 3 1 2 ∷ floor 6 5 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 4 ((1000 , 1005) ∷ []) (true , 3 ∷ [])) +_ : extend (link true 4 255 true (1001 ∷ []) (floor 1 3 1 2 ∷ floor 6 5 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 4 true ((1000 , 1005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 128 false (1005 ∷ 1006 ∷ []) (floor 1 1 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 1) (1000 , 2003) (valid (route false 122 7 ((2003 , 1003) ∷ (1003 , 1001) ∷ []) (false , 2 ∷ 2 ∷ []))) - ≡ valid (route false 128 9 ((1000 , 2003) ∷ (2003 , 1003) ∷ (1003 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 2 128 false (1005 ∷ 1006 ∷ []) (floor 1 1 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 1) (1000 , 2003) (valid (route false 122 7 false ((2003 , 1003) ∷ (1003 , 1001) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route false 128 9 true ((1000 , 2003) ∷ (2003 , 1003) ∷ (1003 , 1001) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 1 2 2 1 ∷ floor 6 1 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 2 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 2 255 false ([]) (floor 1 2 2 1 ∷ floor 6 1 2 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 2 false ((1000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 3 5 2 0 ∷ floor 5 4 2 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 2 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 128 false ([]) (floor 3 5 2 0 ∷ floor 5 4 2 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 2 false ((1000 , 1003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 128 false (1004 ∷ 1006 ∷ []) (floor 0 3 1 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 1 ((2004 , 2005) ∷ (2005 , 1001) ∷ []) (false , 1 ∷ 2 ∷ []))) - ≡ valid (route false 128 4 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 128 false (1004 ∷ 1006 ∷ []) (floor 0 3 1 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 1 false ((2004 , 2005) ∷ (2005 , 1001) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route false 128 4 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) (floor 1 0 2 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 false ([]) (floor 1 0 2 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 0 true (2004 ∷ []) ([]) false false false 2) (1000 , 1002) (valid (route false 122 1 ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route true 122 2 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 0 true (2004 ∷ []) ([]) false false false 2) (1000 , 1002) (valid (route false 122 1 false ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (2 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route true 122 2 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 2001) ∷ []) (2 ∷ 2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2001 ∷ 2003 ∷ []) (floor 3 5 2 1 ∷ floor 4 2 2 0 ∷ floor 6 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 2 ((1000 , 2006) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 128 false (2001 ∷ 2003 ∷ []) (floor 3 5 2 1 ∷ floor 4 2 2 0 ∷ floor 6 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 2 false ((1000 , 2006) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 128 false (2001 ∷ []) (floor 3 3 1 2 ∷ []) true false true 1) (1000 , 2006) (valid (route false 122 0 ((2006 , 2003) ∷ (2003 , 2004) ∷ []) (false , 2 ∷ 3 ∷ []))) - ≡ valid (route false 128 3 ((1000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2004) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 128 false (2001 ∷ []) (floor 3 3 1 2 ∷ []) true false true 1) (1000 , 2006) (valid (route false 122 0 false ((2006 , 2003) ∷ (2003 , 2004) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route false 128 3 true ((1000 , 2006) ∷ (2006 , 2003) ∷ (2003 , 2004) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 2005 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ []) true false true 3) (1000 , 1003) (valid (route false 127 0 ((1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 128 4 ((1000 , 1003) ∷ (1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (true , 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (1003 ∷ 2005 ∷ []) (floor 2 2 2 2 ∷ floor 4 0 1 3 ∷ []) true false true 3) (1000 , 1003) (valid (route false 127 0 false ((1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 128 4 true ((1000 , 1003) ∷ (1003 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1003 ∷ 1005 ∷ []) (floor 5 4 1 1 ∷ []) false false true 1) (1000 , 2006) (valid (route false 127 8 ((2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 9 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (false , 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 255 false (1003 ∷ 1005 ∷ []) (floor 5 4 1 1 ∷ []) false false true 1) (1000 , 2006) (valid (route false 127 8 false ((2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 9 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1004 ∷ []) (floor 2 1 2 3 ∷ []) false false true 1) (1000 , 1006) (valid (route false 122 2 ((1006 , 2002) ∷ []) (true , 2 ∷ []))) - ≡ valid (route false 122 4 ((1000 , 1006) ∷ (1006 , 2002) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ : extend (link true 2 0 false (1004 ∷ []) (floor 2 1 2 3 ∷ []) false false true 1) (1000 , 1006) (valid (route false 122 2 true ((1006 , 2002) ∷ []) (2 ∷ []))) + ≡ valid (route false 122 4 true ((1000 , 1006) ∷ (1006 , 2002) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 5 6 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route true 0 10 ((1005 , 2003) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 127 11 ((1000 , 1005) ∷ (1005 , 2003) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ : extend (link true 1 127 false (2005 ∷ []) (floor 5 6 1 1 ∷ []) true false true 3) (1000 , 1005) (valid (route true 0 10 false ((1005 , 2003) ∷ []) (2 ∷ []))) + ≡ valid (route true 127 11 true ((1000 , 1005) ∷ (1005 , 2003) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 128 true (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 0 1 0 ∷ floor 6 4 1 0 ∷ []) false false true 3) (1000 , 1004) (valid (route false 128 6 ((1004 , 2004) ∷ (2004 , 1001) ∷ (1001 , 1005) ∷ (1005 , 2006) ∷ []) (false , 2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 2 128 true (2003 ∷ []) (floor 1 5 2 0 ∷ floor 2 0 1 0 ∷ floor 6 4 1 0 ∷ []) false false true 3) (1000 , 1004) (valid (route false 128 6 false ((1004 , 2004) ∷ (2004 , 1001) ∷ (1001 , 1005) ∷ (1005 , 2006) ∷ []) (2 ∷ 2 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (2005 ∷ 2006 ∷ []) (floor 3 2 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 0 10 ((1004 , 1006) ∷ []) (true , 3 ∷ []))) - ≡ valid (route false 127 11 ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (2005 ∷ 2006 ∷ []) (floor 3 2 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 0 10 true ((1004 , 1006) ∷ []) (3 ∷ []))) + ≡ valid (route false 127 11 true ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 0 true (2001 ∷ 2003 ∷ []) ([]) false false true 3) (1000 , 2005) (valid (route true 127 3 ((2005 , 1006) ∷ (1006 , 2001) ∷ (2001 , 1000) ∷ (1000 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 1 0 true (2001 ∷ 2003 ∷ []) ([]) false false true 3) (1000 , 2005) (valid (route true 127 3 false ((2005 , 1006) ∷ (1006 , 2001) ∷ (2001 , 1000) ∷ (1000 , 1004) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 0 false (2002 ∷ 2006 ∷ []) (floor 6 2 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 2 ((1000 , 2003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 0 false (2002 ∷ 2006 ∷ []) (floor 6 2 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 2 false ((1000 , 2003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 122 false (1006 ∷ []) (floor 1 1 2 2 ∷ floor 4 5 1 0 ∷ floor 5 6 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 122 7 ((2004 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ []))) +_ : extend (link true 2 122 false (1006 ∷ []) (floor 1 1 2 2 ∷ floor 4 5 1 0 ∷ floor 5 6 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 122 7 false ((2004 , 1006) ∷ (1006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2002) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 127 false ([]) (floor 6 4 1 1 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 2 ((1000 , 2002) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 2 127 false ([]) (floor 6 4 1 1 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 2 true ((1000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 0 4 1 1 ∷ floor 2 6 2 2 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 0 ((2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 127 3 ((1000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 0 4 1 1 ∷ floor 2 6 2 2 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 0 false ((2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 3 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 127 3 false ((1000 , 2003) ∷ (2003 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2006) ∷ []) (3 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 127 8 ((2001 , 2005) ∷ (2005 , 2003) ∷ []) (true , 3 ∷ 3 ∷ []))) - ≡ valid (route false 127 9 ((1000 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2003) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 127 8 true ((2001 , 2005) ∷ (2005 , 2003) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route false 127 9 true ((1000 , 2001) ∷ (2001 , 2005) ∷ (2005 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2001 ∷ 2003 ∷ []) ([]) false false true 2) (1000 , 2002) (valid (route false 128 3 ((2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 255 5 ((1000 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 255 true (2001 ∷ 2003 ∷ []) ([]) false false true 2) (1000 , 2002) (valid (route false 128 3 false ((2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 255 5 false ((1000 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1005 ∷ []) ([]) false false true 1) (1000 , 2005) (valid (route false 122 7 ((2005 , 2004) ∷ (2004 , 1005) ∷ []) (true , 1 ∷ 1 ∷ []))) - ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1005) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 0 false (1005 ∷ []) ([]) false false true 1) (1000 , 2005) (valid (route false 122 7 true ((2005 , 2004) ∷ (2004 , 1005) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route true 122 8 true ((1000 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1005) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1001 ∷ 1004 ∷ []) (floor 2 5 2 0 ∷ floor 4 5 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route false 128 9 ((2005 , 2006) ∷ []) (false , 1 ∷ []))) - ≡ valid (route false 128 11 ((1000 , 2005) ∷ (2005 , 2006) ∷ []) (false , 1 ∷ 1 ∷ [])) +_ : extend (link true 2 0 false (1001 ∷ 1004 ∷ []) (floor 2 5 2 0 ∷ floor 4 5 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route false 128 9 false ((2005 , 2006) ∷ []) (1 ∷ []))) + ≡ valid (route false 128 11 false ((1000 , 2005) ∷ (2005 , 2006) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 1 2 2 0 ∷ floor 4 3 2 3 ∷ floor 6 3 1 1 ∷ []) false false false 3) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 2 0 false ([]) (floor 1 2 2 0 ∷ floor 4 3 2 3 ∷ floor 6 3 1 1 ∷ []) false false false 3) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 122 true (1005 ∷ 2005 ∷ []) (floor 1 4 1 1 ∷ floor 6 1 2 0 ∷ []) false false false 3) (1000 , 1003) (valid (route false 128 3 ((1003 , 2005) ∷ (2005 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2006) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 3 122 true (1005 ∷ 2005 ∷ []) (floor 1 4 1 1 ∷ floor 6 1 2 0 ∷ []) false false false 3) (1000 , 1003) (valid (route false 128 3 false ((1003 , 2005) ∷ (2005 , 2003) ∷ (2003 , 1000) ∷ (1000 , 2006) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false (1002 ∷ 1005 ∷ []) ([]) false true true 1) (1000 , 1006) (valid (route false 0 4 ((1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 0 5 ((1000 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 0 false (1002 ∷ 1005 ∷ []) ([]) false true true 1) (1000 , 1006) (valid (route false 0 4 false ((1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 0 5 false ((1000 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1003) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 0 true (1002 ∷ []) ([]) false false true 2) (1000 , 2005) (valid (route false 127 11 ((2005 , 1004) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 127 13 ((1000 , 2005) ∷ (2005 , 1004) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ : extend (link true 2 0 true (1002 ∷ []) ([]) false false true 2) (1000 , 2005) (valid (route false 127 11 false ((2005 , 1004) ∷ []) (1 ∷ []))) + ≡ valid (route true 127 13 false ((1000 , 2005) ∷ (2005 , 1004) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 false (2002 ∷ []) (floor 1 5 1 2 ∷ floor 3 0 1 2 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1001) (valid (route false 255 6 ((1001 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1004) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 2 128 false (2002 ∷ []) (floor 1 5 1 2 ∷ floor 3 0 1 2 ∷ floor 5 4 2 3 ∷ []) false false false 1) (1000 , 1001) (valid (route false 255 6 false ((1001 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1004) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 3 ((1006 , 1002) ∷ []) (true , 1 ∷ []))) - ≡ valid (route false 128 6 ((1000 , 1006) ∷ (1006 , 1002) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ : extend (link true 3 127 false (2004 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 128 3 true ((1006 , 1002) ∷ []) (1 ∷ []))) + ≡ valid (route false 128 6 true ((1000 , 1006) ∷ (1006 , 1002) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 4 0 2 1 ∷ floor 4 5 2 0 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2001) (valid (route false 122 5 ((2001 , 2002) ∷ []) (true , 2 ∷ []))) +_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 4 0 2 1 ∷ floor 4 5 2 0 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2001) (valid (route false 122 5 true ((2001 , 2002) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (1005 ∷ []) (floor 3 3 1 3 ∷ []) true true false 3) (1000 , 1001) (valid (route true 122 0 ((1001 , 1036) ∷ (1036 , 2016) ∷ (2016 , 2025) ∷ (2025 , 2032) ∷ (2032 , 2017) ∷ (2017 , 1027) ∷ (1027 , 2039) ∷ (2039 , 2035) ∷ (2035 , 2020) ∷ (2020 , 1023) ∷ (1023 , 1024) ∷ (1024 , 2007) ∷ (2007 , 2009) ∷ (2009 , 1011) ∷ (1011 , 1010) ∷ (1010 , 2004) ∷ (2004 , 2030) ∷ (2030 , 1008) ∷ (1008 , 1019) ∷ (1019 , 1003) ∷ (1003 , 1038) ∷ (1038 , 2012) ∷ (2012 , 1021) ∷ (1021 , 1034) ∷ (1034 , 2015) ∷ (2015 , 2022) ∷ (2022 , 1018) ∷ (1018 , 2014) ∷ (2014 , 1028) ∷ (1028 , 1031) ∷ (1031 , 1013) ∷ (1013 , 2029) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 127 false (1005 ∷ []) (floor 3 3 1 3 ∷ []) true true false 3) (1000 , 1001) (valid (route true 122 0 false ((1001 , 1036) ∷ (1036 , 2016) ∷ (2016 , 2025) ∷ (2025 , 2032) ∷ (2032 , 2017) ∷ (2017 , 1027) ∷ (1027 , 2039) ∷ (2039 , 2035) ∷ (2035 , 2020) ∷ (2020 , 1023) ∷ (1023 , 1024) ∷ (1024 , 2007) ∷ (2007 , 2009) ∷ (2009 , 1011) ∷ (1011 , 1010) ∷ (1010 , 2004) ∷ (2004 , 2030) ∷ (2030 , 1008) ∷ (1008 , 1019) ∷ (1019 , 1003) ∷ (1003 , 1038) ∷ (1038 , 2012) ∷ (2012 , 1021) ∷ (1021 , 1034) ∷ (1034 , 2015) ∷ (2015 , 2022) ∷ (2022 , 1018) ∷ (1018 , 2014) ∷ (2014 , 1028) ∷ (1028 , 1031) ∷ (1031 , 1013) ∷ (1013 , 2029) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false ([]) (floor 6 3 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 255 8 ((2005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) - ≡ valid (route false 255 12 ((1000 , 2005) ∷ (2005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false ([]) (floor 6 3 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 255 8 false ((2005 , 1001) ∷ (1001 , 2006) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route false 255 12 false ((1000 , 2005) ∷ (2005 , 1001) ∷ (1001 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 5 1 3 ∷ floor 4 3 1 2 ∷ []) false true false 2) (1000 , 2006) (valid (route true 255 8 ((2006 , 1003) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 255 9 ((1000 , 2006) ∷ (2006 , 1003) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ : extend (link true 1 128 false (1002 ∷ []) (floor 1 5 1 3 ∷ floor 4 3 1 2 ∷ []) false true false 2) (1000 , 2006) (valid (route true 255 8 false ((2006 , 1003) ∷ []) (2 ∷ []))) + ≡ valid (route true 255 9 false ((1000 , 2006) ∷ (2006 , 1003) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1006 ∷ []) (floor 3 5 1 0 ∷ []) true true true 2) (1000 , 2006) (valid (route true 0 7 ((2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 128 11 ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false (1006 ∷ []) (floor 3 5 1 0 ∷ []) true true true 2) (1000 , 2006) (valid (route true 0 7 false ((2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 128 11 true ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2003) ∷ (2003 , 2001) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 0 true ([]) (floor 0 5 1 0 ∷ floor 4 4 1 0 ∷ floor 6 0 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 255 4 ((2004 , 1004) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 255 7 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ : extend (link true 3 0 true ([]) (floor 0 5 1 0 ∷ floor 4 4 1 0 ∷ floor 6 0 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 255 4 false ((2004 , 1004) ∷ []) (3 ∷ []))) + ≡ valid (route true 255 7 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 4 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 1 ((1000 , 2003) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 2 4 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 1 false ((1000 , 2003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 128 false ([]) (floor 0 6 2 3 ∷ []) false true true 3) (1000 , 2001) (valid (route false 122 0 ((2001 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1000) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 3 128 false ([]) (floor 0 6 2 3 ∷ []) false true true 3) (1000 , 2001) (valid (route false 122 0 true ((2001 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1000) ∷ []) (1 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false ([]) (floor 2 0 2 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 3 ((1000 , 2006) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 2 0 2 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 3 true ((1000 , 2006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 122 false (1002 ∷ 2005 ∷ []) (floor 1 5 2 3 ∷ floor 3 4 1 0 ∷ floor 5 4 2 2 ∷ []) true false true 1) (1000 , 2003) (valid (route false 127 9 ((2003 , 1000) ∷ []) (true , 2 ∷ []))) +_ : extend (link true 4 122 false (1002 ∷ 2005 ∷ []) (floor 1 5 2 3 ∷ floor 3 4 1 0 ∷ floor 5 4 2 2 ∷ []) true false true 1) (1000 , 2003) (valid (route false 127 9 true ((2003 , 1000) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2006 ∷ []) (floor 5 3 1 3 ∷ []) false true true 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 2004) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 127 false (1004 ∷ 2006 ∷ []) (floor 5 3 1 3 ∷ []) false true true 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 false ((1000 , 2004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2005 ∷ []) (floor 0 3 2 1 ∷ floor 5 3 1 0 ∷ floor 6 3 1 1 ∷ []) true false false 1) (1000 , 2006) (valid (route false 128 5 ((2006 , 1005) ∷ (1005 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 2 0 false (2005 ∷ []) (floor 0 3 2 1 ∷ floor 5 3 1 0 ∷ floor 6 3 1 1 ∷ []) true false false 1) (1000 , 2006) (valid (route false 128 5 false ((2006 , 1005) ∷ (1005 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false ([]) (floor 3 5 2 3 ∷ floor 5 2 2 1 ∷ floor 6 3 2 2 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 10 ((2002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1000) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 1 127 false ([]) (floor 3 5 2 3 ∷ floor 5 2 2 1 ∷ floor 6 3 2 2 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 10 false ((2002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1000) ∷ []) (2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (1004 ∷ 1006 ∷ []) ([]) true false false 2) (1000 , 1001) (valid (route false 127 0 ((1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 127 1 ((1000 , 1001) ∷ (1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 122 false (1004 ∷ 1006 ∷ []) ([]) true false false 2) (1000 , 1001) (valid (route false 127 0 false ((1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 127 1 true ((1000 , 1001) ∷ (1001 , 1004) ∷ (1004 , 2001) ∷ (2001 , 2005) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 127 true (2001 ∷ []) (floor 1 4 2 0 ∷ floor 4 1 2 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 122 0 ((1004 , 2003) ∷ (2003 , 2002) ∷ []) (false , 1 ∷ 1 ∷ []))) - ≡ valid (route true 127 1 ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 127 true (2001 ∷ []) (floor 1 4 2 0 ∷ floor 4 1 2 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 122 0 false ((1004 , 2003) ∷ (2003 , 2002) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route true 127 1 false ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 0 false ([]) (floor 2 0 1 0 ∷ floor 5 5 2 3 ∷ floor 6 6 1 2 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 1 ((1005 , 2004) ∷ (2004 , 1003) ∷ []) (true , 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 5 ((1000 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 4 0 false ([]) (floor 2 0 1 0 ∷ floor 5 5 2 3 ∷ floor 6 6 1 2 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 1 true ((1005 , 2004) ∷ (2004 , 1003) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route false 255 5 true ((1000 , 1005) ∷ (1005 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 1 3 2 0 ∷ []) true false true 1) (1000 , 2005) (valid (route true 122 5 ((2005 , 1005) ∷ (1005 , 2001) ∷ []) (false , 2 ∷ 1 ∷ []))) - ≡ valid (route true 122 8 ((1000 , 2005) ∷ (2005 , 1005) ∷ (1005 , 2001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 3 122 true ([]) (floor 1 3 2 0 ∷ []) true false true 1) (1000 , 2005) (valid (route true 122 5 false ((2005 , 1005) ∷ (1005 , 2001) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route true 122 8 true ((1000 , 2005) ∷ (2005 , 1005) ∷ (1005 , 2001) ∷ []) (1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2004 ∷ []) (floor 1 3 2 0 ∷ floor 3 6 1 1 ∷ []) false true false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 2 255 true (2004 ∷ []) (floor 1 3 2 0 ∷ floor 3 6 1 1 ∷ []) false true false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 255 false ([]) ([]) false false true 1) (1000 , 1004) (valid (route false 127 3 ((1004 , 2003) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 255 5 ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ : extend (link true 2 255 false ([]) ([]) false false true 1) (1000 , 1004) (valid (route false 127 3 false ((1004 , 2003) ∷ []) (2 ∷ []))) + ≡ valid (route false 255 5 false ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 1 0 2 2 ∷ floor 6 6 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 122 2 ((1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route false 127 3 ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 1 0 2 2 ∷ floor 6 6 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 122 2 false ((1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route false 127 3 false ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 0 1 1 3 ∷ floor 4 5 2 1 ∷ []) false true true 1) (1000 , 1004) (valid (route false 255 8 ((1004 , 1000) ∷ (1000 , 1001) ∷ (1001 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) +_ : extend (link true 1 127 false ([]) (floor 0 1 1 3 ∷ floor 4 5 2 1 ∷ []) false true true 1) (1000 , 1004) (valid (route false 255 8 false ((1004 , 1000) ∷ (1000 , 1001) ∷ (1001 , 2002) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (1003 ∷ 2002 ∷ []) (floor 0 5 1 1 ∷ floor 5 1 2 1 ∷ []) false false true 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 4 ((1000 , 1003) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 4 127 false (1003 ∷ 2002 ∷ []) (floor 0 5 1 1 ∷ floor 5 1 2 1 ∷ []) false false true 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 4 false ((1000 , 1003) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 4 1 1 ∷ floor 6 0 1 0 ∷ []) false false true 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 2 ((1000 , 2005) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 0 4 1 1 ∷ floor 6 0 1 0 ∷ []) false false true 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 2 false ((1000 , 2005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 255 false (2004 ∷ []) (floor 1 2 1 3 ∷ []) false false true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 4 ((1000 , 2002) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 4 255 false (2004 ∷ []) (floor 1 2 1 3 ∷ []) false false true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 4 false ((1000 , 2002) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 0 true (2005 ∷ []) (floor 2 4 1 3 ∷ floor 3 2 2 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 0 3 ((2002 , 1005) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 0 5 ((1000 , 2002) ∷ (2002 , 1005) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ : extend (link true 2 0 true (2005 ∷ []) (floor 2 4 1 3 ∷ floor 3 2 2 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 0 3 false ((2002 , 1005) ∷ []) (1 ∷ []))) + ≡ valid (route true 0 5 false ((1000 , 2002) ∷ (2002 , 1005) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1004 ∷ 1005 ∷ []) (floor 1 1 1 0 ∷ floor 3 3 1 2 ∷ floor 6 1 2 2 ∷ []) false false false 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 4 128 false (1004 ∷ 1005 ∷ []) (floor 1 1 1 0 ∷ floor 3 3 1 2 ∷ floor 6 1 2 2 ∷ []) false false false 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1005 ∷ 1006 ∷ []) ([]) false false false 1) (1000 , 1003) (valid (route false 122 10 ((1003 , 2028) ∷ (2028 , 2002) ∷ (2002 , 2036) ∷ (2036 , 1026) ∷ (1026 , 2003) ∷ (2003 , 2020) ∷ (2020 , 2021) ∷ (2021 , 1034) ∷ (1034 , 2012) ∷ (2012 , 1011) ∷ (1011 , 2006) ∷ (2006 , 1025) ∷ (1025 , 1017) ∷ (1017 , 1032) ∷ (1032 , 1008) ∷ (1008 , 1005) ∷ (1005 , 2016) ∷ (2016 , 2038) ∷ (2038 , 2013) ∷ (2013 , 2015) ∷ (2015 , 1022) ∷ (1022 , 1035) ∷ (1035 , 2030) ∷ (2030 , 1019) ∷ (1019 , 2001) ∷ (2001 , 1039) ∷ (1039 , 2029) ∷ (2029 , 2023) ∷ (2023 , 2010) ∷ (2010 , 2031) ∷ (2031 , 1009) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 3 255 false (1005 ∷ 1006 ∷ []) ([]) false false false 1) (1000 , 1003) (valid (route false 122 10 true ((1003 , 2028) ∷ (2028 , 2002) ∷ (2002 , 2036) ∷ (2036 , 1026) ∷ (1026 , 2003) ∷ (2003 , 2020) ∷ (2020 , 2021) ∷ (2021 , 1034) ∷ (1034 , 2012) ∷ (2012 , 1011) ∷ (1011 , 2006) ∷ (2006 , 1025) ∷ (1025 , 1017) ∷ (1017 , 1032) ∷ (1032 , 1008) ∷ (1008 , 1005) ∷ (1005 , 2016) ∷ (2016 , 2038) ∷ (2038 , 2013) ∷ (2013 , 2015) ∷ (2015 , 1022) ∷ (1022 , 1035) ∷ (1035 , 2030) ∷ (2030 , 1019) ∷ (1019 , 2001) ∷ (2001 , 1039) ∷ (1039 , 2029) ∷ (2029 , 2023) ∷ (2023 , 2010) ∷ (2010 , 2031) ∷ (2031 , 1009) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (2002 ∷ []) (floor 5 2 2 2 ∷ []) false true false 1) (1000 , 1002) (valid (route false 128 11 ((1002 , 1005) ∷ (1005 , 1001) ∷ []) (true , 1 ∷ 3 ∷ []))) +_ : extend (link true 3 0 false (2002 ∷ []) (floor 5 2 2 2 ∷ []) false true false 1) (1000 , 1002) (valid (route false 128 11 true ((1002 , 1005) ∷ (1005 , 1001) ∷ []) (1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 true ([]) (floor 0 2 2 3 ∷ floor 4 3 1 1 ∷ floor 6 1 2 0 ∷ []) true false true 2) (1000 , 1003) (valid (route false 128 9 ((1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 128 12 ((1000 , 1003) ∷ (1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 3 127 true ([]) (floor 0 2 2 3 ∷ floor 4 3 1 1 ∷ floor 6 1 2 0 ∷ []) true false true 2) (1000 , 1003) (valid (route false 128 9 false ((1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 128 12 true ((1000 , 1003) ∷ (1003 , 1002) ∷ (1002 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 128 false (2001 ∷ []) ([]) false false true 3) (1000 , 2006) (valid (route false 255 2 ((2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route true 255 6 ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 4 128 false (2001 ∷ []) ([]) false false true 3) (1000 , 2006) (valid (route false 255 2 false ((2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route true 255 6 false ((1000 , 2006) ∷ (2006 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 127 false ([]) (floor 1 1 1 1 ∷ floor 6 6 2 2 ∷ []) false false true 3) (1000 , 2004) (valid (route false 255 2 ((2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 4 ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 127 false ([]) (floor 1 1 1 1 ∷ floor 6 6 2 2 ∷ []) false false true 3) (1000 , 2004) (valid (route false 255 2 false ((2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 4 false ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2006) ∷ (2006 , 1003) ∷ []) (3 ∷ 2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1003 ∷ []) ([]) true false false 2) (1000 , 2004) (valid (route false 127 6 ((2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 127 7 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 0 false (1003 ∷ []) ([]) true false false 2) (1000 , 2004) (valid (route false 127 6 true ((2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 127 7 true ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1002 ∷ 2006 ∷ []) (floor 4 3 2 1 ∷ []) true true true 1) (1000 , 2001) (valid (route false 0 2 ((2001 , 1000) ∷ (1000 , 2005) ∷ (2005 , 2004) ∷ []) (true , 3 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 3 255 true (1002 ∷ 2006 ∷ []) (floor 4 3 2 1 ∷ []) true true true 1) (1000 , 2001) (valid (route false 0 2 true ((2001 , 1000) ∷ (1000 , 2005) ∷ (2005 , 2004) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 true ([]) ([]) false false true 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 3 ((1000 , 2005) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 3 127 true ([]) ([]) false false true 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 3 false ((1000 , 2005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 2004 ∷ []) (floor 1 1 2 0 ∷ floor 2 5 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 122 9 ((1003 , 2002) ∷ (2002 , 2006) ∷ (2006 , 2003) ∷ (2003 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 4 128 false (1003 ∷ 2004 ∷ []) (floor 1 1 2 0 ∷ floor 2 5 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 122 9 true ((1003 , 2002) ∷ (2002 , 2006) ∷ (2006 , 2003) ∷ (2003 , 1001) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false false 3) (1000 , 2001) (valid (route false 128 6 ((2001 , 2004) ∷ []) (true , 3 ∷ []))) - ≡ valid (route true 128 8 ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ : extend (link true 2 128 true ([]) ([]) false false false 3) (1000 , 2001) (valid (route false 128 6 true ((2001 , 2004) ∷ []) (3 ∷ []))) + ≡ valid (route true 128 8 true ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 128 false ([]) (floor 0 3 1 2 ∷ floor 2 1 2 2 ∷ []) false true true 3) (1000 , 1001) (valid (route false 127 10 ((1001 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 1000) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 1 128 false ([]) (floor 0 3 1 2 ∷ floor 2 1 2 2 ∷ []) false true true 3) (1000 , 1001) (valid (route false 127 10 true ((1001 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 1000) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (1004 ∷ 1006 ∷ []) (floor 6 3 2 0 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 10 ((1002 , 1005) ∷ (1005 , 1006) ∷ (1006 , 1000) ∷ []) (true , 3 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 3 122 false (1004 ∷ 1006 ∷ []) (floor 6 3 2 0 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 10 true ((1002 , 1005) ∷ (1005 , 1006) ∷ (1006 , 1000) ∷ []) (3 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 255 true (2002 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 1002) (valid (route true 128 10 ((1002 , 2006) ∷ (2006 , 2005) ∷ []) (true , 1 ∷ 3 ∷ []))) - ≡ valid (route true 255 13 ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2005) ∷ []) (true , 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 3 255 true (2002 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 1002) (valid (route true 128 10 true ((1002 , 2006) ∷ (2006 , 2005) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route true 255 13 true ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2005) ∷ []) (1 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) (floor 5 1 2 3 ∷ floor 5 3 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 255 11 ((2002 , 2004) ∷ (2004 , 1000) ∷ (1000 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 3 255 false ([]) (floor 5 1 2 3 ∷ floor 5 3 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 255 11 true ((2002 , 2004) ∷ (2004 , 1000) ∷ (1000 , 1001) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 255 false (1002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 255 8 ((1004 , 1000) ∷ (1000 , 1002) ∷ (1002 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 2 255 false (1002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 255 8 false ((1004 , 1000) ∷ (1000 , 1002) ∷ (1002 , 2006) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (2006 ∷ []) ([]) true false false 2) (1000 , 1003) (valid (route false 255 11 ((1003 , 2005) ∷ []) (true , 3 ∷ []))) - ≡ valid (route false 255 14 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 3 127 false (2006 ∷ []) ([]) true false false 2) (1000 , 1003) (valid (route false 255 11 true ((1003 , 2005) ∷ []) (3 ∷ []))) + ≡ valid (route false 255 14 true ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 1 2 1 2 ∷ floor 3 6 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 1 127 false (2005 ∷ []) (floor 1 2 1 2 ∷ floor 3 6 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 128 false (1006 ∷ []) (floor 0 5 2 0 ∷ floor 5 5 2 2 ∷ []) false true true 1) (1000 , 2003) (valid (route false 128 5 ((2003 , 1002) ∷ []) (true , 3 ∷ []))) +_ : extend (link true 1 128 false (1006 ∷ []) (floor 0 5 2 0 ∷ floor 5 5 2 2 ∷ []) false true true 1) (1000 , 2003) (valid (route false 128 5 true ((2003 , 1002) ∷ []) (3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false (1005 ∷ 2005 ∷ []) (floor 2 1 2 2 ∷ floor 3 5 1 0 ∷ floor 5 0 1 3 ∷ []) true false true 2) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 4 ((1000 , 1001) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 4 128 false (1005 ∷ 2005 ∷ []) (floor 2 1 2 2 ∷ floor 3 5 1 0 ∷ floor 5 0 1 3 ∷ []) true false true 2) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 4 true ((1000 , 1001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2005 ∷ 2006 ∷ []) ([]) false false true 2) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 2 ((1000 , 1001) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 0 false (2005 ∷ 2006 ∷ []) ([]) false false true 2) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 2 false ((1000 , 1001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 128 true (2004 ∷ []) (floor 1 3 2 3 ∷ floor 4 0 1 3 ∷ floor 5 4 2 1 ∷ []) true false true 1) (1000 , 1002) (valid (route false 122 8 ((1002 , 2002) ∷ (2002 , 2006) ∷ []) (true , 2 ∷ 3 ∷ []))) - ≡ valid (route true 128 11 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2006) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 128 true (2004 ∷ []) (floor 1 3 2 3 ∷ floor 4 0 1 3 ∷ floor 5 4 2 1 ∷ []) true false true 1) (1000 , 1002) (valid (route false 122 8 true ((1002 , 2002) ∷ (2002 , 2006) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route true 128 11 true ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 true (1005 ∷ 2002 ∷ []) (floor 1 2 1 3 ∷ floor 5 0 1 1 ∷ []) true true true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 128 2 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 2 128 true (1005 ∷ 2002 ∷ []) (floor 1 2 1 3 ∷ floor 5 0 1 1 ∷ []) true true true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 128 2 true ((1000 , 2004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1006 ∷ 2006 ∷ []) (floor 4 5 1 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 2 ((1002 , 2005) ∷ (2005 , 1003) ∷ []) (true , 3 ∷ 1 ∷ []))) - ≡ valid (route false 0 6 ((1000 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1003) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 4 0 false (1006 ∷ 2006 ∷ []) (floor 4 5 1 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 2 true ((1002 , 2005) ∷ (2005 , 1003) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route false 0 6 true ((1000 , 1002) ∷ (1002 , 2005) ∷ (2005 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 0 false ([]) (floor 2 1 2 1 ∷ floor 5 1 1 2 ∷ floor 6 3 2 2 ∷ []) true true false 3) (1000 , 1001) (valid (route false 255 10 ((1001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 2005) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 4 0 false ([]) (floor 2 1 2 1 ∷ floor 5 1 1 2 ∷ floor 6 3 2 2 ∷ []) true true false 3) (1000 , 1001) (valid (route false 255 10 false ((1001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 2005) ∷ []) (2 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 122 false (2001 ∷ []) (floor 6 4 2 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 122 7 ((2005 , 1002) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 122 9 ((1000 , 2005) ∷ (2005 , 1002) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ : extend (link true 2 122 false (2001 ∷ []) (floor 6 4 2 3 ∷ []) false false true 2) (1000 , 2005) (valid (route false 122 7 false ((2005 , 1002) ∷ []) (2 ∷ []))) + ≡ valid (route false 122 9 false ((1000 , 2005) ∷ (2005 , 1002) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 true (2005 ∷ []) (floor 1 4 2 3 ∷ floor 1 6 1 2 ∷ floor 2 4 2 2 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 1 127 true (2005 ∷ []) (floor 1 4 2 3 ∷ floor 1 6 1 2 ∷ floor 2 4 2 2 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 0 true ([]) ([]) false false false 1) (1000 , 2005) (valid (route false 122 8 ((2005 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1000) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 2 0 true ([]) ([]) false false false 1) (1000 , 2005) (valid (route false 122 8 false ((2005 , 1001) ∷ (1001 , 1005) ∷ (1005 , 1000) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 127 false (1003 ∷ 2003 ∷ []) (floor 1 1 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 127 11 ((1003 , 2005) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 127 13 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ : extend (link true 2 127 false (1003 ∷ 2003 ∷ []) (floor 1 1 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 127 11 false ((1003 , 2005) ∷ []) (3 ∷ []))) + ≡ valid (route true 127 13 false ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 128 false (1004 ∷ 2004 ∷ []) (floor 5 4 2 3 ∷ floor 6 5 2 2 ∷ []) true true true 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 3 ((1000 , 1001) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 3 128 false (1004 ∷ 2004 ∷ []) (floor 5 4 2 3 ∷ floor 6 5 2 2 ∷ []) true true true 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 3 true ((1000 , 1001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1004 ∷ 2004 ∷ []) (floor 2 0 1 1 ∷ floor 2 5 2 2 ∷ floor 6 5 1 3 ∷ []) false true true 3) (1000 , 2003) (valid (route false 255 8 ((2003 , 2002) ∷ []) (false , 1 ∷ []))) - ≡ valid (route false 255 9 ((1000 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ : extend (link true 1 255 false (1004 ∷ 2004 ∷ []) (floor 2 0 1 1 ∷ floor 2 5 2 2 ∷ floor 6 5 1 3 ∷ []) false true true 3) (1000 , 2003) (valid (route false 255 8 false ((2003 , 2002) ∷ []) (1 ∷ []))) + ≡ valid (route false 255 9 false ((1000 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 true (2002 ∷ []) (floor 2 4 1 1 ∷ floor 3 5 1 0 ∷ floor 6 1 1 0 ∷ []) true true true 3) (1000 , 1006) (valid (route true 255 7 ((1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 255 8 ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 0 true (2002 ∷ []) (floor 2 4 1 1 ∷ floor 3 5 1 0 ∷ floor 6 1 1 0 ∷ []) true true true 3) (1000 , 1006) (valid (route true 255 7 false ((1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 255 8 true ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1003) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2006 ∷ []) (floor 4 5 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 255 5 ((1003 , 2005) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 255 6 ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ : extend (link true 1 128 false (2006 ∷ []) (floor 4 5 2 2 ∷ []) false false true 2) (1000 , 1003) (valid (route true 255 5 false ((1003 , 2005) ∷ []) (1 ∷ []))) + ≡ valid (route true 255 6 false ((1000 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 2 5 2 3 ∷ []) false false false 1) (1000 , 2005) (valid (route false 127 7 ((2005 , 1000) ∷ (1000 , 2004) ∷ []) (true , 1 ∷ 1 ∷ []))) +_ : extend (link true 3 122 true ([]) (floor 2 5 2 3 ∷ []) false false false 1) (1000 , 2005) (valid (route false 127 7 true ((2005 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 false (1004 ∷ []) (floor 0 2 2 0 ∷ floor 0 5 1 0 ∷ floor 4 6 1 1 ∷ []) false false false 3) (1000 , 1001) (valid (route false 255 9 ((1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 255 13 ((1000 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 122 false (1004 ∷ []) (floor 0 2 2 0 ∷ floor 0 5 1 0 ∷ floor 4 6 1 1 ∷ []) false false false 3) (1000 , 1001) (valid (route false 255 9 true ((1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 255 13 true ((1000 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 true (2005 ∷ []) ([]) false false true 3) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 2 ((1000 , 2002) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 255 true (2005 ∷ []) ([]) false false true 3) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 2 false ((1000 , 2002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 128 false (2006 ∷ []) (floor 5 2 1 3 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 128 4 ((1000 , 2006) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 4 128 false (2006 ∷ []) (floor 5 2 1 3 ∷ []) false false true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 128 4 false ((1000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 255 false (2004 ∷ []) (floor 1 0 2 2 ∷ floor 3 5 2 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 7 ((1002 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2003) ∷ (2003 , 1000) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 2 255 false (2004 ∷ []) (floor 1 0 2 2 ∷ floor 3 5 2 1 ∷ []) false true true 1) (1000 , 1002) (valid (route false 127 7 false ((1002 , 2005) ∷ (2005 , 2001) ∷ (2001 , 2003) ∷ (2003 , 1000) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false ([]) (floor 0 6 1 1 ∷ floor 1 0 1 0 ∷ []) true false true 3) (1000 , 2002) (valid (route true 128 8 ((2002 , 2003) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 128 11 ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (true , 3 ∷ 1 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 0 6 1 1 ∷ floor 1 0 1 0 ∷ []) true false true 3) (1000 , 2002) (valid (route true 128 8 false ((2002 , 2003) ∷ []) (1 ∷ []))) + ≡ valid (route true 128 11 true ((1000 , 2002) ∷ (2002 , 2003) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 255 true (1001 ∷ 2004 ∷ []) (floor 1 3 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 128 7 ((2001 , 1003) ∷ (1003 , 1000) ∷ (1000 , 2006) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 4 255 true (1001 ∷ 2004 ∷ []) (floor 1 3 2 3 ∷ []) false false true 1) (1000 , 2001) (valid (route false 128 7 false ((2001 , 1003) ∷ (1003 , 1000) ∷ (1000 , 2006) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 128 false ([]) ([]) true false true 1) (1000 , 1005) (valid (route true 255 0 ((1005 , 2002) ∷ (2002 , 1000) ∷ (1000 , 2005) ∷ (2005 , 1001) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 3 128 false ([]) ([]) true false true 1) (1000 , 1005) (valid (route true 255 0 true ((1005 , 2002) ∷ (2002 , 1000) ∷ (1000 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (1006 ∷ []) (floor 5 1 2 1 ∷ []) true false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 0 false (1006 ∷ []) (floor 5 1 2 1 ∷ []) true false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 255 false ([]) (floor 2 5 1 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 1 ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 255 5 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 255 false ([]) (floor 2 5 1 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 1 false ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 255 5 true ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 1006) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1004 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1001) (valid (route false 255 8 ((1001 , 2003) ∷ []) (true , 3 ∷ []))) +_ : extend (link true 3 122 false (1004 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1001) (valid (route false 255 8 true ((1001 , 2003) ∷ []) (3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 false ([]) (floor 1 4 2 0 ∷ []) true true true 3) (1000 , 2002) (valid (route false 127 0 ((2002 , 1000) ∷ []) (false , 3 ∷ []))) +_ : extend (link true 4 255 false ([]) (floor 1 4 2 0 ∷ []) true true true 3) (1000 , 2002) (valid (route false 127 0 false ((2002 , 1000) ∷ []) (3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 false (2001 ∷ []) (floor 0 0 2 2 ∷ floor 2 2 2 0 ∷ floor 6 1 2 1 ∷ []) false true true 1) (1000 , 2003) (valid (route false 127 2 ((2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 4 0 false (2001 ∷ []) (floor 0 0 2 2 ∷ floor 2 2 2 0 ∷ floor 6 1 2 1 ∷ []) false true true 1) (1000 , 2003) (valid (route false 127 2 false ((2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2001) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1006 ∷ 2004 ∷ []) ([]) true true true 2) (1000 , 1004) (valid (route false 128 0 ((1004 , 2005) ∷ []) (false , 1 ∷ []))) - ≡ valid (route false 128 4 ((1000 , 1004) ∷ (1004 , 2005) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ : extend (link true 4 127 false (1006 ∷ 2004 ∷ []) ([]) true true true 2) (1000 , 1004) (valid (route false 128 0 false ((1004 , 2005) ∷ []) (1 ∷ []))) + ≡ valid (route false 128 4 true ((1000 , 1004) ∷ (1004 , 2005) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 127 false (1002 ∷ 1005 ∷ []) (floor 2 2 2 3 ∷ floor 3 0 2 3 ∷ floor 6 2 1 2 ∷ []) false false true 3) (1000 , 1004) (valid (route true 127 9 ((1004 , 2003) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 127 11 ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ : extend (link true 2 127 false (1002 ∷ 1005 ∷ []) (floor 2 2 2 3 ∷ floor 3 0 2 3 ∷ floor 6 2 1 2 ∷ []) false false true 3) (1000 , 1004) (valid (route true 127 9 false ((1004 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route true 127 11 false ((1000 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ []) (floor 4 0 2 3 ∷ floor 5 3 2 2 ∷ floor 5 5 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 10 ((2004 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 4 127 false (1003 ∷ []) (floor 4 0 2 3 ∷ floor 5 3 2 2 ∷ floor 5 5 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 10 false ((2004 , 1006) ∷ (1006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false ([]) (floor 1 0 2 0 ∷ floor 2 5 1 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 122 9 ((2006 , 2002) ∷ (2002 , 1003) ∷ []) (true , 1 ∷ 1 ∷ []))) - ≡ valid (route false 122 10 ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1003) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 0 false ([]) (floor 1 0 2 0 ∷ floor 2 5 1 2 ∷ []) false false true 1) (1000 , 2006) (valid (route false 122 9 true ((2006 , 2002) ∷ (2002 , 1003) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route false 122 10 true ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1003) ∷ []) (1 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 0 3 2 2 ∷ floor 4 2 2 0 ∷ floor 6 1 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 2 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 255 false ([]) (floor 0 3 2 2 ∷ floor 4 2 2 0 ∷ floor 6 1 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 2 false ((1000 , 1002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1005 ∷ 2001 ∷ []) (floor 6 1 1 3 ∷ []) true false false 2) (1000 , 1004) (valid (route true 255 0 ((1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route true 255 1 ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 127 false (1005 ∷ 2001 ∷ []) (floor 6 1 1 3 ∷ []) true false false 2) (1000 , 1004) (valid (route true 255 0 false ((1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (1 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route true 255 1 true ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 1005) ∷ (1005 , 2003) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 128 true (1005 ∷ []) (floor 4 1 2 0 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 128 1 ((1000 , 2002) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 1 128 true (1005 ∷ []) (floor 4 1 2 0 ∷ []) true false true 2) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 128 1 true ((1000 , 2002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 127 false (2002 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 1 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 122 9 ((2006 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1000) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 2 127 false (2002 ∷ []) (floor 4 1 2 3 ∷ floor 5 5 1 3 ∷ []) true false true 2) (1000 , 2006) (valid (route false 122 9 false ((2006 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1000) ∷ []) (1 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 128 false (1006 ∷ 2003 ∷ []) (floor 2 5 1 0 ∷ floor 2 6 1 3 ∷ []) false true true 1) (1000 , 2002) (valid (route false 128 1 ((2002 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 3 128 false (1006 ∷ 2003 ∷ []) (floor 2 5 1 0 ∷ floor 2 6 1 3 ∷ []) false true true 1) (1000 , 2002) (valid (route false 128 1 false ((2002 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 255 11 ((2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 14 ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 255 11 true ((2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 14 true ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2003) ∷ (2003 , 1005) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2006 ∷ []) (floor 4 0 2 0 ∷ floor 5 6 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route true 0 5 ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 0 7 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (false , 1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false (2006 ∷ []) (floor 4 0 2 0 ∷ floor 5 6 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route true 0 5 false ((1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 0 7 false ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 2002) ∷ (2002 , 2005) ∷ (2005 , 1006) ∷ []) (1 ∷ 3 ∷ 1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 3 5 2 3 ∷ floor 5 1 1 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 128 10 ((2005 , 1000) ∷ (1000 , 1004) ∷ (1004 , 2001) ∷ (2001 , 1002) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 2 128 false ([]) (floor 3 5 2 3 ∷ floor 5 1 1 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 128 10 true ((2005 , 1000) ∷ (1000 , 1004) ∷ (1004 , 2001) ∷ (2001 , 1002) ∷ []) (1 ∷ 2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false ([]) (floor 0 3 1 3 ∷ floor 4 1 2 2 ∷ floor 5 0 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 1 ((1000 , 2004) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 0 false ([]) (floor 0 3 1 3 ∷ floor 4 1 2 2 ∷ floor 5 0 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 1 false ((1000 , 2004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2001 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route true 0 4 ((2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 122 5 ((1000 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false (2001 ∷ []) ([]) false false true 1) (1000 , 2004) (valid (route true 0 4 false ((2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 122 5 false ((1000 , 2004) ∷ (2004 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2003) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 2 1 0 ∷ floor 4 0 1 3 ∷ floor 6 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 2 ((1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 128 5 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 2 1 0 ∷ floor 4 0 1 3 ∷ floor 6 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route false 128 2 false ((1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (1 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 128 5 false ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1004) ∷ (1004 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 true (1004 ∷ []) ([]) true true true 1) (1000 , 1002) (valid (route false 122 2 ((1002 , 2002) ∷ []) (true , 1 ∷ []))) +_ : extend (link true 3 122 true (1004 ∷ []) ([]) true true true 1) (1000 , 1002) (valid (route false 122 2 true ((1002 , 2002) ∷ []) (1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (2002 ∷ 2006 ∷ []) ([]) false true true 3) (1000 , 1002) (valid (route false 128 10 ((1002 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 2 ∷ []))) - ≡ valid (route false 128 11 ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 127 false (2002 ∷ 2006 ∷ []) ([]) false true true 3) (1000 , 1002) (valid (route false 128 10 false ((1002 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 2 ∷ []))) + ≡ valid (route false 128 11 false ((1000 , 1002) ∷ (1002 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 0 false (2003 ∷ []) (floor 3 2 2 1 ∷ floor 5 3 2 0 ∷ []) false true true 3) (1000 , 2004) (valid (route false 255 0 ((2004 , 2005) ∷ []) (true , 1 ∷ []))) +_ : extend (link true 3 0 false (2003 ∷ []) (floor 3 2 2 1 ∷ floor 5 3 2 0 ∷ []) false true true 3) (1000 , 2004) (valid (route false 255 0 true ((2004 , 2005) ∷ []) (1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) (floor 4 1 2 0 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 3 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 127 false (2004 ∷ []) (floor 4 1 2 0 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 3 false ((1000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 false ([]) (floor 0 4 1 1 ∷ []) true true true 2) (1000 , 1004) (valid (route false 127 10 ((1004 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2003) ∷ []) (true , 1 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 2 128 false ([]) (floor 0 4 1 1 ∷ []) true true true 2) (1000 , 1004) (valid (route false 127 10 true ((1004 , 2006) ∷ (2006 , 1000) ∷ (1000 , 2003) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (2005 ∷ []) (floor 3 0 1 2 ∷ []) false false true 3) (1000 , 2004) (valid (route true 122 5 ((2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (2005 ∷ []) (floor 3 0 1 2 ∷ []) false false true 3) (1000 , 2004) (valid (route true 122 5 false ((2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 false ((1000 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2001) ∷ (2001 , 1003) ∷ (1003 , 1005) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 128 true ([]) (floor 0 1 2 3 ∷ floor 6 4 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 128 5 ((2002 , 2031) ∷ (2031 , 1010) ∷ (1010 , 2011) ∷ (2011 , 1027) ∷ (1027 , 2022) ∷ (2022 , 1040) ∷ (1040 , 1029) ∷ (1029 , 1020) ∷ (1020 , 1017) ∷ (1017 , 1001) ∷ (1001 , 1007) ∷ (1007 , 1037) ∷ (1037 , 2019) ∷ (2019 , 2015) ∷ (2015 , 2039) ∷ (2039 , 2026) ∷ (2026 , 2016) ∷ (2016 , 1013) ∷ (1013 , 1002) ∷ (1002 , 2038) ∷ (2038 , 1008) ∷ (1008 , 2018) ∷ (2018 , 2036) ∷ (2036 , 2014) ∷ (2014 , 1004) ∷ (1004 , 2033) ∷ (2033 , 2003) ∷ (2003 , 1034) ∷ (1034 , 2032) ∷ (2032 , 1023) ∷ (1023 , 1009) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 4 128 true ([]) (floor 0 1 2 3 ∷ floor 6 4 2 1 ∷ []) false false true 1) (1000 , 2002) (valid (route true 128 5 false ((2002 , 2031) ∷ (2031 , 1010) ∷ (1010 , 2011) ∷ (2011 , 1027) ∷ (1027 , 2022) ∷ (2022 , 1040) ∷ (1040 , 1029) ∷ (1029 , 1020) ∷ (1020 , 1017) ∷ (1017 , 1001) ∷ (1001 , 1007) ∷ (1007 , 1037) ∷ (1037 , 2019) ∷ (2019 , 2015) ∷ (2015 , 2039) ∷ (2039 , 2026) ∷ (2026 , 2016) ∷ (2016 , 1013) ∷ (1013 , 1002) ∷ (1002 , 2038) ∷ (2038 , 1008) ∷ (1008 , 2018) ∷ (2018 , 2036) ∷ (2036 , 2014) ∷ (2014 , 1004) ∷ (1004 , 2033) ∷ (2033 , 2003) ∷ (2003 , 1034) ∷ (1034 , 2032) ∷ (2032 , 1023) ∷ (1023 , 1009) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (1003 ∷ 1006 ∷ []) (floor 4 5 2 3 ∷ floor 6 5 1 2 ∷ []) false false false 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 false (1003 ∷ 1006 ∷ []) (floor 4 5 2 3 ∷ floor 6 5 1 2 ∷ []) false false false 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 128 false (1003 ∷ []) ([]) false false true 3) (1000 , 1001) (valid (route false 0 0 ((1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 128 2 ((1000 , 1001) ∷ (1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 2 128 false (1003 ∷ []) ([]) false false true 3) (1000 , 1001) (valid (route false 0 0 false ((1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 128 2 false ((1000 , 1001) ∷ (1001 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1004) ∷ (1004 , 2002) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 true ([]) ([]) false true false 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 4 0 true ([]) ([]) false true false 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 122 false ([]) (floor 2 2 2 1 ∷ floor 6 2 2 0 ∷ []) false false false 3) (1000 , 2001) (valid (route false 122 0 ((2001 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1002) ∷ []) (true , 1 ∷ 2 ∷ 3 ∷ []))) +_ : extend (link true 4 122 false ([]) (floor 2 2 2 1 ∷ floor 6 2 2 0 ∷ []) false false false 3) (1000 , 2001) (valid (route false 122 0 true ((2001 , 1001) ∷ (1001 , 1006) ∷ (1006 , 1002) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 0 true (2003 ∷ 2005 ∷ []) (floor 1 1 1 0 ∷ floor 6 5 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 128 7 ((2004 , 1004) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 128 10 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 2 ∷ 1 ∷ [])) +_ : extend (link true 3 0 true (2003 ∷ 2005 ∷ []) (floor 1 1 1 0 ∷ floor 6 5 2 1 ∷ []) false true true 2) (1000 , 2004) (valid (route false 128 7 false ((2004 , 1004) ∷ []) (1 ∷ []))) + ≡ valid (route true 128 10 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 6 0 2 2 ∷ floor 6 6 2 1 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 6 0 2 2 ∷ floor 6 6 2 1 ∷ []) false true true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 false ((1000 , 1003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (2005 ∷ []) ([]) true true true 1) (1000 , 2005) (valid (route false 122 4 ((2005 , 2003) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 127 8 ((1000 , 2005) ∷ (2005 , 2003) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ : extend (link true 4 127 false (2005 ∷ []) ([]) true true true 1) (1000 , 2005) (valid (route false 122 4 false ((2005 , 2003) ∷ []) (2 ∷ []))) + ≡ valid (route true 127 8 true ((1000 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 0 2 1 0 ∷ floor 1 4 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 1 ((1000 , 1001) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 0 2 1 0 ∷ floor 1 4 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 1 false ((1000 , 1001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 127 5 ((2003 , 1004) ∷ (1004 , 2006) ∷ []) (false , 3 ∷ 3 ∷ []))) - ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 122 false (2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 127 5 false ((2003 , 1004) ∷ (1004 , 2006) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1004) ∷ (1004 , 2006) ∷ []) (1 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 3 6 1 3 ∷ []) false true true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 1 ((1000 , 1005) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 122 false ([]) (floor 3 6 1 3 ∷ []) false true true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 1 false ((1000 , 1005) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) ([]) false false true 1) (1000 , 2004) (valid (route false 127 4 ((2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 127 5 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 1 122 false ([]) ([]) false false true 1) (1000 , 2004) (valid (route false 127 4 false ((2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 127 5 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2002) ∷ (2002 , 1006) ∷ []) (1 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) ([]) false false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 false ([]) ([]) false false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 127 true ([]) (floor 2 0 2 0 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 2006) (valid (route false 128 8 ((2006 , 2002) ∷ (2002 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) - ≡ valid (route true 128 9 ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 127 true ([]) (floor 2 0 2 0 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 2006) (valid (route false 128 8 false ((2006 , 2002) ∷ (2002 , 1004) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route true 128 9 true ((1000 , 2006) ∷ (2006 , 2002) ∷ (2002 , 1004) ∷ []) (3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 128 false (2002 ∷ []) (floor 2 4 2 3 ∷ floor 5 5 2 3 ∷ []) false true true 3) (1000 , 1004) (valid (route false 128 8 ((1004 , 2004) ∷ (2004 , 1006) ∷ []) (true , 1 ∷ 3 ∷ []))) +_ : extend (link true 1 128 false (2002 ∷ []) (floor 2 4 2 3 ∷ floor 5 5 2 3 ∷ []) false true true 3) (1000 , 1004) (valid (route false 128 8 true ((1004 , 2004) ∷ (2004 , 1006) ∷ []) (1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (2006 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 0 6 ((1003 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 4 127 false (2006 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 0 6 true ((1003 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ []) (1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 false ([]) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 4 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 4 255 false ([]) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 4 false ((1000 , 1002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1003 ∷ 1006 ∷ []) (floor 0 4 1 0 ∷ floor 4 0 2 2 ∷ floor 4 1 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 6 ((1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 128 10 ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 4 128 false (1003 ∷ 1006 ∷ []) (floor 0 4 1 0 ∷ floor 4 0 2 2 ∷ floor 4 1 1 1 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 6 false ((1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 128 10 false ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 2001) ∷ (2001 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 6 1 1 ∷ floor 2 6 2 1 ∷ floor 3 6 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 127 7 ((1003 , 1000) ∷ (1000 , 1004) ∷ []) (true , 1 ∷ 2 ∷ []))) +_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 6 1 1 ∷ floor 2 6 2 1 ∷ floor 3 6 1 0 ∷ []) true true true 2) (1000 , 1003) (valid (route false 127 7 true ((1003 , 1000) ∷ (1000 , 1004) ∷ []) (1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (2005 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 255 0 ((2006 , 2004) ∷ (2004 , 1006) ∷ []) (false , 2 ∷ 3 ∷ []))) - ≡ valid (route false 255 4 ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 4 127 false (2005 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 255 0 false ((2006 , 2004) ∷ (2004 , 1006) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route false 255 4 false ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 false ([]) (floor 0 0 2 0 ∷ floor 2 6 2 0 ∷ floor 3 3 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 4 ((1000 , 2001) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 4 0 false ([]) (floor 0 0 2 0 ∷ floor 2 6 2 0 ∷ floor 3 3 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 4 true ((1000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 4 122 true (1005 ∷ 2006 ∷ []) (floor 1 2 1 1 ∷ floor 6 6 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route true 128 5 ((1003 , 1004) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 128 9 ((1000 , 1003) ∷ (1003 , 1004) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ : extend (link true 4 122 true (1005 ∷ 2006 ∷ []) (floor 1 2 1 1 ∷ floor 6 6 2 0 ∷ []) false false true 3) (1000 , 1003) (valid (route true 128 5 false ((1003 , 1004) ∷ []) (2 ∷ []))) + ≡ valid (route true 128 9 false ((1000 , 1003) ∷ (1003 , 1004) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ []) (floor 0 1 1 3 ∷ floor 1 0 2 3 ∷ floor 6 0 2 3 ∷ []) true false true 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 1 ((1000 , 2004) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 1 127 true (1003 ∷ []) (floor 0 1 1 3 ∷ floor 1 0 2 3 ∷ floor 6 0 2 3 ∷ []) true false true 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 1 true ((1000 , 2004) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2004 ∷ []) (floor 1 0 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 2 ∷ []) false true true 2) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 1 ((1000 , 1005) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 1 127 true (1003 ∷ 2004 ∷ []) (floor 1 0 1 3 ∷ floor 5 2 1 1 ∷ floor 6 5 2 2 ∷ []) false true true 2) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 1 false ((1000 , 1005) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 0 true (2001 ∷ 2005 ∷ []) (floor 2 4 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 255 11 ((1004 , 1005) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 255 13 ((1000 , 1004) ∷ (1004 , 1005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 2 0 true (2001 ∷ 2005 ∷ []) (floor 2 4 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 255 11 false ((1004 , 1005) ∷ []) (3 ∷ []))) + ≡ valid (route true 255 13 true ((1000 , 1004) ∷ (1004 , 1005) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 0 false (2002 ∷ []) (floor 1 6 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 127 9 ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 127 11 ((1000 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false (2002 ∷ []) (floor 1 6 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 127 9 true ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 127 11 true ((1000 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ (1002 , 2005) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1004 ∷ []) (floor 0 4 2 3 ∷ floor 1 3 1 0 ∷ floor 6 6 2 0 ∷ []) false false true 2) (1000 , 1005) (valid (route true 128 8 ((1005 , 2012) ∷ (2012 , 2029) ∷ (2029 , 2039) ∷ (2039 , 2028) ∷ (2028 , 2040) ∷ (2040 , 2011) ∷ (2011 , 2003) ∷ (2003 , 1024) ∷ (1024 , 2014) ∷ (2014 , 2002) ∷ (2002 , 2008) ∷ (2008 , 2015) ∷ (2015 , 1026) ∷ (1026 , 2007) ∷ (2007 , 1009) ∷ (1009 , 1038) ∷ (1038 , 2034) ∷ (2034 , 1022) ∷ (1022 , 2036) ∷ (2036 , 1001) ∷ (1001 , 2025) ∷ (2025 , 2020) ∷ (2020 , 1018) ∷ (1018 , 1013) ∷ (1013 , 1017) ∷ (1017 , 2023) ∷ (2023 , 1035) ∷ (1035 , 1027) ∷ (1027 , 2005) ∷ (2005 , 2016) ∷ (2016 , 1019) ∷ (1019 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ []))) +_ : extend (link true 4 127 false (1004 ∷ []) (floor 0 4 2 3 ∷ floor 1 3 1 0 ∷ floor 6 6 2 0 ∷ []) false false true 2) (1000 , 1005) (valid (route true 128 8 false ((1005 , 2012) ∷ (2012 , 2029) ∷ (2029 , 2039) ∷ (2039 , 2028) ∷ (2028 , 2040) ∷ (2040 , 2011) ∷ (2011 , 2003) ∷ (2003 , 1024) ∷ (1024 , 2014) ∷ (2014 , 2002) ∷ (2002 , 2008) ∷ (2008 , 2015) ∷ (2015 , 1026) ∷ (1026 , 2007) ∷ (2007 , 1009) ∷ (1009 , 1038) ∷ (1038 , 2034) ∷ (2034 , 1022) ∷ (1022 , 2036) ∷ (2036 , 1001) ∷ (1001 , 2025) ∷ (2025 , 2020) ∷ (2020 , 1018) ∷ (1018 , 1013) ∷ (1013 , 1017) ∷ (1017 , 2023) ∷ (2023 , 1035) ∷ (1035 , 1027) ∷ (1027 , 2005) ∷ (2005 , 2016) ∷ (2016 , 1019) ∷ (1019 , 2004) ∷ []) (1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 128 false (2004 ∷ []) (floor 0 1 1 3 ∷ floor 0 5 2 2 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 2 128 false (2004 ∷ []) (floor 0 1 1 3 ∷ floor 0 5 2 2 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 2 1 3 ∷ floor 3 3 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route false 122 8 ((1006 , 1002) ∷ (1002 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) - ≡ valid (route true 127 9 ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 127 false (1004 ∷ 2002 ∷ []) (floor 0 2 1 3 ∷ floor 3 3 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route false 122 8 false ((1006 , 1002) ∷ (1002 , 1004) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route true 127 9 true ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 1004) ∷ []) (3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 127 false (1005 ∷ 2003 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 255 3 ((2003 , 1006) ∷ (1006 , 2002) ∷ []) (false , 2 ∷ 3 ∷ []))) - ≡ valid (route true 255 4 ((1000 , 2003) ∷ (2003 , 1006) ∷ (1006 , 2002) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false (1005 ∷ 2003 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route true 255 3 false ((2003 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route true 255 4 false ((1000 , 2003) ∷ (2003 , 1006) ∷ (1006 , 2002) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 128 false (1006 ∷ []) (floor 2 1 1 3 ∷ floor 2 6 2 1 ∷ []) false false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 128 false (1006 ∷ []) (floor 2 1 1 3 ∷ floor 2 6 2 1 ∷ []) false false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (2001 ∷ []) (floor 2 6 2 3 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 1 ((1000 , 2003) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 1 122 false (2001 ∷ []) (floor 2 6 2 3 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 1 false ((1000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 127 true ([]) (floor 1 0 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 127 3 ((1000 , 1006) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 3 127 true ([]) (floor 1 0 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 127 3 true ((1000 , 1006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) ([]) true false true 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 2006) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 1 127 false ([]) ([]) true false true 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 true ((1000 , 2006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1002 ∷ []) (floor 4 5 1 1 ∷ []) true false true 3) (1000 , 2001) (valid (route false 122 2 ((2001 , 1006) ∷ (1006 , 1002) ∷ []) (true , 1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 127 false (1002 ∷ []) (floor 4 5 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 2004) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 255 true (1002 ∷ []) (floor 4 5 1 1 ∷ []) true false true 3) (1000 , 2001) (valid (route false 122 2 true ((2001 , 1006) ∷ (1006 , 1002) ∷ []) (1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 127 false (1002 ∷ []) (floor 4 5 1 1 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 false ((1000 , 2004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 2006) (valid (route false 127 11 ((2006 , 1006) ∷ []) (true , 1 ∷ []))) - ⊕ extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 1004) (valid (route false 127 11 ((1004 , 1006) ∷ []) (true , 1 ∷ []))) - ≡ valid (route false 128 12 ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (true , 1 ∷ 1 ∷ [])) +_ : extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 2006) (valid (route false 127 11 true ((2006 , 1006) ∷ []) (1 ∷ []))) + ⊕ extend (link true 1 128 false (1005 ∷ 2004 ∷ []) ([]) false false false 1) (1000 , 1004) (valid (route false 127 11 true ((1004 , 1006) ∷ []) (1 ∷ []))) + ≡ valid (route false 128 12 true ((1000 , 1004) ∷ (1004 , 1006) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 0 false (1005 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 255 6 ((1002 , 1000) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 4 127 true (1005 ∷ 2005 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 255 4 ((1003 , 2002) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 255 8 ((1000 , 1003) ∷ (1003 , 2002) ∷ []) (false , 1 ∷ 1 ∷ [])) +_ : extend (link true 1 0 false (1005 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 255 6 false ((1002 , 1000) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 127 true (1005 ∷ 2005 ∷ []) ([]) false true true 1) (1000 , 1003) (valid (route false 255 4 false ((1003 , 2002) ∷ []) (1 ∷ []))) + ≡ valid (route true 255 8 false ((1000 , 1003) ∷ (1003 , 2002) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 4 ((1000 , 2001) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 0 false (2002 ∷ []) (floor 0 1 2 0 ∷ floor 6 3 2 0 ∷ []) true false true 2) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 4 true ((1000 , 2001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 127 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 2) (1000 , 1001) (valid (route false 122 4 ((1001 , 1006) ∷ (1006 , 1003) ∷ []) (false , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 4 0 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 3) (1000 , 2005) (valid (route false 122 2 ((2005 , 2001) ∷ []) (false , 3 ∷ []))) - ≡ valid (route false 122 6 ((1000 , 2005) ∷ (2005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ : extend (link true 1 127 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 2) (1000 , 1001) (valid (route false 122 4 false ((1001 , 1006) ∷ (1006 , 1003) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 2 6 2 3 ∷ floor 5 0 2 2 ∷ []) false false true 3) (1000 , 2005) (valid (route false 122 2 false ((2005 , 2001) ∷ []) (3 ∷ []))) + ≡ valid (route false 122 6 false ((1000 , 2005) ∷ (2005 , 2001) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 2001) (valid (route true 128 6 ((2001 , 2003) ∷ []) (false , 3 ∷ []))) - ⊕ extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 1002) (valid (route true 128 6 ((1002 , 2003) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 128 10 ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 3 ∷ [])) +_ : extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 2001) (valid (route true 128 6 false ((2001 , 2003) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 0 false (1001 ∷ 2003 ∷ []) (floor 3 0 2 1 ∷ floor 4 1 1 1 ∷ []) false false true 3) (1000 , 1002) (valid (route true 128 6 false ((1002 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route true 128 10 false ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 false (2002 ∷ []) (floor 3 0 1 3 ∷ floor 3 6 1 3 ∷ []) true true false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 255 true (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 8 ((1001 , 1002) ∷ (1002 , 1005) ∷ []) (true , 3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 127 false (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 128 5 ((1004 , 2006) ∷ (2006 , 1005) ∷ []) (false , 3 ∷ 3 ∷ []))) - ≡ valid (route true 128 9 ((1000 , 1004) ∷ (1004 , 2006) ∷ (2006 , 1005) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 1 255 true (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) false false true 3) (1000 , 1001) (valid (route false 0 8 true ((1001 , 1002) ∷ (1002 , 1005) ∷ []) (3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 127 false (1006 ∷ []) (floor 2 3 1 2 ∷ floor 3 0 2 2 ∷ floor 4 5 1 2 ∷ []) true false true 2) (1000 , 1004) (valid (route true 128 5 false ((1004 , 2006) ∷ (2006 , 1005) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route true 128 9 true ((1000 , 1004) ∷ (1004 , 2006) ∷ (2006 , 1005) ∷ []) (2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 128 0 ((1003 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 0 true ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 0 2 ((1000 , 1006) ∷ []) (true , 3 ∷ [])) +_ : extend (link true 3 255 false ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) false true true 3) (1000 , 1003) (valid (route false 128 0 true ((1003 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 0 true ([]) (floor 0 1 1 2 ∷ floor 4 4 2 1 ∷ floor 5 2 1 2 ∷ []) true false true 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 0 2 true ((1000 , 1006) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1006 ∷ 2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 122 8 ((2003 , 1004) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 4 128 false (1006 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 1002) (valid (route true 128 0 ((1002 , 1004) ∷ (1004 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1001) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 128 9 ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ : extend (link true 1 128 false (1006 ∷ 2006 ∷ []) ([]) false false true 1) (1000 , 2003) (valid (route false 122 8 false ((2003 , 1004) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 128 false (1006 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 1002) (valid (route true 128 0 false ((1002 , 1004) ∷ (1004 , 2006) ∷ (2006 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 128 9 false ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1006 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route true 128 3 ((1004 , 1005) ∷ []) (true , 3 ∷ []))) - ⊕ extend (link true 2 0 false (1006 ∷ []) ([]) true false false 3) (1000 , 1002) (valid (route false 127 1 ((1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (true , 1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route false 127 3 ((1000 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 3 255 false (1006 ∷ []) ([]) false true false 1) (1000 , 1004) (valid (route true 128 3 true ((1004 , 1005) ∷ []) (3 ∷ []))) + ⊕ extend (link true 2 0 false (1006 ∷ []) ([]) true false false 3) (1000 , 1002) (valid (route false 127 1 true ((1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route false 127 3 true ((1000 , 1002) ∷ (1002 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2002) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 128 2 ((2006 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2002) (valid (route false 128 2 ((2002 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) +_ : extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2006) (valid (route false 128 2 false ((2006 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 127 false (2003 ∷ []) ([]) false true true 3) (1000 , 2002) (valid (route false 128 2 false ((2002 , 2005) ∷ (2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 3 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 255 false ([]) (floor 3 1 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 10 ((1005 , 2005) ∷ (2005 , 1002) ∷ []) (false , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 3 0 true ([]) (floor 3 1 1 3 ∷ []) true true true 2) (1000 , 2004) (valid (route false 122 11 ((2004 , 1004) ∷ (1004 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 ((1000 , 1005) ∷ (1005 , 2005) ∷ (2005 , 1002) ∷ []) (false , 2 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 3 1 1 3 ∷ []) false false true 2) (1000 , 1005) (valid (route false 255 10 false ((1005 , 2005) ∷ (2005 , 1002) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 3 0 true ([]) (floor 3 1 1 3 ∷ []) true true true 2) (1000 , 2004) (valid (route false 122 11 false ((2004 , 1004) ∷ (1004 , 2006) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 false ((1000 , 1005) ∷ (1005 , 2005) ∷ (2005 , 1002) ∷ []) (2 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 127 true (2002 ∷ []) (floor 6 5 1 1 ∷ []) false false false 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 2004) (valid (route false 0 8 ((2004 , 2002) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 1002) (valid (route false 0 8 ((1002 , 2002) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 255 12 ((1000 , 1002) ∷ (1002 , 2002) ∷ []) (true , 1 ∷ 2 ∷ [])) +_ : extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 2004) (valid (route false 0 8 false ((2004 , 2002) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 255 false ([]) ([]) true true true 1) (1000 , 1002) (valid (route false 0 8 false ((1002 , 2002) ∷ []) (2 ∷ []))) + ≡ valid (route false 255 12 true ((1000 , 1002) ∷ (1002 , 2002) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 127 true ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 2006) (valid (route false 127 0 ((2006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1005) ∷ (1005 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 2 122 false ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 2 ((1000 , 1002) ∷ []) (true , 2 ∷ [])) +_ : extend (link true 1 127 true ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 2006) (valid (route false 127 0 false ((2006 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1005) ∷ (1005 , 2004) ∷ []) (1 ∷ 1 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 122 false ([]) (floor 0 3 1 1 ∷ floor 1 2 2 0 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 2 true ((1000 , 1002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 128 2 ((1003 , 1000) ∷ []) (true , 2 ∷ []))) - ⊕ extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 128 2 ((1001 , 1000) ∷ []) (true , 2 ∷ []))) +_ : extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1003) (valid (route false 128 2 true ((1003 , 1000) ∷ []) (2 ∷ []))) + ⊕ extend (link true 3 128 true (2004 ∷ []) (floor 2 3 2 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 128 2 true ((1001 , 1000) ∷ []) (2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 122 10 ((2004 , 1003) ∷ []) (true , 3 ∷ []))) - ⊕ extend (link true 4 128 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false false 2) (1000 , 1005) (valid (route true 128 2 ((1005 , 2006) ∷ []) (true , 2 ∷ []))) - ≡ valid (route false 122 12 ((1000 , 2004) ∷ (2004 , 1003) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 122 10 true ((2004 , 1003) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 128 false (1004 ∷ 2005 ∷ []) (floor 0 0 2 2 ∷ floor 3 0 1 1 ∷ []) false false false 2) (1000 , 1005) (valid (route true 128 2 true ((1005 , 2006) ∷ []) (2 ∷ []))) + ≡ valid (route false 122 12 true ((1000 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route true 128 7 ((1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 2006) (valid (route true 128 7 ((2006 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route true 128 9 ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 1002) (valid (route true 128 7 true ((1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 127 true ([]) (floor 2 4 2 0 ∷ floor 3 3 2 2 ∷ []) false false true 2) (1000 , 2006) (valid (route true 128 7 true ((2006 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (1 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route true 128 9 true ((1000 , 1002) ∷ (1002 , 1006) ∷ (1006 , 2004) ∷ (2004 , 2002) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2003) (valid (route true 128 6 ((2003 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2002) (valid (route true 128 6 ((2002 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2003) (valid (route true 128 6 true ((2003 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false ([]) (floor 5 4 2 3 ∷ []) false true true 2) (1000 , 2002) (valid (route true 128 6 true ((2002 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2002) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 127 false (1006 ∷ []) ([]) false true false 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 128 false (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) true true false 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 122 1 ((1000 , 2003) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 2 128 false (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) true true false 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 0 6 1 0 ∷ floor 2 4 2 2 ∷ floor 3 2 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 122 1 false ((1000 , 2003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 3 2 2 0 ∷ []) false false true 3) (1000 , 1005) (valid (route true 0 7 ((1005 , 2006) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 3 2 2 0 ∷ []) false false false 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 122 9 ((1000 , 1005) ∷ (1005 , 2006) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 3 2 2 0 ∷ []) false false true 3) (1000 , 1005) (valid (route true 0 7 false ((1005 , 2006) ∷ []) (2 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 3 2 2 0 ∷ []) false false false 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 122 9 false ((1000 , 1005) ∷ (1005 , 2006) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1005 ∷ 2002 ∷ []) ([]) false false false 2) (1000 , 2003) (valid (route false 127 3 ((2003 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1005 ∷ 2002 ∷ []) ([]) false true true 3) (1000 , 1006) (valid (route true 122 1 ((1006 , 2005) ∷ (2005 , 2001) ∷ []) (false , 1 ∷ 3 ∷ []))) - ≡ valid (route true 122 4 ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2001) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 1 255 false (1005 ∷ 2002 ∷ []) ([]) false false false 2) (1000 , 2003) (valid (route false 127 3 false ((2003 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1005 ∷ 2002 ∷ []) ([]) false true true 3) (1000 , 1006) (valid (route true 122 1 false ((1006 , 2005) ∷ (2005 , 2001) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route true 122 4 false ((1000 , 1006) ∷ (1006 , 2005) ∷ (2005 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 2001) ∷ []) (true , 2 ∷ []))) - ⊕ extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 127 8 ((1004 , 2001) ∷ []) (true , 2 ∷ []))) - ≡ valid (route false 128 10 ((1000 , 2003) ∷ (2003 , 2001) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ : extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 2001) ∷ []) (2 ∷ []))) + ⊕ extend (link true 2 128 false (1005 ∷ 2006 ∷ []) (floor 0 6 1 2 ∷ floor 6 4 1 0 ∷ []) false false false 3) (1000 , 1004) (valid (route false 127 8 true ((1004 , 2001) ∷ []) (2 ∷ []))) + ≡ valid (route false 128 10 true ((1000 , 2003) ∷ (2003 , 2001) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 true ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) true true false 3) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 127 false ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) false true true 3) (1000 , 1001) (valid (route false 128 9 ((1001 , 1000) ∷ (1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (true , 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 3 127 true ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) true true false 3) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 127 false ([]) (floor 0 4 1 0 ∷ floor 2 1 1 0 ∷ floor 4 4 2 1 ∷ []) false true true 3) (1000 , 1001) (valid (route false 128 9 true ((1001 , 1000) ∷ (1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1003) (valid (route false 127 5 ((1003 , 1002) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1004) (valid (route false 127 5 ((1004 , 1002) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 127 6 ((1000 , 1004) ∷ (1004 , 1002) ∷ []) (false , 2 ∷ 2 ∷ [])) +_ : extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1003) (valid (route false 127 5 false ((1003 , 1002) ∷ []) (2 ∷ []))) + ⊕ extend (link true 1 0 false (1001 ∷ 1003 ∷ []) (floor 0 0 1 1 ∷ floor 2 2 2 0 ∷ []) false false true 2) (1000 , 1004) (valid (route false 127 5 false ((1004 , 1002) ∷ []) (2 ∷ []))) + ≡ valid (route false 127 6 false ((1000 , 1004) ∷ (1004 , 1002) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 3 127 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 127 false ([]) ([]) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 false ((1000 , 1002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 1003) (valid (route true 0 9 ((1003 , 2004) ∷ []) (true , 1 ∷ []))) - ⊕ extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 2001) (valid (route true 0 9 ((2001 , 2004) ∷ []) (true , 1 ∷ []))) - ≡ valid (route true 128 13 ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (true , 2 ∷ 1 ∷ [])) +_ : extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 1003) (valid (route true 0 9 true ((1003 , 2004) ∷ []) (1 ∷ []))) + ⊕ extend (link true 4 128 false ([]) (floor 1 2 2 1 ∷ floor 1 6 1 3 ∷ floor 5 3 1 1 ∷ []) false false true 2) (1000 , 2001) (valid (route true 0 9 true ((2001 , 2004) ∷ []) (1 ∷ []))) + ≡ valid (route true 128 13 true ((1000 , 2001) ∷ (2001 , 2004) ∷ []) (2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2005) (valid (route false 122 3 ((2005 , 1001) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 1006) (valid (route false 122 3 ((1006 , 1001) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 122 7 ((1000 , 2005) ∷ (2005 , 1001) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ : extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 2005) (valid (route false 122 3 false ((2005 , 1001) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 122 false (2003 ∷ []) (floor 5 6 1 2 ∷ floor 6 6 2 1 ∷ []) true true true 3) (1000 , 1006) (valid (route false 122 3 false ((1006 , 1001) ∷ []) (2 ∷ []))) + ≡ valid (route false 122 7 true ((1000 , 2005) ∷ (2005 , 1001) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 2 ((2003 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 1004) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 4 255 true (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 128 3 ((2001 , 1001) ∷ (1001 , 1005) ∷ []) (false , 2 ∷ 2 ∷ []))) - ≡ valid (route true 255 7 ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 122 false (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) false false true 3) (1000 , 2003) (valid (route false 0 2 true ((2003 , 1000) ∷ (1000 , 1003) ∷ (1003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 4 255 true (2001 ∷ []) (floor 3 4 2 0 ∷ floor 5 0 2 1 ∷ []) true false true 1) (1000 , 2001) (valid (route false 128 3 false ((2001 , 1001) ∷ (1001 , 1005) ∷ []) (2 ∷ 2 ∷ []))) + ≡ valid (route true 255 7 true ((1000 , 2001) ∷ (2001 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1005) (valid (route false 127 2 ((1005 , 1000) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1004) (valid (route false 127 2 ((1004 , 1000) ∷ []) (false , 1 ∷ []))) +_ : extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1005) (valid (route false 127 2 false ((1005 , 1000) ∷ []) (1 ∷ []))) + ⊕ extend (link true 3 122 true ([]) (floor 1 4 1 0 ∷ floor 2 3 2 3 ∷ floor 4 5 1 3 ∷ []) true false true 1) (1000 , 1004) (valid (route false 127 2 false ((1004 , 1000) ∷ []) (1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 true (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true false 3) (1000 , 2004) (valid (route false 0 6 ((2004 , 2002) ∷ (2002 , 2005) ∷ []) (true , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 2 0 false (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true true 1) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 2 ((1000 , 1003) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 4 255 true (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true false 3) (1000 , 2004) (valid (route false 0 6 true ((2004 , 2002) ∷ (2002 , 2005) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 2 0 false (2006 ∷ []) (floor 1 3 2 3 ∷ floor 3 1 1 3 ∷ floor 6 5 2 3 ∷ []) false true true 1) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 2 false ((1000 , 1003) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 128 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 8 ((2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 3 127 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 255 4 ((2004 , 2003) ∷ (2003 , 2006) ∷ []) (false , 3 ∷ 1 ∷ []))) - ≡ valid (route true 128 10 ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 128 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 8 true ((2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 3 127 true (1005 ∷ []) (floor 0 1 2 3 ∷ []) false true true 1) (1000 , 2004) (valid (route false 255 4 false ((2004 , 2003) ∷ (2003 , 2006) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route true 128 10 true ((1000 , 2006) ∷ (2006 , 1005) ∷ (1005 , 2001) ∷ (2001 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1006) (valid (route false 122 11 ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1003) (valid (route false 122 11 ((1003 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ []))) +_ : extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1006) (valid (route false 122 11 false ((1006 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (3 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 2 122 true ([]) (floor 2 4 1 2 ∷ floor 3 3 2 2 ∷ floor 4 1 1 3 ∷ []) false false false 2) (1000 , 1003) (valid (route false 122 11 false ((1003 , 1004) ∷ (1004 , 1001) ∷ (1001 , 1002) ∷ []) (3 ∷ 2 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 128 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 4 ((2003 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1005) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 122 3 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 128 false ([]) (floor 0 5 1 2 ∷ floor 1 0 1 1 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 4 false ((2003 , 1003) ∷ (1003 , 1004) ∷ (1004 , 1005) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 122 3 false ((1000 , 1004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 127 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 122 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 122 6 ((2003 , 1004) ∷ []) (true , 3 ∷ []))) - ≡ valid (route false 122 7 ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 3 127 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false false 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 122 false (2006 ∷ []) (floor 0 3 2 0 ∷ []) false false true 2) (1000 , 2003) (valid (route false 122 6 true ((2003 , 1004) ∷ []) (3 ∷ []))) + ≡ valid (route false 122 7 true ((1000 , 2003) ∷ (2003 , 1004) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 127 true (2005 ∷ []) ([]) true false false 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 127 false (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false true 1) (1000 , 1001) (valid (route false 122 9 ((1001 , 2004) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 3 127 true (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false false 2) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 127 false (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false true 1) (1000 , 1001) (valid (route false 122 9 false ((1001 , 2004) ∷ []) (1 ∷ []))) + ⊕ extend (link true 3 127 true (1003 ∷ []) (floor 1 4 2 2 ∷ floor 5 0 1 1 ∷ floor 5 1 1 3 ∷ []) false false false 2) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 128 false (2003 ∷ 2006 ∷ []) ([]) true true false 2) (1000 , 2003) (valid (route false 128 9 ((2003 , 1006) ∷ (1006 , 1000) ∷ (1000 , 2005) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (2003 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 3 ((1000 , 1002) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 128 false (2003 ∷ 2006 ∷ []) ([]) true true false 2) (1000 , 2003) (valid (route false 128 9 false ((2003 , 1006) ∷ (1006 , 1000) ∷ (1000 , 2005) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (2003 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 3 false ((1000 , 1002) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 4 ((1000 , 1003) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 false ([]) (floor 2 3 1 2 ∷ []) false false true 3) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 4 false ((1000 , 1003) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1001) (valid (route true 127 4 ((1001 , 2001) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1002) (valid (route true 127 4 ((1002 , 2001) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 127 7 ((1000 , 1001) ∷ (1001 , 2001) ∷ []) (true , 2 ∷ 2 ∷ [])) +_ : extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1001) (valid (route true 127 4 false ((1001 , 2001) ∷ []) (2 ∷ []))) + ⊕ extend (link true 3 122 false ([]) (floor 2 6 2 1 ∷ []) true false true 2) (1000 , 1002) (valid (route true 127 4 false ((1002 , 2001) ∷ []) (2 ∷ []))) + ≡ valid (route true 127 7 true ((1000 , 1001) ∷ (1001 , 2001) ∷ []) (2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 255 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 8 ((1004 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2001) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 122 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false false 3) (1000 , 2002) (valid (route false 255 1 ((2002 , 1002) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 255 5 ((1000 , 2002) ∷ (2002 , 1002) ∷ []) (false , 3 ∷ 2 ∷ [])) +_ : extend (link true 4 255 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 8 false ((1004 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2001) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2006 ∷ []) (floor 1 6 1 1 ∷ []) false false false 3) (1000 , 2002) (valid (route false 255 1 false ((2002 , 1002) ∷ []) (2 ∷ []))) + ≡ valid (route false 255 5 false ((1000 , 2002) ∷ (2002 , 1002) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false ([]) (floor 0 6 1 3 ∷ []) false false true 3) (1000 , 2002) (valid (route false 0 9 ((2002 , 2004) ∷ (2004 , 2006) ∷ []) (true , 1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 0 false ([]) (floor 0 6 1 3 ∷ []) true true true 1) (1000 , 1005) (valid (route false 128 2 ((1005 , 2001) ∷ (2001 , 1004) ∷ []) (false , 2 ∷ 1 ∷ []))) - ≡ valid (route false 127 12 ((1000 , 2002) ∷ (2002 , 2004) ∷ (2004 , 2006) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 127 false ([]) (floor 0 6 1 3 ∷ []) false false true 3) (1000 , 2002) (valid (route false 0 9 true ((2002 , 2004) ∷ (2004 , 2006) ∷ []) (1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 0 false ([]) (floor 0 6 1 3 ∷ []) true true true 1) (1000 , 1005) (valid (route false 128 2 false ((1005 , 2001) ∷ (2001 , 1004) ∷ []) (2 ∷ 1 ∷ []))) + ≡ valid (route false 127 12 true ((1000 , 2002) ∷ (2002 , 2004) ∷ (2004 , 2006) ∷ []) (3 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 1004) (valid (route true 0 10 ((1004 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 2 ∷ []))) - ⊕ extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 2001) (valid (route true 0 10 ((2001 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 2 ∷ []))) - ≡ valid (route true 255 13 ((1000 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2001) ∷ []) (true , 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 1004) (valid (route true 0 10 true ((1004 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ []))) + ⊕ extend (link true 3 255 false (1004 ∷ 2004 ∷ []) (floor 1 2 1 2 ∷ floor 1 6 2 0 ∷ []) true false false 1) (1000 , 2001) (valid (route true 0 10 true ((2001 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route true 255 13 true ((1000 , 2001) ∷ (2001 , 2003) ∷ (2003 , 2001) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 0 3 ((2001 , 2002) ∷ []) (true , 3 ∷ []))) - ⊕ extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 1006) (valid (route false 0 3 ((1006 , 2002) ∷ []) (true , 3 ∷ []))) - ≡ valid (route false 0 6 ((1000 , 2001) ∷ (2001 , 2002) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 2001) (valid (route false 0 3 true ((2001 , 2002) ∷ []) (3 ∷ []))) + ⊕ extend (link true 3 0 false ([]) ([]) false false true 2) (1000 , 1006) (valid (route false 0 3 true ((1006 , 2002) ∷ []) (3 ∷ []))) + ≡ valid (route false 0 6 true ((1000 , 2001) ∷ (2001 , 2002) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1003) (valid (route true 255 6 ((1003 , 1005) ∷ (1005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ []))) - ⊕ extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route true 255 6 ((1004 , 1005) ∷ (1005 , 2001) ∷ []) (false , 3 ∷ 3 ∷ []))) - ≡ valid (route true 255 9 ((1000 , 1003) ∷ (1003 , 1005) ∷ (1005 , 2001) ∷ []) (false , 1 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1003) (valid (route true 255 6 false ((1003 , 1005) ∷ (1005 , 2001) ∷ []) (3 ∷ 3 ∷ []))) + ⊕ extend (link true 3 128 true (1001 ∷ 2006 ∷ []) (floor 3 0 1 2 ∷ floor 5 3 2 0 ∷ floor 6 5 1 1 ∷ []) false false true 1) (1000 , 1004) (valid (route true 255 6 false ((1004 , 1005) ∷ (1005 , 2001) ∷ []) (3 ∷ 3 ∷ []))) + ≡ valid (route true 255 9 false ((1000 , 1003) ∷ (1003 , 1005) ∷ (1005 , 2001) ∷ []) (1 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 1001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 3 ((1000 , 1001) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 false ([]) (floor 1 5 2 0 ∷ floor 5 3 1 1 ∷ []) true false true 1) (1000 , 1001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 3 true ((1000 , 1001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false false true 3) (1000 , 2002) (valid (route true 127 1 ((2002 , 1002) ∷ []) (true , 1 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false true true 3) (1000 , 1006) (valid (route false 0 1 ((1006 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 1 ∷ []))) - ≡ valid (route true 122 2 ((1000 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2002) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false false true 3) (1000 , 2002) (valid (route true 127 1 true ((2002 , 1002) ∷ []) (1 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ 2002 ∷ []) (floor 5 2 2 3 ∷ []) false true true 3) (1000 , 1006) (valid (route false 0 1 false ((1006 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route true 122 2 false ((1000 , 1006) ∷ (1006 , 2003) ∷ (2003 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2006) (valid (route false 255 7 ((2006 , 1005) ∷ []) (true , 3 ∷ []))) - ⊕ extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2001) (valid (route false 255 7 ((2001 , 1005) ∷ []) (true , 3 ∷ []))) - ≡ valid (route false 255 11 ((1000 , 2001) ∷ (2001 , 1005) ∷ []) (true , 3 ∷ 3 ∷ [])) +_ : extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2006) (valid (route false 255 7 true ((2006 , 1005) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 122 false ([]) ([]) false false true 3) (1000 , 2001) (valid (route false 255 7 true ((2001 , 1005) ∷ []) (3 ∷ []))) + ≡ valid (route false 255 11 true ((1000 , 2001) ∷ (2001 , 1005) ∷ []) (3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 2005) (valid (route true 122 10 ((2005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 1002) (valid (route true 122 10 ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route true 122 11 ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 2005) (valid (route true 122 10 true ((2005 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 122 true (2006 ∷ []) (floor 3 6 2 3 ∷ floor 4 6 1 0 ∷ floor 5 5 1 1 ∷ []) true false false 3) (1000 , 1002) (valid (route true 122 10 true ((1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (1 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route true 122 11 true ((1000 , 1002) ∷ (1002 , 2002) ∷ (2002 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1005) ∷ []) (3 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 255 true (1004 ∷ []) ([]) true false false 1) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 255 true (1004 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 127 11 ((2001 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1005) ∷ []) (true , 2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 3 255 true (1004 ∷ []) ([]) true false false 1) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 255 true (1004 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 127 11 true ((2001 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1001) ∷ (1001 , 1005) ∷ []) (2 ∷ 2 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 1002) (valid (route true 128 2 ((1002 , 1001) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 2001) (valid (route true 128 2 ((2001 , 1001) ∷ []) (false , 1 ∷ []))) - ≡ valid (route true 255 4 ((1000 , 2001) ∷ (2001 , 1001) ∷ []) (true , 3 ∷ 1 ∷ [])) +_ : extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 1002) (valid (route true 128 2 false ((1002 , 1001) ∷ []) (1 ∷ []))) + ⊕ extend (link true 2 255 false (1003 ∷ []) (floor 0 6 1 3 ∷ []) true true true 3) (1000 , 2001) (valid (route true 128 2 false ((2001 , 1001) ∷ []) (1 ∷ []))) + ≡ valid (route true 255 4 true ((1000 , 2001) ∷ (2001 , 1001) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 true (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false true true 3) (1000 , 2004) (valid (route false 128 6 ((2004 , 2002) ∷ (2002 , 2003) ∷ []) (true , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 1 255 false (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 1 ((1000 , 1002) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 0 true (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false true true 3) (1000 , 2004) (valid (route false 128 6 true ((2004 , 2002) ∷ (2002 , 2003) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 1 255 false (1005 ∷ 2005 ∷ []) (floor 6 3 2 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 1 false ((1000 , 1002) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2001) (valid (route false 0 2 ((2001 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2002) (valid (route false 0 2 ((2002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ []))) +_ : extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2001) (valid (route false 0 2 true ((2001 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ []) ([]) true true true 3) (1000 , 2002) (valid (route false 0 2 true ((2002 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 1002) (valid (route false 0 0 ((1002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 0 ((2005 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) +_ : extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 1002) (valid (route false 0 0 false ((1002 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 1 255 false (1004 ∷ 2001 ∷ []) (floor 5 2 1 1 ∷ floor 5 4 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 0 false ((2005 , 1005) ∷ (1005 , 2004) ∷ (2004 , 2006) ∷ (2006 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 true (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 127 5 ((1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 128 false (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route true 122 2 ((1006 , 1002) ∷ (1002 , 1003) ∷ []) (false , 1 ∷ 2 ∷ []))) - ≡ valid (route true 127 9 ((1000 , 1001) ∷ (1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 4 0 true (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) false false true 3) (1000 , 1001) (valid (route false 127 5 false ((1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 128 false (1002 ∷ []) (floor 1 4 2 1 ∷ floor 5 3 2 2 ∷ floor 6 5 1 3 ∷ []) true false false 3) (1000 , 1006) (valid (route true 122 2 false ((1006 , 1002) ∷ (1002 , 1003) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route true 127 9 false ((1000 , 1001) ∷ (1001 , 1016) ∷ (1016 , 1034) ∷ (1034 , 2001) ∷ (2001 , 2027) ∷ (2027 , 2037) ∷ (2037 , 1007) ∷ (1007 , 1022) ∷ (1022 , 1015) ∷ (1015 , 1014) ∷ (1014 , 1010) ∷ (1010 , 1033) ∷ (1033 , 2006) ∷ (2006 , 1023) ∷ (1023 , 1009) ∷ (1009 , 2039) ∷ (2039 , 2005) ∷ (2005 , 1026) ∷ (1026 , 1036) ∷ (1036 , 1031) ∷ (1031 , 2035) ∷ (2035 , 2024) ∷ (2024 , 2011) ∷ (2011 , 2018) ∷ (2018 , 1019) ∷ (1019 , 2008) ∷ (2008 , 1012) ∷ (1012 , 2013) ∷ (2013 , 2021) ∷ (2021 , 2032) ∷ (2032 , 2028) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 3 ((2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 127 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 7 ((2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 255 6 ((1000 , 2002) ∷ (2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 3 255 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false false 2) (1000 , 2002) (valid (route false 127 3 false ((2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 127 false (1005 ∷ 2001 ∷ []) (floor 2 6 2 3 ∷ floor 5 0 1 2 ∷ floor 5 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 7 false ((2005 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 255 6 false ((1000 , 2002) ∷ (2002 , 2005) ∷ (2005 , 2004) ∷ (2004 , 1003) ∷ []) (2 ∷ 3 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ []) false false true 3) (1000 , 1004) (valid (route false 122 6 ((1004 , 1003) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 2 127 false ([]) (floor 1 1 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 0 ((1002 , 1006) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 255 2 ((1000 , 1002) ∷ (1002 , 1006) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ : extend (link true 2 128 true ([]) (floor 1 1 2 1 ∷ []) false false true 3) (1000 , 1004) (valid (route false 122 6 false ((1004 , 1003) ∷ []) (1 ∷ []))) + ⊕ extend (link true 2 127 false ([]) (floor 1 1 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 0 false ((1002 , 1006) ∷ []) (2 ∷ []))) + ≡ valid (route false 255 2 false ((1000 , 1002) ∷ (1002 , 1006) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 128 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 3) (1000 , 2006) (valid (route false 122 5 ((2006 , 1000) ∷ (1000 , 1002) ∷ []) (false , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 1 122 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 2) (1000 , 1001) (valid (route false 255 10 ((1001 , 2003) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 255 11 ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (false , 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 3) (1000 , 2006) (valid (route false 122 5 false ((2006 , 1000) ∷ (1000 , 1002) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 1 122 false (1001 ∷ []) (floor 4 3 2 0 ∷ []) false true false 2) (1000 , 1001) (valid (route false 255 10 false ((1001 , 2003) ∷ []) (3 ∷ []))) + ≡ valid (route true 255 11 false ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false true true 2) (1000 , 1006) (valid (route true 255 5 ((1006 , 2006) ∷ (2006 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 1 128 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 128 1 ((1000 , 1004) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 122 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false true true 2) (1000 , 1006) (valid (route true 255 5 false ((1006 , 2006) ∷ (2006 , 1001) ∷ (1001 , 1003) ∷ (1003 , 2005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 1 128 false (1001 ∷ []) (floor 4 4 2 0 ∷ []) false false true 1) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 128 1 false ((1000 , 1004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 127 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 255 2 ((2002 , 2004) ∷ (2004 , 2005) ∷ []) (true , 2 ∷ 3 ∷ []))) - ≡ valid (route false 0 2 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 2 0 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 127 false ([]) (floor 0 2 1 3 ∷ floor 0 3 1 3 ∷ floor 5 1 1 2 ∷ []) false true true 3) (1000 , 2002) (valid (route false 255 2 true ((2002 , 2004) ∷ (2004 , 2005) ∷ []) (2 ∷ 3 ∷ []))) + ≡ valid (route false 0 2 false ((1000 , 1004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 2 122 true (2005 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 2001) (valid (route false 128 7 ((2001 , 1006) ∷ (1006 , 1005) ∷ []) (true , 1 ∷ 3 ∷ []))) - ⊕ extend (link true 2 255 false (2005 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1003) (valid (route false 0 0 ((1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route false 255 2 ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (true , 3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 122 true (2005 ∷ 2006 ∷ []) ([]) false false false 3) (1000 , 2001) (valid (route false 128 7 true ((2001 , 1006) ∷ (1006 , 1005) ∷ []) (1 ∷ 3 ∷ []))) + ⊕ extend (link true 2 255 false (2005 ∷ 2006 ∷ []) ([]) false false true 3) (1000 , 1003) (valid (route false 0 0 true ((1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route false 255 2 true ((1000 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 1001) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1001 ∷ []) ([]) false false true 3) (1000 , 1005) (valid (route false 0 4 ((1005 , 1000) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 3 127 false (1001 ∷ []) ([]) false false false 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 128 true (1001 ∷ []) ([]) false false true 3) (1000 , 1005) (valid (route false 0 4 false ((1005 , 1000) ∷ []) (1 ∷ []))) + ⊕ extend (link true 3 127 false (1001 ∷ []) ([]) false false false 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1002) (valid (route false 127 7 ((1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1005) (valid (route false 127 7 ((1005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ []))) - ≡ valid (route false 127 8 ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) +_ : extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1002) (valid (route false 127 7 false ((1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false ([]) ([]) false false false 3) (1000 , 1005) (valid (route false 127 7 false ((1005 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (2 ∷ 2 ∷ 1 ∷ []))) + ≡ valid (route false 127 8 false ((1000 , 1002) ∷ (1002 , 2006) ∷ (2006 , 2004) ∷ (2004 , 2003) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route true 128 10 ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 10 ((2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route true 255 11 ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 1006) (valid (route true 128 10 false ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 1 255 false ([]) (floor 2 3 1 0 ∷ floor 3 5 1 3 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 10 false ((2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route true 255 11 true ((1000 , 2003) ∷ (2003 , 1005) ∷ (1005 , 1002) ∷ (1002 , 1004) ∷ (1004 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 ((2001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 ((1002 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (true , 2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 2001) (valid (route false 0 0 true ((2001 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 4 255 false ([]) (floor 3 6 2 2 ∷ []) true false true 2) (1000 , 1002) (valid (route false 0 0 true ((1002 , 1003) ∷ (1003 , 2006) ∷ (2006 , 2005) ∷ (2005 , 2002) ∷ []) (2 ∷ 3 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) true false false 2) (1000 , 1003) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 127 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) false false false 1) (1000 , 2002) (valid (route false 255 3 ((2002 , 1004) ∷ (1004 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2006) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 1 122 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) true false false 2) (1000 , 1003) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 127 false (1003 ∷ 2005 ∷ []) (floor 1 2 2 1 ∷ []) false false false 1) (1000 , 2002) (valid (route false 255 3 false ((2002 , 1004) ∷ (1004 , 1005) ∷ (1005 , 1000) ∷ (1000 , 2006) ∷ []) (1 ∷ 3 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 10 ((2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 4 255 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) true false true 2) (1000 , 1004) (valid (route false 122 3 ((1004 , 1000) ∷ (1000 , 1006) ∷ (1006 , 1005) ∷ (1005 , 2002) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 128 14 ((1000 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 4 128 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 10 false ((2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 4 255 false (1005 ∷ []) (floor 1 5 2 1 ∷ floor 3 1 2 3 ∷ []) true false true 2) (1000 , 1004) (valid (route false 122 3 false ((1004 , 1000) ∷ (1000 , 1006) ∷ (1006 , 1005) ∷ (1005 , 2002) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 128 14 false ((1000 , 2001) ∷ (2001 , 1005) ∷ (1005 , 1001) ∷ (1001 , 2006) ∷ []) (1 ∷ 2 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 9 ((2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 1006) (valid (route false 0 9 ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route false 122 12 ((1000 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (true , 2 ∷ 3 ∷ 3 ∷ 3 ∷ [])) +_ : extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 2004) (valid (route false 0 9 true ((2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 3 122 false ([]) ([]) true false false 2) (1000 , 1006) (valid (route false 0 9 true ((1006 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (3 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route false 122 12 true ((1000 , 2004) ∷ (2004 , 1005) ∷ (1005 , 1002) ∷ (1002 , 2001) ∷ []) (2 ∷ 3 ∷ 3 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 2001) (valid (route false 128 3 ((2001 , 2003) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 1005) (valid (route false 128 3 ((1005 , 2003) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 128 5 ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (true , 3 ∷ 2 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 2001) (valid (route false 128 3 false ((2001 , 2003) ∷ []) (2 ∷ []))) + ⊕ extend (link true 2 122 false ([]) (floor 1 6 1 3 ∷ floor 4 1 2 3 ∷ floor 5 6 2 2 ∷ []) true false true 3) (1000 , 1005) (valid (route false 128 3 false ((1005 , 2003) ∷ []) (2 ∷ []))) + ≡ valid (route false 128 5 true ((1000 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route true 0 1 ((1004 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 2003) (valid (route true 0 1 ((2003 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route true 0 1 false ((1004 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 122 false (2003 ∷ []) ([]) false false true 3) (1000 , 2003) (valid (route true 0 1 false ((2003 , 2001) ∷ (2001 , 1002) ∷ (1002 , 1000) ∷ (1000 , 1006) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 4 ((1000 , 2001) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 false ([]) (floor 0 2 2 2 ∷ floor 1 2 1 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 4 false ((1000 , 2001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2006) (valid (route true 127 11 ((2006 , 1005) ∷ []) (false , 3 ∷ []))) - ⊕ extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2004) (valid (route true 127 11 ((2004 , 1005) ∷ []) (false , 3 ∷ []))) - ≡ valid (route true 128 15 ((1000 , 2004) ∷ (2004 , 1005) ∷ []) (true , 2 ∷ 3 ∷ [])) +_ : extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2006) (valid (route true 127 11 false ((2006 , 1005) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 128 true (1006 ∷ []) (floor 2 2 2 2 ∷ []) true false true 2) (1000 , 2004) (valid (route true 127 11 false ((2004 , 1005) ∷ []) (3 ∷ []))) + ≡ valid (route true 128 15 true ((1000 , 2004) ∷ (2004 , 1005) ∷ []) (2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 8 ((2004 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2003) (valid (route false 255 8 ((2003 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2004) (valid (route false 255 8 true ((2004 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1003 ∷ 1006 ∷ []) (floor 1 6 1 2 ∷ []) true false true 3) (1000 , 2003) (valid (route false 255 8 true ((2003 , 2024) ∷ (2024 , 2037) ∷ (2037 , 2014) ∷ (2014 , 2006) ∷ (2006 , 2035) ∷ (2035 , 1031) ∷ (1031 , 1004) ∷ (1004 , 1032) ∷ (1032 , 2022) ∷ (2022 , 2001) ∷ (2001 , 2015) ∷ (2015 , 2030) ∷ (2030 , 2026) ∷ (2026 , 2034) ∷ (2034 , 1010) ∷ (1010 , 1011) ∷ (1011 , 2038) ∷ (2038 , 2021) ∷ (2021 , 2020) ∷ (2020 , 1027) ∷ (1027 , 2033) ∷ (2033 , 1029) ∷ (1029 , 1023) ∷ (1023 , 2005) ∷ (2005 , 1007) ∷ (1007 , 2040) ∷ (2040 , 1017) ∷ (1017 , 2003) ∷ (2003 , 1018) ∷ (1018 , 1036) ∷ (1036 , 1013) ∷ (1013 , 2028) ∷ []) (2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 3 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 true (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 3 ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 122 false (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) true true false 2) (1000 , 2005) (valid (route true 0 6 ((2005 , 2003) ∷ (2003 , 1000) ∷ []) (false , 1 ∷ 2 ∷ []))) +_ : extend (link true 3 122 true (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) false false true 1) (1000 , 1002) (valid (route false 255 3 false ((1002 , 2006) ∷ (2006 , 1000) ∷ (1000 , 1005) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 122 false (1001 ∷ 1002 ∷ []) (floor 0 2 2 1 ∷ floor 4 6 2 1 ∷ []) true true false 2) (1000 , 2005) (valid (route true 0 6 false ((2005 , 2003) ∷ (2003 , 1000) ∷ []) (1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 255 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 122 false (1006 ∷ []) ([]) false false true 2) (1000 , 2006) (valid (route false 127 11 ((2006 , 2001) ∷ (2001 , 1006) ∷ (1006 , 1000) ∷ []) (true , 3 ∷ 1 ∷ 2 ∷ []))) - ≡ valid (route false 255 4 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 4 255 false (1006 ∷ []) ([]) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 122 false (1006 ∷ []) ([]) false false true 2) (1000 , 2006) (valid (route false 127 11 true ((2006 , 2001) ∷ (2001 , 1006) ∷ (1006 , 1000) ∷ []) (3 ∷ 1 ∷ 2 ∷ []))) + ≡ valid (route false 255 4 false ((1000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 255 3 ((1000 , 2004) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 255 true ([]) (floor 0 1 1 0 ∷ floor 3 4 2 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 255 3 false ((1000 , 2004) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 2 ((1000 , 2001) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 127 false (2005 ∷ 2006 ∷ []) (floor 5 6 1 2 ∷ []) false true true 1) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 2 false ((1000 , 2001) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) ([]) true false true 1) (1000 , 1001) (valid (route false 0 7 ((1001 , 2003) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 4 122 true (1004 ∷ []) ([]) true false true 2) (1000 , 1005) (valid (route true 255 1 ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (true , 1 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 128 8 ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (true , 1 ∷ 1 ∷ [])) +_ : extend (link true 1 128 false (1004 ∷ []) ([]) true false true 1) (1000 , 1001) (valid (route false 0 7 false ((1001 , 2003) ∷ []) (1 ∷ []))) + ⊕ extend (link true 4 122 true (1004 ∷ []) ([]) true false true 2) (1000 , 1005) (valid (route true 255 1 true ((1005 , 2006) ∷ (2006 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 128 8 true ((1000 , 1001) ∷ (1001 , 2003) ∷ []) (1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2004) (valid (route true 127 10 ((2004 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2001) (valid (route true 127 10 ((2001 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (false , 3 ∷ 1 ∷ 3 ∷ []))) +_ : extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2004) (valid (route true 127 10 false ((2004 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 true ([]) ([]) false true true 3) (1000 , 2001) (valid (route true 127 10 false ((2001 , 2003) ∷ (2003 , 1004) ∷ (1004 , 1000) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 128 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 255 4 ((1003 , 2001) ∷ (2001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 4 128 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false true 3) (1000 , 1003) (valid (route false 255 4 false ((1003 , 2001) ∷ (2001 , 1000) ∷ (1000 , 2003) ∷ []) (1 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 0 3 1 2 ∷ floor 2 2 2 1 ∷ []) false false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 7 ((1006 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 7 ((2001 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) +_ : extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 1006) (valid (route false 0 7 false ((1006 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (2002 ∷ []) (floor 2 2 2 1 ∷ []) false true true 2) (1000 , 2001) (valid (route false 0 7 false ((2001 , 1001) ∷ (1001 , 1000) ∷ (1000 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 122 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 1 255 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false true true 1) (1000 , 2001) (valid (route true 122 2 ((2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 255 3 ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (false , 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 4 122 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false false false 2) (1000 , 2004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 1 255 false ([]) (floor 0 0 1 2 ∷ floor 2 6 2 0 ∷ floor 3 1 1 1 ∷ []) false true true 1) (1000 , 2001) (valid (route true 122 2 false ((2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 255 3 false ((1000 , 2001) ∷ (2001 , 2004) ∷ (2004 , 1001) ∷ (1001 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 128 true (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 0 5 ((2004 , 2005) ∷ (2005 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) - ⊕ extend (link true 1 122 false (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 3) (1000 , 2002) (valid (route false 127 10 ((2002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ (1005 , 1000) ∷ []) (true , 2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) - ≡ valid (route true 128 8 ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2003) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 3 128 true (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 2) (1000 , 2004) (valid (route false 0 5 false ((2004 , 2005) ∷ (2005 , 2003) ∷ []) (1 ∷ 1 ∷ []))) + ⊕ extend (link true 1 122 false (1003 ∷ []) (floor 4 4 1 1 ∷ []) false false true 3) (1000 , 2002) (valid (route false 127 10 true ((2002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ (1005 , 1000) ∷ []) (2 ∷ 1 ∷ 3 ∷ 1 ∷ []))) + ≡ valid (route true 128 8 false ((1000 , 2004) ∷ (2004 , 2005) ∷ (2005 , 2003) ∷ []) (2 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) (floor 3 2 1 2 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 8 ((2001 , 2006) ∷ []) (false , 1 ∷ []))) - ⊕ extend (link true 4 0 false ([]) (floor 3 2 1 2 ∷ []) false true true 1) (1000 , 1003) (valid (route false 255 3 ((1003 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1006) ∷ []) (false , 1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 255 11 ((1000 , 2001) ∷ (2001 , 2006) ∷ []) (false , 3 ∷ 1 ∷ [])) +_ : extend (link true 3 255 false ([]) (floor 3 2 1 2 ∷ []) false false true 3) (1000 , 2001) (valid (route false 0 8 false ((2001 , 2006) ∷ []) (1 ∷ []))) + ⊕ extend (link true 4 0 false ([]) (floor 3 2 1 2 ∷ []) false true true 1) (1000 , 1003) (valid (route false 255 3 false ((1003 , 2003) ∷ (2003 , 1000) ∷ (1000 , 1006) ∷ []) (1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 255 11 false ((1000 , 2001) ∷ (2001 , 2006) ∷ []) (3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 122 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false true 3) (1000 , 1004) (valid (route true 0 8 ((1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 2 127 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 122 10 ((1000 , 1004) ∷ (1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (false , 3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 2 122 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false true 3) (1000 , 1004) (valid (route true 0 8 false ((1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 2 127 false (1005 ∷ 2002 ∷ []) (floor 0 3 2 0 ∷ []) false false false 2) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 122 10 false ((1000 , 1004) ∷ (1004 , 2027) ∷ (2027 , 1012) ∷ (1012 , 1001) ∷ (1001 , 1008) ∷ (1008 , 1029) ∷ (1029 , 1033) ∷ (1033 , 1022) ∷ (1022 , 2014) ∷ (2014 , 2039) ∷ (2039 , 1035) ∷ (1035 , 1036) ∷ (1036 , 2011) ∷ (2011 , 1024) ∷ (1024 , 1015) ∷ (1015 , 1016) ∷ (1016 , 1034) ∷ (1034 , 1005) ∷ (1005 , 2006) ∷ (2006 , 2017) ∷ (2017 , 1020) ∷ (1020 , 2030) ∷ (2030 , 2025) ∷ (2025 , 2004) ∷ (2004 , 1019) ∷ (1019 , 2013) ∷ (2013 , 1040) ∷ (1040 , 2018) ∷ (2018 , 1009) ∷ (1009 , 2031) ∷ (2031 , 1026) ∷ []) (3 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 255 4 ((1000 , 2001) ∷ []) (true , 3 ∷ [])) +_ : extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 255 false (1002 ∷ 2002 ∷ []) (floor 1 1 1 2 ∷ floor 3 3 2 1 ∷ floor 3 5 2 3 ∷ []) true false true 3) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 255 4 true ((1000 , 2001) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 1 127 false (2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 255 false (2002 ∷ []) ([]) false false false 3) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 1 ((1000 , 1004) ∷ []) (false , 3 ∷ [])) +_ : extend (link true 1 127 false (2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 255 false (2002 ∷ []) ([]) false false false 3) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 1 false ((1000 , 1004) ∷ []) (3 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) false true true 2) (1000 , 1006) (valid (route false 122 7 ((1006 , 2005) ∷ (2005 , 1003) ∷ (1003 , 1001) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 3 0 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 1 ((2003 , 2004) ∷ (2004 , 1001) ∷ []) (true , 1 ∷ 2 ∷ []))) - ≡ valid (route true 128 4 ((1000 , 2003) ∷ (2003 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 3 255 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) false true true 2) (1000 , 1006) (valid (route false 122 7 false ((1006 , 2005) ∷ (2005 , 1003) ∷ (1003 , 1001) ∷ []) (3 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 3 0 false (1003 ∷ []) (floor 2 0 2 0 ∷ floor 3 3 2 2 ∷ floor 3 4 1 2 ∷ []) true false true 2) (1000 , 2003) (valid (route true 128 1 true ((2003 , 2004) ∷ (2004 , 1001) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route true 128 4 true ((1000 , 2003) ∷ (2003 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 1 128 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route false 255 9 ((1002 , 1001) ∷ (1001 , 1005) ∷ []) (false , 3 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true false 3) (1000 , 1006) (valid (route false 255 0 ((1006 , 1000) ∷ []) (false , 1 ∷ []))) +_ : extend (link true 1 128 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true true 1) (1000 , 1002) (valid (route false 255 9 false ((1002 , 1001) ∷ (1001 , 1005) ∷ []) (3 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1004 ∷ []) (floor 1 2 1 1 ∷ floor 2 1 2 3 ∷ floor 4 2 2 2 ∷ []) false true false 3) (1000 , 1006) (valid (route false 255 0 false ((1006 , 1000) ∷ []) (1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 127 10 ((1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 10 ((2005 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 127 13 ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 1004) (valid (route true 127 10 true ((1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1001 ∷ []) (floor 2 1 1 3 ∷ []) false false true 1) (1000 , 2005) (valid (route true 127 10 true ((2005 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 127 13 true ((1000 , 1004) ∷ (1004 , 2003) ∷ (2003 , 1006) ∷ (1006 , 1001) ∷ []) (1 ∷ 2 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2001) (valid (route false 255 9 ((2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) - ⊕ extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2006) (valid (route false 255 9 ((2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (false , 2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route false 255 13 ((1000 , 2001) ∷ (2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (true , 1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2001) (valid (route false 255 9 false ((2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ⊕ extend (link true 4 127 false (1003 ∷ 2003 ∷ []) ([]) true false true 1) (1000 , 2006) (valid (route false 255 9 false ((2006 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (2 ∷ 1 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route false 255 13 true ((1000 , 2001) ∷ (2001 , 1002) ∷ (1002 , 2005) ∷ (2005 , 2006) ∷ (2006 , 2004) ∷ []) (1 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 122 false (1006 ∷ 2003 ∷ []) (floor 5 0 2 1 ∷ []) false true false 2) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 3 255 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 1) (1000 , 2001) (valid (route true 255 5 ((2001 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1002) ∷ []) (false , 1 ∷ 2 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 3 128 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ []))) - ≡ valid (route true 128 11 ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (true , 3 ∷ 2 ∷ 2 ∷ 2 ∷ [])) +_ : extend (link true 3 255 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 1) (1000 , 2001) (valid (route true 255 5 false ((2001 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1001) ∷ (1001 , 1002) ∷ []) (1 ∷ 2 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 3 128 false (1003 ∷ 1004 ∷ []) (floor 0 6 2 2 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (2 ∷ 2 ∷ 2 ∷ []))) + ≡ valid (route true 128 11 true ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ []) (3 ∷ 2 ∷ 2 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2003) (valid (route false 127 3 ((2003 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2004) (valid (route false 127 3 ((2004 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 1 ∷ []))) - ≡ valid (route true 127 6 ((1000 , 2003) ∷ (2003 , 1001) ∷ (1001 , 1004) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2003) (valid (route false 127 3 false ((2003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1001 ∷ 1003 ∷ []) ([]) false true true 3) (1000 , 2004) (valid (route false 127 3 false ((2004 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 1 ∷ []))) + ≡ valid (route true 127 6 false ((1000 , 2003) ∷ (2003 , 1001) ∷ (1001 , 1004) ∷ []) (3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 4 ((2006 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 122 4 ((2004 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (false , 2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) +_ : extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 4 false ((2006 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 255 false (2005 ∷ []) (floor 0 6 1 1 ∷ []) false false true 3) (1000 , 2004) (valid (route false 122 4 false ((2004 , 2039) ∷ (2039 , 1030) ∷ (1030 , 2029) ∷ (2029 , 1014) ∷ (1014 , 1040) ∷ (1040 , 2023) ∷ (2023 , 1011) ∷ (1011 , 1026) ∷ (1026 , 2037) ∷ (2037 , 1010) ∷ (1010 , 2024) ∷ (2024 , 2020) ∷ (2020 , 1022) ∷ (1022 , 1038) ∷ (1038 , 2015) ∷ (2015 , 2008) ∷ (2008 , 1019) ∷ (1019 , 1032) ∷ (1032 , 2025) ∷ (2025 , 2002) ∷ (2002 , 1027) ∷ (1027 , 2004) ∷ (2004 , 2031) ∷ (2031 , 2034) ∷ (2034 , 2001) ∷ (2001 , 1035) ∷ (1035 , 1021) ∷ (1021 , 1033) ∷ (1033 , 1012) ∷ (1012 , 2036) ∷ (2036 , 1003) ∷ []) (2 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 3 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 3 ((2005 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 2 ∷ []))) - ⊕ extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2003) (valid (route false 0 3 ((2003 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 2 ∷ []))) - ≡ valid (route true 127 4 ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 2004) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ [])) +_ : extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2005) (valid (route false 0 3 false ((2005 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 2 ∷ []))) + ⊕ extend (link true 1 127 true (1003 ∷ 2003 ∷ []) (floor 1 4 2 2 ∷ floor 1 5 1 3 ∷ floor 3 3 1 0 ∷ []) false false true 1) (1000 , 2003) (valid (route false 0 3 false ((2003 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 2 ∷ []))) + ≡ valid (route true 127 4 false ((1000 , 2003) ∷ (2003 , 1002) ∷ (1002 , 2004) ∷ []) (1 ∷ 1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route true 0 3 ((2005 , 1004) ∷ []) (false , 2 ∷ []))) - ⊕ extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2004) (valid (route true 0 3 ((2004 , 1004) ∷ []) (false , 2 ∷ []))) - ≡ valid (route true 122 7 ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (false , 1 ∷ 2 ∷ [])) +_ : extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2005) (valid (route true 0 3 false ((2005 , 1004) ∷ []) (2 ∷ []))) + ⊕ extend (link true 4 122 false ([]) (floor 1 5 2 3 ∷ floor 2 1 1 2 ∷ []) false false true 1) (1000 , 2004) (valid (route true 0 3 false ((2004 , 1004) ∷ []) (2 ∷ []))) + ≡ valid (route true 122 7 false ((1000 , 2004) ∷ (2004 , 1004) ∷ []) (1 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 ((2003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ []))) - ⊕ extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2001) (valid (route false 127 8 ((2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 127 11 ((1000 , 2001) ∷ (2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (true , 3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) +_ : extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2003) (valid (route false 127 8 true ((2003 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) + ⊕ extend (link true 3 0 false ([]) (floor 5 4 2 0 ∷ floor 6 0 2 1 ∷ floor 6 2 2 0 ∷ []) false false true 3) (1000 , 2001) (valid (route false 127 8 true ((2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 127 11 true ((1000 , 2001) ∷ (2001 , 1004) ∷ (1004 , 1006) ∷ (1006 , 2001) ∷ []) (3 ∷ 3 ∷ 1 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2002) (valid (route false 128 1 ((2002 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) - ⊕ extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2006) (valid (route false 128 1 ((2006 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) +_ : extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2002) (valid (route false 128 1 false ((2002 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) + ⊕ extend (link true 2 127 false (1004 ∷ []) (floor 4 0 1 0 ∷ []) false true true 2) (1000 , 2006) (valid (route false 128 1 false ((2006 , 1000) ∷ (1000 , 1003) ∷ (1003 , 2006) ∷ (2006 , 1004) ∷ []) (2 ∷ 2 ∷ 3 ∷ 3 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2003) (valid (route false 122 8 ((2003 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2006) (valid (route false 122 8 ((2006 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) +_ : extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2003) (valid (route false 122 8 false ((2003 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 0 true ([]) (floor 6 5 1 0 ∷ []) false true true 3) (1000 , 2006) (valid (route false 122 8 false ((2006 , 1037) ∷ (1037 , 1025) ∷ (1025 , 2036) ∷ (2036 , 2024) ∷ (2024 , 1005) ∷ (1005 , 1009) ∷ (1009 , 1027) ∷ (1027 , 1019) ∷ (1019 , 1029) ∷ (1029 , 2002) ∷ (2002 , 1031) ∷ (1031 , 2016) ∷ (2016 , 2022) ∷ (2022 , 2018) ∷ (2018 , 1011) ∷ (1011 , 1021) ∷ (1021 , 1038) ∷ (1038 , 2023) ∷ (2023 , 1032) ∷ (1032 , 2017) ∷ (2017 , 1003) ∷ (1003 , 1006) ∷ (1006 , 1004) ∷ (1004 , 2040) ∷ (2040 , 1030) ∷ (1030 , 2010) ∷ (2010 , 1007) ∷ (1007 , 2033) ∷ (2033 , 2015) ∷ (2015 , 1039) ∷ (1039 , 2013) ∷ []) (3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ 1 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 128 true (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) false false false 1) (1000 , 2004) (valid (route true 122 2 ((2004 , 1003) ∷ (1003 , 2005) ∷ []) (false , 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 false (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) true false false 3) (1000 , 2005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 128 3 ((1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 2005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 1 128 true (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) false false false 1) (1000 , 2004) (valid (route true 122 2 false ((2004 , 1003) ∷ (1003 , 2005) ∷ []) (2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 false (2002 ∷ 2006 ∷ []) (floor 5 3 2 1 ∷ floor 5 4 1 0 ∷ []) true false false 3) (1000 , 2005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 128 3 false ((1000 , 2004) ∷ (2004 , 1003) ∷ (1003 , 2005) ∷ []) (1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 3 3 1 1 ∷ []) false false false 1) (1000 , 1006) (valid (route false 255 10 ((1006 , 1000) ∷ (1000 , 1005) ∷ []) (true , 3 ∷ 2 ∷ []))) - ⊕ extend (link true 1 128 false ([]) (floor 3 3 1 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 6 ((1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 128 7 ((1000 , 1002) ∷ (1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (true , 2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 3 3 1 1 ∷ []) false false false 1) (1000 , 1006) (valid (route false 255 10 true ((1006 , 1000) ∷ (1000 , 1005) ∷ []) (3 ∷ 2 ∷ []))) + ⊕ extend (link true 1 128 false ([]) (floor 3 3 1 1 ∷ []) false false true 2) (1000 , 1002) (valid (route false 0 6 true ((1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 128 7 true ((1000 , 1002) ∷ (1002 , 1021) ∷ (1021 , 2029) ∷ (2029 , 2017) ∷ (2017 , 1032) ∷ (1032 , 1039) ∷ (1039 , 1033) ∷ (1033 , 2003) ∷ (2003 , 1038) ∷ (1038 , 2035) ∷ (2035 , 2025) ∷ (2025 , 2034) ∷ (2034 , 2020) ∷ (2020 , 1028) ∷ (1028 , 2031) ∷ (2031 , 2006) ∷ (2006 , 2007) ∷ (2007 , 2016) ∷ (2016 , 2005) ∷ (2005 , 1027) ∷ (1027 , 2040) ∷ (2040 , 2037) ∷ (2037 , 2019) ∷ (2019 , 2008) ∷ (2008 , 1023) ∷ (1023 , 1013) ∷ (1013 , 2010) ∷ (2010 , 2030) ∷ (2030 , 2011) ∷ (2011 , 2004) ∷ (2004 , 1001) ∷ []) (2 ∷ 2 ∷ 2 ∷ 2 ∷ 1 ∷ 2 ∷ 1 ∷ 3 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 2 ∷ 2 ∷ 3 ∷ 2 ∷ 1 ∷ 1 ∷ 1 ∷ 2 ∷ 3 ∷ 3 ∷ 2 ∷ [])) _ = refl -_ : extend (link true 3 127 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 3 ((2003 , 2006) ∷ (2006 , 2001) ∷ []) (false , 3 ∷ 1 ∷ []))) - ⊕ extend (link true 2 0 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 0 2 ((1000 , 1005) ∷ []) (false , 1 ∷ [])) +_ : extend (link true 3 127 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false true true 1) (1000 , 2003) (valid (route true 255 3 false ((2003 , 2006) ∷ (2006 , 2001) ∷ []) (3 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 false (2004 ∷ []) (floor 1 1 1 2 ∷ floor 2 4 2 0 ∷ []) false false true 1) (1000 , 1005) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 0 2 false ((1000 , 1005) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 2 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 122 false (2001 ∷ []) ([]) false false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 2 false ((1000 , 1006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1004) (valid (route false 128 6 ((1004 , 1005) ∷ []) (false , 2 ∷ []))) - ≡ valid (route false 0 3 ((1000 , 2001) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 false (1005 ∷ 2006 ∷ []) (floor 2 6 2 1 ∷ []) false false true 2) (1000 , 1004) (valid (route false 128 6 false ((1004 , 1005) ∷ []) (2 ∷ []))) + ≡ valid (route false 0 3 false ((1000 , 2001) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2002) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 ([]) (false , []))) +_ : extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2002) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 2 0 false ([]) (floor 0 6 2 3 ∷ floor 2 2 1 0 ∷ []) false false false 1) (1000 , 2003) (valid (route false 0 0 false ([]) ([]))) ≡ invalid _ = refl -_ : extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1005) (valid (route true 0 6 ((1005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) - ⊕ extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1001) (valid (route true 0 6 ((1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 128 8 ((1000 , 1001) ∷ (1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1005) (valid (route true 0 6 false ((1005 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ⊕ extend (link true 2 128 true ([]) ([]) false false true 3) (1000 , 1001) (valid (route true 0 6 false ((1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 128 8 false ((1000 , 1001) ∷ (1001 , 2004) ∷ (2004 , 2001) ∷ (2001 , 2003) ∷ []) (3 ∷ 3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 255 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 3) (1000 , 2003) (valid (route false 255 9 ((2003 , 1005) ∷ (1005 , 1003) ∷ (1003 , 1002) ∷ (1002 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 3 122 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 2) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 3 ((1000 , 1006) ∷ []) (false , 2 ∷ [])) +_ : extend (link true 2 255 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 3) (1000 , 2003) (valid (route false 255 9 false ((2003 , 1005) ∷ (1005 , 1003) ∷ (1003 , 1002) ∷ (1002 , 1006) ∷ []) (3 ∷ 2 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 3 122 false (1004 ∷ []) (floor 3 3 2 2 ∷ floor 4 0 1 1 ∷ floor 4 4 1 3 ∷ []) false false true 2) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 3 false ((1000 , 1006) ∷ []) (2 ∷ [])) _ = refl -_ : extend (link true 2 255 false ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 128 6 ((1006 , 1002) ∷ (1002 , 2006) ∷ []) (false , 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 0 true ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1003) (valid (route false 127 0 ((1003 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1002) ∷ []) (true , 2 ∷ 3 ∷ 2 ∷ []))) - ≡ valid (route false 255 8 ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2006) ∷ []) (true , 2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 255 false ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1006) (valid (route false 128 6 false ((1006 , 1002) ∷ (1002 , 2006) ∷ []) (2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 0 true ([]) (floor 1 4 1 2 ∷ floor 2 5 1 1 ∷ floor 6 5 1 1 ∷ []) true false true 2) (1000 , 1003) (valid (route false 127 0 true ((1003 , 2006) ∷ (2006 , 2001) ∷ (2001 , 1002) ∷ []) (2 ∷ 3 ∷ 2 ∷ []))) + ≡ valid (route false 255 8 true ((1000 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2006) ∷ []) (2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) true false true 1) (1000 , 1005) (valid (route true 0 0 ((1005 , 1001) ∷ []) (true , 3 ∷ []))) - ⊕ extend (link true 4 0 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 5 ((2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (false , 2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 122 9 ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (false , 3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 255 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) true false true 1) (1000 , 1005) (valid (route true 0 0 true ((1005 , 1001) ∷ []) (3 ∷ []))) + ⊕ extend (link true 4 0 false (1002 ∷ []) (floor 2 1 1 3 ∷ floor 4 0 2 1 ∷ []) false false true 3) (1000 , 2006) (valid (route false 122 5 false ((2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 122 9 false ((1000 , 2006) ∷ (2006 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1002) ∷ []) (3 ∷ 2 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 false (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 1004) (valid (route false 127 11 ((1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 128 false (1001 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 127 13 ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 0 false (1001 ∷ 2005 ∷ []) ([]) false false true 1) (1000 , 1004) (valid (route false 127 11 false ((1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (2 ∷ 3 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 128 false (1001 ∷ 2005 ∷ []) ([]) false false true 3) (1000 , 2001) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 127 13 false ((1000 , 1004) ∷ (1004 , 1002) ∷ (1002 , 2004) ∷ (2004 , 1003) ∷ (1003 , 1005) ∷ []) (1 ∷ 2 ∷ 3 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 3 255 false ([]) ([]) true false true 3) (1000 , 2004) (valid (route false 128 10 ((2004 , 2001) ∷ (2001 , 1005) ∷ []) (false , 2 ∷ 1 ∷ []))) - ⊕ extend (link true 4 127 false ([]) ([]) false true true 3) (1000 , 2005) (valid (route false 127 5 ((2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 2 ∷ 2 ∷ 3 ∷ []))) - ≡ valid (route false 127 9 ((1000 , 2005) ∷ (2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 3 255 false ([]) ([]) true false true 3) (1000 , 2004) (valid (route false 128 10 false ((2004 , 2001) ∷ (2001 , 1005) ∷ []) (2 ∷ 1 ∷ []))) + ⊕ extend (link true 4 127 false ([]) ([]) false true true 3) (1000 , 2005) (valid (route false 127 5 false ((2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (2 ∷ 2 ∷ 3 ∷ []))) + ≡ valid (route false 127 9 false ((1000 , 2005) ∷ (2005 , 1002) ∷ (1002 , 1006) ∷ (1006 , 1005) ∷ []) (3 ∷ 2 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 122 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) true false false 3) (1000 , 1005) (valid (route false 0 9 ((1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (false , 3 ∷ 3 ∷ 1 ∷ []))) - ⊕ extend (link true 4 0 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) false true false 3) (1000 , 2006) (valid (route false 255 9 ((2006 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2003) ∷ []) (false , 2 ∷ 3 ∷ 3 ∷ []))) - ≡ valid (route true 122 10 ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (true , 3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) +_ : extend (link true 1 122 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) true false false 3) (1000 , 1005) (valid (route false 0 9 false ((1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ 1 ∷ []))) + ⊕ extend (link true 4 0 true (1003 ∷ 2003 ∷ []) (floor 0 3 2 2 ∷ floor 2 2 1 0 ∷ floor 5 3 1 3 ∷ []) false true false 3) (1000 , 2006) (valid (route false 255 9 false ((2006 , 2004) ∷ (2004 , 2002) ∷ (2002 , 2003) ∷ []) (2 ∷ 3 ∷ 3 ∷ []))) + ≡ valid (route true 122 10 true ((1000 , 1005) ∷ (1005 , 2002) ∷ (2002 , 1004) ∷ (1004 , 2003) ∷ []) (3 ∷ 3 ∷ 3 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 1001) (valid (route false 128 8 ((1001 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 1 ∷ []))) - ⊕ extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 2004) (valid (route false 128 8 ((2004 , 1006) ∷ (1006 , 2002) ∷ []) (true , 2 ∷ 1 ∷ []))) +_ : extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 1001) (valid (route false 128 8 true ((1001 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 0 true ([]) (floor 0 1 2 2 ∷ []) true true true 2) (1000 , 2004) (valid (route false 128 8 true ((2004 , 1006) ∷ (1006 , 2002) ∷ []) (2 ∷ 1 ∷ []))) ≡ invalid _ = refl -_ : extend (link true 1 122 true ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true true true 1) (1000 , 1006) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 0 false ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true false true 3) (1000 , 1003) (valid (route false 122 8 ((1003 , 1000) ∷ (1000 , 2004) ∷ []) (false , 1 ∷ 3 ∷ []))) - ≡ valid (route true 122 1 ((1000 , 1006) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 1 122 true ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true true true 1) (1000 , 1006) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 false ([]) (floor 1 3 2 1 ∷ floor 3 0 1 0 ∷ []) true false true 3) (1000 , 1003) (valid (route false 122 8 false ((1003 , 1000) ∷ (1000 , 2004) ∷ []) (1 ∷ 3 ∷ []))) + ≡ valid (route true 122 1 true ((1000 , 1006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 1 127 true (1003 ∷ 2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 4 122 true (1003 ∷ 2002 ∷ []) ([]) false true false 3) (1000 , 2003) (valid (route false 122 6 ((2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) - ≡ valid (route true 122 10 ((1000 , 2003) ∷ (2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (false , 3 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 127 true (1003 ∷ 2002 ∷ []) ([]) false false true 3) (1000 , 1004) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 4 122 true (1003 ∷ 2002 ∷ []) ([]) false true false 3) (1000 , 2003) (valid (route false 122 6 false ((2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (2 ∷ 2 ∷ 1 ∷ 1 ∷ []))) + ≡ valid (route true 122 10 false ((1000 , 2003) ∷ (2003 , 2002) ∷ (2002 , 1003) ∷ (1003 , 2005) ∷ (2005 , 1006) ∷ []) (3 ∷ 2 ∷ 2 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 3 255 false (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true false true 1) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ⊕ extend (link true 3 0 true (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true true true 1) (1000 , 2006) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route true 0 3 ((1000 , 2006) ∷ []) (true , 1 ∷ [])) +_ : extend (link true 3 255 false (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true false true 1) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ⊕ extend (link true 3 0 true (1002 ∷ []) (floor 4 0 2 3 ∷ floor 5 2 1 3 ∷ []) true true true 1) (1000 , 2006) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route true 0 3 true ((1000 , 2006) ∷ []) (1 ∷ [])) _ = refl -_ : extend (link true 2 122 false ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false true 1) (1000 , 1002) (valid (route false 128 11 ((1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 1 ∷ 2 ∷ 3 ∷ []))) - ⊕ extend (link true 4 255 true ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false false 1) (1000 , 2001) (valid (route true 127 0 ((2001 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2004) ∷ (2004 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ 3 ∷ []))) - ≡ valid (route false 128 13 ((1000 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (false , 1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) +_ : extend (link true 2 122 false ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false true 1) (1000 , 1002) (valid (route false 128 11 false ((1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 2 ∷ 3 ∷ []))) + ⊕ extend (link true 4 255 true ([]) (floor 3 0 1 1 ∷ floor 4 6 2 2 ∷ floor 5 4 2 0 ∷ []) false false false 1) (1000 , 2001) (valid (route true 127 0 false ((2001 , 1006) ∷ (1006 , 1002) ∷ (1002 , 2004) ∷ (2004 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ 3 ∷ []))) + ≡ valid (route false 128 13 false ((1000 , 1002) ∷ (1002 , 1005) ∷ (1005 , 1003) ∷ (1003 , 2001) ∷ []) (1 ∷ 1 ∷ 2 ∷ 3 ∷ [])) _ = refl -_ : extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1006) (valid (route false 255 1 ((1006 , 2006) ∷ (2006 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) - ⊕ extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 255 1 ((1005 , 2006) ∷ (2006 , 2003) ∷ []) (false , 1 ∷ 1 ∷ []))) - ≡ valid (route false 255 2 ((1000 , 1006) ∷ (1006 , 2006) ∷ (2006 , 2003) ∷ []) (false , 3 ∷ 1 ∷ 1 ∷ [])) +_ : extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1006) (valid (route false 255 1 false ((1006 , 2006) ∷ (2006 , 2003) ∷ []) (1 ∷ 1 ∷ []))) + ⊕ extend (link true 1 255 false ([]) (floor 2 4 1 3 ∷ floor 5 6 2 3 ∷ []) false false true 3) (1000 , 1005) (valid (route false 255 1 false ((1005 , 2006) ∷ (2006 , 2003) ∷ []) (1 ∷ 1 ∷ []))) + ≡ valid (route false 255 2 false ((1000 , 1006) ∷ (1006 , 2006) ∷ (2006 , 2003) ∷ []) (3 ∷ 1 ∷ 1 ∷ [])) _ = refl -_ : extend (link true 1 255 true (1006 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1004) (valid (route false 122 8 ((1004 , 2004) ∷ (2004 , 1002) ∷ []) (false , 2 ∷ 1 ∷ []))) - ⊕ extend (link true 2 122 false (1006 ∷ 2002 ∷ []) ([]) true true true 3) (1000 , 1002) (valid (route false 0 0 ([]) (false , []))) - ≡ valid (route false 122 2 ((1000 , 1002) ∷ []) (true , 3 ∷ [])) +_ : extend (link true 1 255 true (1006 ∷ 2002 ∷ []) ([]) false true true 2) (1000 , 1004) (valid (route false 122 8 false ((1004 , 2004) ∷ (2004 , 1002) ∷ []) (2 ∷ 1 ∷ []))) + ⊕ extend (link true 2 122 false (1006 ∷ 2002 ∷ []) ([]) true true true 3) (1000 , 1002) (valid (route false 0 0 false ([]) ([]))) + ≡ valid (route false 122 2 true ((1000 , 1002) ∷ []) (3 ∷ [])) _ = refl From 90cede469533761613318372c8703f927c702bb7 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 05:59:34 -0800 Subject: [PATCH 08/11] docs(moq-net): what the route proof covers, and the mark's place in the order The route proof's README says what is mechanized, what is bound by tests, what is argued on paper (including why Sobrinho's 2005 liveness theorem does not cover staying on the next hop in use, and the argument that does), and what is not given. The epic's item 13 and the rule's shape record the mark's place in the order, decided by the coordinator on 2026-11-16 pending the maintainer; the router quest gets the order, the neighbour key, the chain, and the binding move. Corrects 7b49e3fb9c's sweep baseline, which counted every origin; with the same split counter (relays that announced in both orders) the order without the mark gave 2272 routes: 46 on another next hop, 0 at another rank, 19 marked once, 0 reachable once. With the mark: 29, 0, 0, 0. The 13 "reachable once" were all from the 2 relays that announced in one order only. Random networks never showed a neighbour losing its route by the mark; the fixture does. Co-Authored-By: Claude Opus 5.5 --- quest/m2/multicast/README.md | 19 +- quest/m2/multicast/proof.md | 8 +- quest/m2/multicast/router.md | 20 ++ rs/moq-net/verify/README.md | 9 + rs/moq-net/verify/route-algebra/README.md | 221 ++++++++++++++++++++++ 5 files changed, 274 insertions(+), 3 deletions(-) create mode 100644 rs/moq-net/verify/route-algebra/README.md diff --git a/quest/m2/multicast/README.md b/quest/m2/multicast/README.md index 0de6d4eb75f..6d3b8d3ff0a 100644 --- a/quest/m2/multicast/README.md +++ b/quest/m2/multicast/README.md @@ -209,6 +209,21 @@ publishers, in route messages, unless noted): move). The route stands after the last claim leaves (rejected: withdrawing it, which races the claim's own end and would show a reader offline where the publisher ended cleanly). + - Order at equal rank, decided by the coordinator on 2026-11-16 while + the maintainer was away, pending their confirmation: a route with no + marked link on its path beats a marked one, then the next hop in use, + the shorter path, and the neighbour. A relay holding two routes of + equal rank, one learned over a marked link, had kept whichever came + first, so a neighbour behind its own marked link was reachable or not + by arrival order, and under a fixed order by the neighbours' keys + ([proof](/quest/m2/multicast/proof.md)). The mark only turns on along + a path, so extending a route still never improves it. A strictly + cheaper marked route still wins; an operator who wants the unmarked + side preferred raises its priority. On the bake-off it moved no + settled result, only failure transients on peered tiers: 220 to 225 + for a home dying on 15 relays, 954 to 924 on 32 (rejected: leaving it + to arrival order; dropping the next hop in use, which moves a + subscription for an equal route; ranking the mark ahead of cost). 14. ✅ **A silent death is left to keep-alives and the opt-in metadata standby** ([route health](/quest/m3/route-health/README.md)). No arm fixed it: readers behind a relay that dies unnoticed for 3 s stay unfed @@ -245,7 +260,9 @@ a further departure is a decision to list in its PR: whose path names it, sends none to a neighbour already on the path, and refuses one at or below a session floor. Rank is not draining, then the lowest priority on the path, then the summed cost, each link adding at - least 1, so extending a route never improves it. A closed session and a + least 1, so extending a route never improves it. At equal rank a route + with no marked link beats a marked one, then the next hop in use, the + shorter path, and the neighbour (item 13). A closed session and a draining node are each named once per neighbour, and a closed session's message ends every route its sender offered through it. A node advertises once per burst of input. diff --git a/quest/m2/multicast/proof.md b/quest/m2/multicast/proof.md index 3ef8108dfb5..5ede00aba39 100644 --- a/quest/m2/multicast/proof.md +++ b/quest/m2/multicast/proof.md @@ -43,8 +43,12 @@ Measured 2026-11-15 by the [bake-off](https://github.com/moq-dev/moq/pull/8880), and decided 2026-11-16 ([maintainer](https://github.com/moq-dev/moq/pull/8880#issuecomment-6911055514)). The rank is the epic's: not draining, the lowest priority on the path, the -summed cost, each link adding at least 1, then the next hop in use, the -shorter path, and the neighbour. Four more lemmas for what it added: +summed cost, each link adding at least 1, then no marked link on the path, +the next hop in use, the shorter path, and the neighbour. The mark's place +was decided by the coordinator on 2026-11-16 while the maintainer was away, +pending their confirmation (rejected: leaving it to arrival order; dropping +the next hop in use; ranking the mark ahead of cost). Four more lemmas for +what it added: - The session floor is a filter: a path naming a pair of relays at or below the highest session known closed between them maps to invalid, a session diff --git a/quest/m2/multicast/router.md b/quest/m2/multicast/router.md index a34bd67bcc7..a2d1ca2aea4 100644 --- a/quest/m2/multicast/router.md +++ b/quest/m2/multicast/router.md @@ -114,4 +114,24 @@ the [epic](/quest/m2/multicast/README.md)'s items 13 and 14): - Selected routes looped for a moment in partitions and deaths (up to 3 rounds at 32 relays, where today's reached 4); requests must fail closed first. +Found 2026-11-16 by the [proof](/quest/m2/multicast/proof.md) +([moq-dev/moq#8904](https://github.com/moq-dev/moq/pull/8904), whose +`rs/moq-net/verify/route-algebra/README.md` holds the arguments): + +- Candidates order by rank, then no marked link on the path, then the next hop + in use, the shorter path, and the neighbour (the epic's item 13, the mark's + place decided by the coordinator pending the maintainer's confirmation). + `route/relay.rs` keeps its own copy of this order; make it match. +- Order equal routes by the neighbour's Node ID, or give the proof's binding + the key the router orders them by: the proof orders them by the neighbour, + the prototype by its simulation's node index. +- Record the chain as the claim instance's path: the announcing relay first, + then each grant's exporter and adopter, so a node refuses a claim naming it + in the role it would take. The prototype records only the adopters, so it + refuses fewer echoes than the proof assumes. +- Move the binding: point `route/tests/algebra.rs` and `route/tests/sticky.rs` + at the router's own functions for a node's own route, sending a route on, + taking one in, ordering candidates, and listing them, regenerate + `Vectors.agda`, and run `just test route-proof`. + Public API: none. Wire: none. diff --git a/rs/moq-net/verify/README.md b/rs/moq-net/verify/README.md index 17bd335594d..4d51ee2573d 100644 --- a/rs/moq-net/verify/README.md +++ b/rs/moq-net/verify/README.md @@ -9,3 +9,12 @@ A counterexample is a path through the model, not yet a bug. Replay it on the co ## Coverage After a change to a covered function, mirror it in the model, rerun every config, and move the sync commit forward only once the model describes the code at the new commit. `just check` fails when a function or type the table names no longer exists in its file (`sh/coverage-tables.py`), so each Code cell starts with a repo-relative path, then the symbols in it. + +## The route proof + +`route-algebra/` is not a model check: it states the multicast route rule as an increasing path algebra in Agda and applies Daggitt and Griffin's convergence theorem to it, checked nightly by `just test route-proof`. Its [README](route-algebra/README.md) holds the full coverage and the paper arguments. In short: + +- Mechanized: the rule converges on every network, from every state, under any loss, reordering, and duplication, to one fixed point, with ties broken by one fixed order; the same for claims across trust boundaries; and the floor and the named drains leave that fixed point unchanged. +- Tested against the proof: the prototype's rank and extend functions meet its axioms, and 322 of their results are checked by Agda. +- On paper and tested, not mechanized: the rule as it runs puts the next hop in use ahead of the shorter path and the neighbour, so its stable state is not unique. It still settles, and every node settles on the rank and mark the fixed order gives it, except where a longer path meets the 32-hop limit; only the next hop varies. +- Not given: loop freedom at every instant, warmth, liveness under endless churn, the chain as Rust records it, and which relays announce under `claimed`. diff --git a/rs/moq-net/verify/route-algebra/README.md b/rs/moq-net/verify/route-algebra/README.md new file mode 100644 index 00000000000..0cf500ce6b0 --- /dev/null +++ b/rs/moq-net/verify/route-algebra/README.md @@ -0,0 +1,221 @@ +# The route rule's convergence proof + +The multicast route rule (`rs/moq-net/src/route/tests/multi.rs` with the epic's +`floor`, `epoch`, `batch`, `drain`, and `claimed`) stated as an increasing path +algebra in Agda, with Daggitt and Griffin's Theorem 5 applied to it +([arXiv 2106.01184](https://arxiv.org/abs/2106.01184), library +[MatthewDaggitt/agda-routing](https://github.com/MatthewDaggitt/agda-routing)): +on every network, from every state, under every schedule of delayed, +reordered, lost, and repeated messages, the asynchronous iteration reaches the +network's unique fixed point once the network holds still long enough. + +`just test route-proof` type-checks it with its own Agda pin +(`nix/route-proof.nix`: Agda 2.6.4.3, standard-library 2.0, agda-routing at a +fixed commit), so neither the dev shell nor `nix flake check` fetches it. Nightly +runs it. Every module is `--safe` and nothing is postulated. The check takes +about a minute and a half; building the library the first time adds about 40 s. + +| Module | What it holds | +|---|---| +| `Order.agda` | Decidable total orders and the combinators the rank is built from. | +| `Increasing.agda` | The algebra both levels share, and the theorem it buys (`convergent`, `converges-n²`). | +| `Route.agda` | Routes between forwarding nodes: every filter and the link a node holds. | +| `Claim.agda` | Claims across trust boundaries: the same algebra at the grain of the nodes that hand a claim on. | +| `Sim.agda` | `Route` with nodes named as the Rust simulation names them. | +| `Vectors.agda` | Results the Rust prototype computed, each a `refl` (generated). | +| `Accelerate.agda` | The floor and the named drains leave the rule's fixed point unchanged. | + +## The algebra + +A route is invalid or carries whether it is draining, a penalty (127 minus the +lowest priority on its path), a cost, whether a marked link is on its path, its +path, and whatever else a level carries (`extra`). Routes rank by draining, +then penalty, then cost, then unmarked before marked, then the shorter path, +then a fixed order on paths (the neighbour first), then `extra`. A node keeps the +lower of two routes. Crossing a link refuses a route whose path does not start +at the link's far end or already names its near end, and whatever the link's +filter refuses; otherwise it can only make the route draining, raise its +penalty, add to its cost, mark it, and prepend the link. That is an increasing +path algebra, which is all Theorem 5 asks. + +For routes, the link from i to its neighbour j carries: whether it is up, i's +port cost and penalty, whether j sent GOAWAY, the nodes i knows draining, i's +session floors, whether i or j marked the link, whether j announces a claim, +and i's session number. It refuses a route when the link is down, when the +route is j's route to itself and j announces no claim, when the route is +marked and j marked the link, when the path would grow past 32 hops, or when +the path names a session i's floors hold closed. A route that names a node +known draining ranks as draining. Nodes are incarnations: a restart is a new +node. + +## Coverage + +**Mechanized** (Agda, `--safe`): + +- The generic algebra is an increasing path algebra, so it converges, and the + synchronous iteration within n² rounds (`Increasing.convergent`, + `converges-n²`). This covers: selection is one total order with a fixed + tie-break; crossing a session never makes a route preferred; a path naming + its receiver is invalid and a path grows by exactly the hop it crossed; each + filter maps a route to invalid; the named drain keeps one order. +- The route instance with every filter: claimed, the mark's export filter, the + hop limit, the floor with epochs, and the named drain (`Route`). +- The claim instance: any chain of steps that only add, and refuse a claim + naming the node that takes it, converges too (`Claim`). Echoes never beat + the claims they echo because every step is increasing. +- The floor and the named drains only make the rule arrive sooner: the fixed + point of the rule without them is a fixed point with them, given that no floor + covers a live session (`FloorsClosed`) and that a node is named draining only + once it sent GOAWAY on every live link (`DrainNamed`) + (`Accelerate.accelerated-fixed`). + +**Bound to the prototype by tests** (`rs/moq-net/src/route/tests/algebra.rs`): +the router's own functions (`Offer::own`, `Offer::onward`, `Here::arrive`, +`order`) meet the axioms on random links and routes, and 322 of their results +(200 single steps and 122 choices between two routes, half of them ties) are +written into `Vectors.agda`, where Agda must compute the same results by `refl`. +A Rust test fails when the file is stale (`ROUTE_VECTORS=write` regenerates +it), and a changed Agda definition fails the nightly check. Mutating any of the +floor, epoch, drain set, mark filter, hop limit, claimed, penalty, cost, drains, +tie-break, tag, or sessions is caught by a vector. This is a sample: no test +shows the Rust functions equal the Agda definitions on every input. + +**Argued on paper** (below): the fixed point is unique with and without the +accelerators; the two hypotheses hold in the prototype; advertising once per +burst changes no fixed point; what a node advertises is a function of the +latest it heard; the dead-hop and ended withdrawals remove only what the floor +does; `claimed` removes only routes no request names; claims settle once routes +do; the tree is loop-free at the fixed point; and the rule as it runs, with the +next hop in use, still settles. + +**Only tested**: the rule as it runs settles, on the rank and mark the fixed +order gives (`sticky.rs`); the floor refuses every route the dead-hop +withdrawal ends (`algebra.rs`, `the_floor_refuses_every_dead_hop`); a grant +never improves a claim in the real router (`a_grant_never_improves_a_claim`). + +## What this does not give + +- **The rule as it runs.** The theorem is for ties broken by one fixed order. + The prototype puts the next hop in use ahead of the shorter path and the + neighbour, so which of two equal routes a node settles on depends on which + came first, and the stable state is not unique. The argument that it still + settles is on paper and tested, not mechanized (below). +- **Loop freedom at every instant.** Only the fixed point is loop-free. + [Requests](https://github.com/moq-dev/moq/pull/8881) name their origin node + and fail closed instead. +- **A cost that depends on who subscribed.** Warmth is not in the algebra; + [warmth](/quest/m2/multicast/warmth.md) argues it separately. +- **Liveness under churn that never stops.** Convergence needs each epoch to + last long enough. +- **The chain as Rust records it.** The claim instance's path names every node + that took the claim. Rust's chain names only the receivers across scoped + grants, not the relay that exported the claim or the one that announced it, + so a node refuses fewer echoes than the algebra does. The router should + record the announcing relay first, then each grant's exporter and adopter, + and refuse a claim that names it in the role it would take. +- **The neighbour key.** The proof orders equal routes by the neighbour's relay + and then its start. The prototype orders them by its simulation's node index, + which equals the relay. The production router must order them by the + neighbour's Node ID, or the binding must supply the equivalent key. +- **A preference for the unmarked side at any cost.** Unmarked beats marked only + at equal draining, priority, and cost: a strictly cheaper marked route still + wins. Priority outranks cost, so an operator who wants the unmarked side + preferred raises its priority. +- **Which relays announce.** Under `claimed` a relay offers a route to itself + from its first claim on, for good, and whether a relay with no endpoint ever + gets a claim across a scoped grant can depend on arrival order. So the set of + route origins depends on history. The proof takes it as a link label fixed + within an epoch. `sticky.rs`'s `whether_a_relay_announces_hangs_on_arrival_order` + shows a relay that keeps a route to itself with no claim behind it. + +## On paper + +**Uniqueness.** `accelerated-fixed` shows the fixed point of the rule without +floors and named drains is a fixed point with them. Both rules converge, and a +convergent iteration started at a fixed point stays there, so each has exactly +that fixed point. + +**The hypotheses hold.** A floor holds a session only once the node learned it +closed, from its own session ending or from a neighbour naming it. Sessions +between a pair of relays are numbered upward within a start, and with `epoch` a +later start orders above every session of an earlier one, so no live session +sits at or below a floor (`FloorsClosed`). A relay that sends GOAWAY sends it on +every session, and a node is named draining only by a neighbour that heard it +(`DrainNamed`). + +**Advertising once per burst.** The library's schedules let a node act at any +subset of times on any earlier state of its neighbours. Reading a burst and then +advertising is one such schedule, and the iteration's function is unchanged, so +the fixed point is too. + +**A function of the latest heard.** A node keeps the latest offer from each +neighbour for each origin node, delivered in order on one stream, and picks with +`candidates` and `order` over those alone. A withdrawal is the invalid route. +In-order delivery is a special case of the library's data-flow function. + +**Dead hops and ended routes.** With `floor`, every route a dead-hop +withdrawal would end names a session the floor holds closed, so the floor +already refuses it (`the_floor_refuses_every_dead_hop`). A route a neighbour +ended stays invalid until that neighbour's next offer, which is the iteration's +own withdrawal. + +**`claimed`.** A node with no claim offers no route to itself. A request names +an origin node it chose among the claims it knows, so no request names a node +with no claim, and refusing its trivial route removes nothing a request would +use. The flag only turns on (until a restart, which is a new node), so within an +epoch it is a fixed label. + +**Claims after routes.** A claim's rank is the route to its announcer joined +with the claim's own drain, priority, and cost. Once routes settle, the claims' +iteration runs over a fixed route state and is itself an increasing algebra, so +it settles too. + +**Loop-free trees at the fixed point.** At the fixed point a node's route is its +next hop's route extended by one link, so the path shortens by one at each next +hop and ends at the origin node, and it never names the node holding it. The +next hops toward one origin node therefore form a tree, and a request naming +that origin follows it. `sticky.rs` checks this at every settled state: each +route's path is its next hop's route with that hop added. + +**The rule as it runs.** Sobrinho's liveness theorem for strictly monotone +algebras ("An algebraic theory of dynamic network routing", IEEE/ACM ToN 13(5), +2005, Theorem 6) does not cover it as stated. His model assumes a fixed total +preference among couplets of equal weight, and his proof's fourth case uses that +the couplet a node chose was preferred to every couplet it could choose then. +Staying on the next hop in use prefers by state instead. The argument here rests +only on the rank R = (draining, priority, cost) being strictly increasing: every +port costs at least 1 (`Router::connect` asserts it) and drain and priority +never improve. Order the finitely many values of R a path of at most 32 hops can +take. Suppose that from some time on, no node's selection of rank below r +changes. Once every message sent before then is delivered, every candidate of +rank r at a node extends a neighbour's settled selection of rank below r, so the +candidates of rank r at each node are fixed: filters read only the route, the +link, and what the node knows of closed sessions and draining nodes, which stops +changing once the epoch's news is delivered. A node whose best candidate has rank r picks among +those by mark, then the next hop in use, then length and neighbour; with the +candidates fixed it changes at most once more, and then stays. So selections of +rank at most r settle too, and by induction all do. + +Which route a node settles on can differ, but not its rank or mark. A candidate +a path-dependent filter refuses at node i is one whose path names i, and then i +already holds that path's prefix at a strictly lower rank; or one past the hop +limit; or one through a floored session, and no settled path crosses one. So +every node settles on the rank and mark the fixed order gives it, except where a +neighbour's longer path meets the 32-hop limit, and only the next hop varies. +`sticky.rs` checks this: 150 random networks, through churn, each settled twice +from cold in two delivery orders, differ in next hop at 29 of 2,272 routes and +never in rank, mark, or reachability. With the mark below the next hop in use +the same sweep differed in the mark at 19, and +`an_equal_route_in_use_never_leaves_a_neighbour_without_one` shows the +neighbour that order left without a route. + +## Moving the binding to the production router + +The tests bind to the prototype, which the router quest +([router](/quest/m2/multicast/router.md)) replaces with `route/relay.rs`. When it +lands, point `algebra.rs` and `sticky.rs` at the router's equivalents of +`Offer::own`, `Offer::onward`, `Here::arrive`, `order`, and `candidates`, +keeping them one function each that the router itself calls. Instantiate +`Route` with the router's neighbour key in place of `Sim`'s `relay` and +`start`, or order neighbours by Node ID and change `Route`'s path order to +match. Then regenerate `Vectors.agda` and run `just test route-proof`. From c345ccb3b7adbc518dc98dd1a02b16a17410d976 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 06:00:00 -0800 Subject: [PATCH 09/11] chore(quest): finish quest/m2/multicast/proof.md Co-Authored-By: Claude Opus 5.5 --- quest/m2/multicast/README.md | 4 +- quest/m2/multicast/accept.md | 1 - quest/m2/multicast/proof.md | 84 ------------------------------------ quest/m2/multicast/router.md | 2 +- quest/m2/multicast/warmth.md | 2 +- 5 files changed, 4 insertions(+), 89 deletions(-) delete mode 100644 quest/m2/multicast/proof.md diff --git a/quest/m2/multicast/README.md b/quest/m2/multicast/README.md index 6d3b8d3ff0a..14a5427c515 100644 --- a/quest/m2/multicast/README.md +++ b/quest/m2/multicast/README.md @@ -119,7 +119,7 @@ Settled: sends only what the node originates, which ends a LAN peer publishing through a neighbour whose uplink survived; both switches). 7. ✅ **The proof is mechanized, with TLA+ and sweeps beside it** - ([proof](/quest/m2/multicast/proof.md); rejected: a written proof with + ([proof](/rs/moq-net/verify/route-algebra/README.md); rejected: a written proof with property tests, the kind of argument that passed review here and failed for the echo, the deferred echo, and belief by distance; TLA+ and sweeps alone, which say nothing about an arbitrary topology). @@ -216,7 +216,7 @@ publishers, in route messages, unless noted): equal rank, one learned over a marked link, had kept whichever came first, so a neighbour behind its own marked link was reachable or not by arrival order, and under a fixed order by the neighbours' keys - ([proof](/quest/m2/multicast/proof.md)). The mark only turns on along + ([proof](/rs/moq-net/verify/route-algebra/README.md)). The mark only turns on along a path, so extending a route still never improves it. A strictly cheaper marked route still wins; an operator who wants the unmarked side preferred raises its priority. On the bake-off it moved no diff --git a/quest/m2/multicast/accept.md b/quest/m2/multicast/accept.md index f931314f652..52338211531 100644 --- a/quest/m2/multicast/accept.md +++ b/quest/m2/multicast/accept.md @@ -44,4 +44,3 @@ Public API: none. Wire: none expected. ## Required - [The switch](/quest/m2/multicast/switch.md) - the sessions these cases run on -- [The proof](/quest/m2/multicast/proof.md) - what these cases need not show diff --git a/quest/m2/multicast/proof.md b/quest/m2/multicast/proof.md deleted file mode 100644 index 5ede00aba39..00000000000 --- a/quest/m2/multicast/proof.md +++ /dev/null @@ -1,84 +0,0 @@ -# [M] The route rule is proven to converge on any topology - -## Goal - -The route rule's algebra is instantiated against the published Agda library -for path-vector convergence, with every axiom discharged: how a node ranks -routes, how a route changes crossing a link, the mark's export filter, the -rule that a path naming its receiver is invalid, and the chain across a trust -boundary. The theorem then applies on any topology: from any starting state, -under loss, reordering, and duplication, the nodes reach one stable state. A -Rust property test asserts that the router's own rank and extend functions -meet the same axioms, a nightly lane checks the Agda, and -`rs/moq-net/verify/README.md` says what is proven and what is not. - -## Plan - -Decided 2026-11-15 (maintainer, /quest-plan): ✅ mechanized, checked nightly -and not in the merge gate, with TLA+ and sweeps beside it (rejected: a -written proof with property tests; TLA+ and sweeps alone). Today's checking -is exhaustive only at 2 to 3 relays with one failure, and the maintainer -ended the unbounded TLA+ attempt on 2026-11-13. - -The theorem is Daggitt and Griffin's, "Formally Verified Convergence of -Policy-Rich DBF Routing Protocols" ([arXiv 2106.01184](https://arxiv.org/abs/2106.01184)), -Theorem 5: an increasing path algebra always converges. Its library is -[MatthewDaggitt/agda-routing](https://github.com/MatthewDaggitt/agda-routing); -pin it and Agda through Nix. - -What to show, each a lemma about one message handler: - -- Selection is a total order with a fixed tie-break. -- No change across a session makes a route preferred to what it was: adding - the link's cost, taking the lower priority, keeping a drain, appending the - hop. A filter maps a route to invalid. -- A route whose path names the receiver is invalid, and a path grows by - exactly the hop it crossed. -- What a node advertises is a function of the latest it heard from each - neighbour. The dead-hop withdrawal is extra: show it removes only routes - the iteration would remove, so it only arrives sooner. -- The chain is the same algebra at the grain of trust boundaries. - -Measured 2026-11-15 by the [bake-off](https://github.com/moq-dev/moq/pull/8880), -and decided 2026-11-16 -([maintainer](https://github.com/moq-dev/moq/pull/8880#issuecomment-6911055514)). -The rank is the epic's: not draining, the lowest priority on the path, the -summed cost, each link adding at least 1, then no marked link on the path, -the next hop in use, the shorter path, and the neighbour. The mark's place -was decided by the coordinator on 2026-11-16 while the maintainer was away, -pending their confirmation (rejected: leaving it to arrival order; dropping -the next hop in use; ranking the mark ahead of cost). Four more lemmas for -what it added: - -- The session floor is a filter: a path naming a pair of relays at or below - the highest session known closed between them maps to invalid, a session - ordering by its relay's start and then its number, and the set only grows, - so it removes only routes the iteration would remove. -- A node that announces no claim offers no route to itself, which removes - only routes no request names. -- A named drain sets a route's drain from its path and the nodes known - draining, and the drain still travels in the offer, so the order stays one - order. -- A claim ranks by the route to its announcer joined with its own drain, - priority, and cost; show an echo across two grants never beats the claim it - echoes. - -A node advertising once per burst changes no fixed point. - -State plainly what the theorem does not give, and where each is covered: - -- No loop at every instant: [requests](https://github.com/moq-dev/moq/pull/8881) fail - closed instead. -- A cost that depends on who subscribed: - [warmth](/quest/m2/multicast/warmth.md) argues it separately. -- Liveness under churn that never stops. -- That the tree is loop-free once routes settle: one paragraph, since next - hops toward one origin node at a fixed point cannot cycle and a request - names its origin node. - -TLA+ stays for the session, subscription, and failover state machines, where -orderings matter. `RouteHandoff.tla` describes the rule being replaced and -goes with it in the [switch](/quest/m2/multicast/switch.md). Report how long -the Agda check takes. - -Public API: none. Wire: none. diff --git a/quest/m2/multicast/router.md b/quest/m2/multicast/router.md index a2d1ca2aea4..d08501f2cd8 100644 --- a/quest/m2/multicast/router.md +++ b/quest/m2/multicast/router.md @@ -114,7 +114,7 @@ the [epic](/quest/m2/multicast/README.md)'s items 13 and 14): - Selected routes looped for a moment in partitions and deaths (up to 3 rounds at 32 relays, where today's reached 4); requests must fail closed first. -Found 2026-11-16 by the [proof](/quest/m2/multicast/proof.md) +Found 2026-11-16 by the [proof](/rs/moq-net/verify/route-algebra/README.md) ([moq-dev/moq#8904](https://github.com/moq-dev/moq/pull/8904), whose `rs/moq-net/verify/route-algebra/README.md` holds the arguments): diff --git a/quest/m2/multicast/warmth.md b/quest/m2/multicast/warmth.md index 085c6ca7447..2ffc4215379 100644 --- a/quest/m2/multicast/warmth.md +++ b/quest/m2/multicast/warmth.md @@ -90,7 +90,7 @@ when readers only join (Imase and Waxman, 1991). Leaves and moves are what the sweep adds to that. A cost that depends on who subscribed is outside the -[proof](/quest/m2/multicast/proof.md)'s theorem. Argue it separately and +[proof](/rs/moq-net/verify/route-algebra/README.md)'s theorem. Argue it separately and sweep it: taking a route only makes it cheaper for others, and leaving one only worsens an offer nobody uses. A cycle that outlasts the messages in flight fails the mechanism; count the transient ones with the readers they From 6f5b9d5e2ebcf797203c123ff7479491098d0f98 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 09:51:21 -0800 Subject: [PATCH 10/11] docs(moq-net): point the sticky tests and the claim instance at the proof's own README The paper argument and the chain mapping live in rs/moq-net/verify/route-algebra/README.md; rs/moq-net/verify/README.md only summarizes them. Co-Authored-By: Claude Fable 5.2 --- rs/moq-net/src/route/tests/sticky.rs | 2 +- rs/moq-net/verify/route-algebra/Claim.agda | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/rs/moq-net/src/route/tests/sticky.rs b/rs/moq-net/src/route/tests/sticky.rs index b9731439397..831d1320134 100644 --- a/rs/moq-net/src/route/tests/sticky.rs +++ b/rs/moq-net/src/route/tests/sticky.rs @@ -4,7 +4,7 @@ //! The route proof (`rs/moq-net/verify/route-algebra`) breaks ties between routes //! of equal draining, priority, cost, and mark by a fixed order, so it has one //! fixed point. Staying on the next hop in use makes the choice depend on what -//! came first, which the proof does not cover. `rs/moq-net/verify/README.md` +//! came first, which the proof does not cover. `rs/moq-net/verify/route-algebra/README.md` //! argues on paper that the rule still settles, at every node on the rank and mark //! the fixed order would give it; these tests check both. diff --git a/rs/moq-net/verify/route-algebra/Claim.agda b/rs/moq-net/verify/route-algebra/Claim.agda index 399b581db84..fe3d92dfaec 100644 --- a/rs/moq-net/verify/route-algebra/Claim.agda +++ b/rs/moq-net/verify/route-algebra/Claim.agda @@ -9,7 +9,7 @@ -- grant. Each step only adds: it may make the claim draining, raise its penalty, -- add cost, and prepends the node that took it, which refuses a claim that names -- it already. How Rust's claims map onto this, and where Rust's chain names fewer --- nodes than this path, is in `rs/moq-net/verify/README.md`. +-- nodes than this path, is in this directory's `README.md`. -------------------------------------------------------------------------------- module Claim where From e0b661424e0225aee64fd91347eaaaaac3cb889f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 16:29:12 -0800 Subject: [PATCH 11/11] docs(moq-net): state the progress premise of the route proof's convergence The theorem converges within an epoch that holds enough pseudocycles: every node keeps acting and keeps hearing newer messages from each neighbour. A link that loses everything for good is outside it, which the README, the verify summary, and the Agda comments now say. The README's links to the warmth and router quests, which their own PRs delete, point at those PRs. Co-Authored-By: Claude Fable 5.2 --- rs/moq-net/verify/README.md | 2 +- .../verify/route-algebra/Increasing.agda | 16 +++++++++------- rs/moq-net/verify/route-algebra/README.md | 18 +++++++++++++----- 3 files changed, 23 insertions(+), 13 deletions(-) diff --git a/rs/moq-net/verify/README.md b/rs/moq-net/verify/README.md index 4d51ee2573d..bd016626902 100644 --- a/rs/moq-net/verify/README.md +++ b/rs/moq-net/verify/README.md @@ -14,7 +14,7 @@ After a change to a covered function, mirror it in the model, rerun every config `route-algebra/` is not a model check: it states the multicast route rule as an increasing path algebra in Agda and applies Daggitt and Griffin's convergence theorem to it, checked nightly by `just test route-proof`. Its [README](route-algebra/README.md) holds the full coverage and the paper arguments. In short: -- Mechanized: the rule converges on every network, from every state, under any loss, reordering, and duplication, to one fixed point, with ties broken by one fixed order; the same for claims across trust boundaries; and the floor and the named drains leave that fixed point unchanged. +- Mechanized: the rule converges on every network, from every state, under loss, reordering, and duplication, to one fixed point, with ties broken by one fixed order, provided every node keeps acting and keeps hearing newer messages from each neighbour while the network holds still; the same for claims across trust boundaries; and the floor and the named drains leave that fixed point unchanged. - Tested against the proof: the prototype's rank and extend functions meet its axioms, and 322 of their results are checked by Agda. - On paper and tested, not mechanized: the rule as it runs puts the next hop in use ahead of the shorter path and the neighbour, so its stable state is not unique. It still settles, and every node settles on the rank and mark the fixed order gives it, except where a longer path meets the 32-hop limit; only the next hop varies. - Not given: loop freedom at every instant, warmth, liveness under endless churn, the chain as Rust records it, and which relays announce under `claimed`. diff --git a/rs/moq-net/verify/route-algebra/Increasing.agda b/rs/moq-net/verify/route-algebra/Increasing.agda index f16fb78fff7..731b6094c8d 100644 --- a/rs/moq-net/verify/route-algebra/Increasing.agda +++ b/rs/moq-net/verify/route-algebra/Increasing.agda @@ -12,10 +12,12 @@ -- cost, mark it, and prepend the link to its path. -- -- Any such algebra is an increasing path algebra, so Daggitt and Griffin's --- Theorem 5 applies: on every network, from every state, under every schedule --- of delayed, reordered, lost, and repeated messages, the asynchronous iteration --- reaches the network's unique fixed point once the network holds still long --- enough (`convergent`). +-- Theorem 5 applies: on every network, from every state, with messages delayed, +-- reordered, lost, and repeated, the asynchronous iteration reaches the network's +-- unique fixed point once the network holds still long enough (`convergent`). +-- Long enough means enough pseudocycles: every node keeps acting, and keeps +-- hearing from each neighbour something sent after any given moment. A link that +-- loses everything for good is outside the theorem. -------------------------------------------------------------------------------- open import Data.Bool.Base using (Bool; true; false; _∨_; if_then_else_) @@ -327,9 +329,9 @@ module Rule (P : Policy) where ------------------------------------------------------------------------ -- The theorem - -- Daggitt and Griffin, Theorem 5: on every network, from every state, under - -- every schedule, the asynchronous iteration reaches the unique fixed point of - -- each epoch that lasts long enough. + -- Daggitt and Griffin, Theorem 5: on every network, from every state, the + -- asynchronous iteration reaches the unique fixed point of each epoch whose + -- schedule holds enough pseudocycles. convergent : Convergent algebra convergent = incrPaths⇒convergent isRoutingAlgebra isPathAlgebra isIncreasing diff --git a/rs/moq-net/verify/route-algebra/README.md b/rs/moq-net/verify/route-algebra/README.md index 0cf500ce6b0..85cb79d9cee 100644 --- a/rs/moq-net/verify/route-algebra/README.md +++ b/rs/moq-net/verify/route-algebra/README.md @@ -5,9 +5,17 @@ The multicast route rule (`rs/moq-net/src/route/tests/multi.rs` with the epic's algebra in Agda, with Daggitt and Griffin's Theorem 5 applied to it ([arXiv 2106.01184](https://arxiv.org/abs/2106.01184), library [MatthewDaggitt/agda-routing](https://github.com/MatthewDaggitt/agda-routing)): -on every network, from every state, under every schedule of delayed, -reordered, lost, and repeated messages, the asynchronous iteration reaches the -network's unique fixed point once the network holds still long enough. +on every network, from every state, with messages delayed, reordered, lost, and +repeated, the asynchronous iteration reaches the network's unique fixed point +once the network holds still long enough. + +"Long enough" is a premise on progress, not only on time (the paper's +Definitions 14 to 17): while the network holds still, every node must keep +acting, and every node must keep hearing from each neighbour something sent +after any given moment, a fixed number of times over. Loss is tolerated only +within that. A link that loses everything for good never converges, though +nothing about the network changed. A session here is an ordered, reliable +stream, so it delivers or it closes, and a close is a change to the network. `just test route-proof` type-checks it with its own Agda pin (`nix/route-proof.nix`: Agda 2.6.4.3, standard-library 2.0, agda-routing at a @@ -104,7 +112,7 @@ never improves a claim in the real router (`a_grant_never_improves_a_claim`). [Requests](https://github.com/moq-dev/moq/pull/8881) name their origin node and fail closed instead. - **A cost that depends on who subscribed.** Warmth is not in the algebra; - [warmth](/quest/m2/multicast/warmth.md) argues it separately. + [warmth](https://github.com/moq-dev/moq/pull/8903) argues it separately. - **Liveness under churn that never stops.** Convergence needs each epoch to last long enough. - **The chain as Rust records it.** The claim instance's path names every node @@ -212,7 +220,7 @@ neighbour that order left without a route. ## Moving the binding to the production router The tests bind to the prototype, which the router quest -([router](/quest/m2/multicast/router.md)) replaces with `route/relay.rs`. When it +([router](https://github.com/moq-dev/moq/pull/8901)) replaces with `route/relay.rs`. When it lands, point `algebra.rs` and `sticky.rs` at the router's equivalents of `Offer::own`, `Offer::onward`, `Here::arrive`, `order`, and `candidates`, keeping them one function each that the router itself calls. Instantiate