changeset 779:7e5dfe642064

remove black depth on RBTreeInvariant and introduce black-count
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 26 Jun 2023 20:04:38 +0900
parents 4d71d0894cfa
children f7e1704305df
files hoareBinaryTree1.agda
diffstat 1 files changed, 102 insertions(+), 89 deletions(-) [+]
line wrap: on
line diff
--- a/hoareBinaryTree1.agda	Mon May 22 19:06:08 2023 +0900
+++ b/hoareBinaryTree1.agda	Mon Jun 26 20:04:38 2023 +0900
@@ -530,39 +530,52 @@
     Red : Color
     Black : Color
 
-data RBtreeInvariant {n : Level} {A : Set n} : (tree : bt (Color ∧ A)) → (bd : ℕ) → Set n where
-    rb-leaf     : RBtreeInvariant leaf 0
-    rb-single : (key : ℕ) → (value : A) →  RBtreeInvariant (node key ⟪ Black , value ⟫ leaf leaf) 1
+black-depth : {n : Level} {A : Set n} → (tree : bt (Color ∧ A) ) → ℕ
+black-depth leaf = 0
+black-depth (node key ⟪ Red , value ⟫  t t₁) = black-depth t  ⊔ black-depth t₁ 
+black-depth (node key ⟪ Black , value ⟫  t t₁) = suc (black-depth t  ⊔ black-depth t₁ )
+
+data RBtreeInvariant {n : Level} {A : Set n} : (tree : bt (Color ∧ A)) → Set n where
+    rb-leaf     : RBtreeInvariant leaf 
+    rb-single : (key : ℕ) → (value : A) →  RBtreeInvariant (node key ⟪ Black , value ⟫ leaf leaf) 
     rb-right-red : {key key₁ : ℕ} → {value value₁ : A} → {t t₁ : bt (Color ∧ A)} 
-       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ t t₁) 1
-       → RBtreeInvariant (node key  ⟪ Red ,   value  ⟫ leaf (node key₁ ⟪ Black , value₁ ⟫ t t₁)) 1
+       → black-depth t ≡ black-depth t₁
+       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ t t₁) 
+       → RBtreeInvariant (node key  ⟪ Red ,   value  ⟫ leaf (node key₁ ⟪ Black , value₁ ⟫ t t₁)) 
     rb-right-black : {key key₁ : ℕ} → {value value₁ : A} → {t t₁ : bt (Color ∧ A)} → {c : Color}
-       → RBtreeInvariant (node key₁ ⟪ c     , value₁ ⟫ t t₁) 1
-       → RBtreeInvariant (node key  ⟪ Black , value  ⟫ leaf (node key₁ ⟪ c , value₁ ⟫ t t₁)) 1
+       → black-depth t ≡ black-depth t₁
+       → RBtreeInvariant (node key₁ ⟪ c     , value₁ ⟫ t t₁) 
+       → RBtreeInvariant (node key  ⟪ Black , value  ⟫ leaf (node key₁ ⟪ c , value₁ ⟫ t t₁)) 
     rb-left-red : {key key₁ : ℕ} → {value value₁ : A} → {t t₁ : bt (Color ∧ A)} 
-       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ t t₁) 1
-       → RBtreeInvariant (node key₁  ⟪ Red ,   value  ⟫ (node key ⟪ Black , value₁ ⟫ t t₁) leaf ) 1
+       → black-depth t ≡ black-depth t₁
+       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ t t₁) 
+       → RBtreeInvariant (node key₁  ⟪ Red ,   value  ⟫ (node key ⟪ Black , value₁ ⟫ t t₁) leaf ) 
     rb-left-black : {key key₁ : ℕ} → {value value₁ : A} → {t t₁ : bt (Color ∧ A)} → {c : Color}
-       → RBtreeInvariant (node key₁ ⟪ c     , value₁ ⟫ t t₁) 1
-       → RBtreeInvariant (node key₁  ⟪ Black , value  ⟫ (node key ⟪ c , value₁ ⟫ t t₁) leaf) 1
-    rb-node-red  : {key key₁ key₂ : ℕ} → {value value₁ value₂ : A} → {t₁ t₂ t₃ t₄ : bt (Color ∧ A)} → (d : ℕ)
-       → RBtreeInvariant (node key ⟪ Black , value ⟫ t₁ t₂) d
-       → RBtreeInvariant (node key₂ ⟪ Black , value₂ ⟫ t₃ t₄) d
-       → RBtreeInvariant (node key₁ ⟪ Red , value₁ ⟫ (node key ⟪ Black , value ⟫ t₁ t₂) (node key₂ ⟪ Black , value₂ ⟫ t₃ t₄)) d
-    rb-node-black  : {key key₁ key₂ : ℕ} → {value value₁ value₂ : A} → {t₁ t₂ t₃ t₄ : bt (Color ∧ A)} → (d : ℕ)
+       → black-depth t ≡ black-depth t₁
+       → RBtreeInvariant (node key₁ ⟪ c     , value₁ ⟫ t t₁) 
+       → RBtreeInvariant (node key₁  ⟪ Black , value  ⟫ (node key ⟪ c , value₁ ⟫ t t₁) leaf) 
+    rb-node-red  : {key key₁ key₂ : ℕ} → {value value₁ value₂ : A} → {t₁ t₂ t₃ t₄ : bt (Color ∧ A)} 
+       → black-depth t₁ ≡ black-depth t₂
+       → RBtreeInvariant (node key ⟪ Black , value ⟫ t₁ t₂) 
+       → black-depth t₃ ≡ black-depth t₄
+       → RBtreeInvariant (node key₂ ⟪ Black , value₂ ⟫ t₃ t₄) 
+       → RBtreeInvariant (node key₁ ⟪ Red , value₁ ⟫ (node key ⟪ Black , value ⟫ t₁ t₂) (node key₂ ⟪ Black , value₂ ⟫ t₃ t₄)) 
+    rb-node-black  : {key key₁ key₂ : ℕ} → {value value₁ value₂ : A} → {t₁ t₂ t₃ t₄ : bt (Color ∧ A)} 
        → {c c₁ : Color}
-       → RBtreeInvariant (node key  ⟪ c  , value  ⟫ t₁ t₂) d
-       → RBtreeInvariant (node key₂ ⟪ c₁ , value₂ ⟫ t₃ t₄) d
-       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ (node key ⟪ c , value ⟫ t₁ t₂) (node key₂ ⟪ c₁ , value₂ ⟫ t₃ t₄)) (suc d)
+       → black-depth t₁ ≡ black-depth t₂
+       → RBtreeInvariant (node key  ⟪ c  , value  ⟫ t₁ t₂) 
+       → black-depth t₃ ≡ black-depth t₄
+       → RBtreeInvariant (node key₂ ⟪ c₁ , value₂ ⟫ t₃ t₄) 
+       → RBtreeInvariant (node key₁ ⟪ Black , value₁ ⟫ (node key ⟪ c , value ⟫ t₁ t₂) (node key₂ ⟪ c₁ , value₂ ⟫ t₃ t₄)) 
 
-tesr-rb-0 : RBtreeInvariant {_} {ℕ} leaf 0
+tesr-rb-0 : RBtreeInvariant {_} {ℕ} leaf 
 tesr-rb-0 = rb-leaf
 
-tesr-rb-1 : RBtreeInvariant {_} {ℕ} (node 10 ⟪ Black , 10 ⟫ leaf leaf) 1
+tesr-rb-1 : RBtreeInvariant {_} {ℕ} (node 10 ⟪ Black , 10 ⟫ leaf leaf) 
 tesr-rb-1 = rb-single 10 10
 
-tesr-rb-2 : RBtreeInvariant {_} {ℕ} (node 10 ⟪ Red , 10 ⟫ (node 5 ⟪ Black , 5 ⟫ leaf leaf)  leaf) 1
-tesr-rb-2 = rb-left-red  ( rb-single 10 5)
+tesr-rb-2 : RBtreeInvariant {_} {ℕ} (node 10 ⟪ Red , 10 ⟫ (node 5 ⟪ Black , 5 ⟫ leaf leaf)  leaf) 
+tesr-rb-2 = rb-left-red refl ( rb-single 10 5)
 
 color : {n : Level} {A : Set n}  → (rb : bt (Color ∧ A)) → Color
 color leaf = Red
@@ -620,9 +633,9 @@
        od d rd : ℕ
        tree rot : bt (Color ∧ A)
        origti : treeInvariant orig 
-       origrb : RBtreeInvariant orig od
-       treerb : RBtreeInvariant tree d
-       replrb : RBtreeInvariant repl rd
+       origrb : RBtreeInvariant orig 
+       treerb : RBtreeInvariant tree 
+       replrb : RBtreeInvariant repl 
        d=rd : ( d ≡ rd ) ∨ ( (suc d ≡ rd ) ∧ (color tree ≡ Red))
        si : stackInvariant key tree orig stack
        rotated : rotatedTree tree rot
@@ -637,48 +650,48 @@
 --      find b in left and move the b to the right (one down or two down)
 --
 rbi-case1 : {n : Level} {A : Set n} → {key d : ℕ} → {value : A} → (parent repl : bt (Color ∧ A) ) 
-           → RBtreeInvariant parent (suc d)
-           → RBtreeInvariant repl d 
+           → RBtreeInvariant parent 
+           → RBtreeInvariant repl 
            → {left right : bt (Color ∧ A) } → parent ≡ node key ⟪ Black , value ⟫ left right
-           →    (color right ≡ Red → RBtreeInvariant (node key ⟪ Black , value ⟫ left repl  ) (suc d))
-             ∧  (color left  ≡ Red → RBtreeInvariant (node key ⟪ Black , value ⟫ repl right ) (suc d))
-rbi-case1 {n} {A} {key} = ?
+           →    (color right ≡ Red → RBtreeInvariant (node key ⟪ Black , value ⟫ left repl  ) )
+             ∧  (color left  ≡ Red → RBtreeInvariant (node key ⟪ Black , value ⟫ repl right ) )
+rbi-case1 {n} {A} {key} = {!!}
 
 rbi-case31 : {n : Level} {A : Set n} → {kg kp d dp : ℕ} → {vg vp : A} → {cg : Color} → (tree grand parent repl : bt (Color ∧ A) ) 
-           → RBtreeInvariant grand dp
-           → RBtreeInvariant repl d 
+           → RBtreeInvariant grand 
+           → RBtreeInvariant repl 
            → {uncle left right : bt (Color ∧ A) } 
            → grand  ≡ node kg ⟪ cg , vg ⟫ uncle parent
            → parent ≡ node kp ⟪ Red , vp ⟫ left  right
            → color uncle ≡ Red
-           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Red , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right )) dp) 
-              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Red , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  )) dp)
-rbi-case31 {n} {A} {key} = ?
+           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Red , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right )) ) 
+              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Red , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  )) )
+rbi-case31 {n} {A} {key} = {!!}
 
 --
 -- case4 increase the black depth
 --
 rbi-case41 : {n : Level} {A : Set n} → {kg kp d dp : ℕ} → {vg vp : A} → {cg : Color} → (tree grand parent repl : bt (Color ∧ A) ) 
-           → RBtreeInvariant grand dp
-           → RBtreeInvariant repl d 
+           → RBtreeInvariant grand 
+           → RBtreeInvariant repl  
            → {uncle left right : bt (Color ∧ A) } 
            → grand  ≡ node kg ⟪ cg , vg ⟫ uncle parent
            → parent ≡ node kp ⟪ Red , vp ⟫ left  right
            → color uncle ≡ Black
-           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right )) (suc dp) )
-              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  )) (suc dp) )
-rbi-case41 {n} {A} {key} = ?
+           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right ))  )
+              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  ))  )
+rbi-case41 {n} {A} {key} = {!!}
 
 rbi-case51 : {n : Level} {A : Set n} → {kg kp d dp : ℕ} → {vg vp : A} → {cg : Color} → (tree grand parent repl : bt (Color ∧ A) ) 
-           → RBtreeInvariant grand dp
-           → RBtreeInvariant repl d 
+           → RBtreeInvariant grand 
+           → RBtreeInvariant repl  
            → {uncle left right : bt (Color ∧ A) } 
            → grand  ≡ node kg ⟪ cg , vg ⟫ uncle parent
            → parent ≡ node kp ⟪ Red , vp ⟫ left  right
            → color uncle ≡ Black
-           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right )) (suc dp) )
-              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  )) (suc dp) )
-rbi-case51 {n} {A} {key} = ?
+           →     (color left  ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ repl right ))  )
+              ∧  (color right ≡ Red → RBtreeInvariant (node kg ⟪ Black , vg ⟫ uncle (node kp ⟪ Black , vp ⟫ left repl  ))  )
+rbi-case51 {n} {A} {key} = {!!}
 
 --... | Black = record {
 --             d = ? ; od = RBI.od rbi ; rd = ? 
@@ -726,24 +739,24 @@
 stackCase1 s-nil refl = refl
 
 PGtoRBinvariant : {n : Level} {A : Set n} → {key d0 ds dp dg : ℕ } → (tree orig : bt (Color ∧ A) )
-           →  RBtreeInvariant orig d0 
+           →  RBtreeInvariant orig 
            →  (stack : List (bt (Color ∧ A)))  → (pg : PG (Color ∧ A) tree stack )
-           →  RBtreeInvariant tree ds ∧  RBtreeInvariant (PG.parent pg) dp ∧  RBtreeInvariant (PG.grand pg) dg 
+           →  RBtreeInvariant tree ∧  RBtreeInvariant (PG.parent pg) ∧  RBtreeInvariant (PG.grand pg) 
 PGtoRBinvariant = {!!}
 
 findRBT : {n m : Level} {A : Set n} {t : Set m} → (key : ℕ) → (tree tree0 : bt (Color ∧ A) ) 
            → (stack : List (bt (Color ∧ A)))
            → treeInvariant tree0 ∧  stackInvariant key tree tree0 stack
-           → {d : ℕ} →  RBtreeInvariant tree0 d 
+           → {d : ℕ} →  RBtreeInvariant tree0 
            → (exit : (tree1 : bt (Color ∧ A)) → (stack : List (bt (Color ∧ A))) 
                  → treeInvariant tree1 ∧ stackInvariant key tree1 tree0 stack
-                 → {d1 : ℕ} → RBtreeInvariant tree1 d1 
+                 → {d1 : ℕ} → RBtreeInvariant tree1 
                  → (tree1 ≡ leaf ) ∨ ( node-key tree1 ≡ just key )  → t ) → t
-findRBT {_} {_} {A} {t} key tree0 leaf stack ti {d} rb0 exit = ?
+findRBT {_} {_} {A} {t} key tree0 leaf stack ti {d} rb0 exit = {!!}
 findRBT {_} {_} {A} {t} key tree0 (node key₁ value left right) stack ti {d} rb0 exit with <-cmp key key₁
-... | tri< a ¬b ¬c = ?
-... | tri≈ ¬a b ¬c = ?
-... | tri> ¬a ¬b c = ?
+... | tri< a ¬b ¬c = {!!}
+... | tri≈ ¬a b ¬c = {!!}
+... | tri> ¬a ¬b c = {!!}
 
 rotateLeft : {n m : Level} {A : Set n} {t : Set m}
      → (key : ℕ) → (value : A) 
@@ -757,10 +770,10 @@
         →  stack1 ≡ (orig ∷ [])
         →  RBI key value orig repl stack1
         → t ) → t
-rotateLeft {n} {m} {A} {t} key value = ? where
+rotateLeft {n} {m} {A} {t} key value = {!!} where
     rotateLeft1 : t
-    rotateLeft1 with stackToPG ? ? ? ?
-    ... | case1 x = ? -- {!!} {!!} {!!} {!!} rr
+    rotateLeft1 with stackToPG {!!} {!!} {!!} {!!}
+    ... | case1 x = {!!} -- {!!} {!!} {!!} {!!} rr
     ... | case2 (case1 x) = {!!}
     ... | case2 (case2 pg) = {!!}
 
@@ -776,9 +789,9 @@
         →  stack1 ≡ (orig ∷ [])
         →  RBI key value orig repl stack1
         → t ) → t
-rotateRight {n} {m} {A} {t} key value = ? where
+rotateRight {n} {m} {A} {t} key value = {!!} where
     rotateRight1 : t
-    rotateRight1 with stackToPG ? ? ? ?
+    rotateRight1 with stackToPG {!!} {!!} {!!} {!!}
     ... | case1 x = {!!}
     ... | case2 (case1 x) = {!!}
     ... | case2 (case2 pg) = {!!}
@@ -795,18 +808,18 @@
         →  stack1 ≡ (orig ∷ [])
         →  RBI key value orig repl stack1
         → t ) → t
-insertCase5 {n} {m} {A} {t} key value = ? where
+insertCase5 {n} {m} {A} {t} key value = {!!} where
     insertCase51 : t
-    insertCase51 with stackToPG ? ? ? ?
+    insertCase51 with stackToPG {!!} {!!} {!!} {!!}
     ... | case1 eq = {!!}
     ... | case2 (case1 eq ) = {!!}
     ... | case2 (case2 pg) with PG.pg pg
-    ... | s2-s1p2 x x₁ = ? -- rotateRight {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
+    ... | s2-s1p2 x x₁ = {!!} -- rotateRight {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
        -- x     : PG.parent pg ≡ node kp vp tree n1
        -- x₁    : PG.grand pg ≡ node kg vg (PG.parent pg) (PG.uncle pg)
-    ... | s2-1sp2 x x₁ = ? -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
-    ... | s2-s12p x x₁ = ? -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
-    ... | s2-1s2p x x₁ = ? -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
+    ... | s2-1sp2 x x₁ = {!!} -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
+    ... | s2-s12p x x₁ = {!!} -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
+    ... | s2-1s2p x x₁ = {!!} -- rotateLeft {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} next exit
     -- = insertCase2 tree (PG.parent pg) (PG.uncle pg) (PG.grand pg) stack si (PG.pg pg) 
 
 
@@ -824,7 +837,7 @@
         →  stack1 ≡ (orig ∷ [])
         →  RBI key value orig repl stack1
         → t ) → t
-replaceRBP {n} {m} {A} {t} key value orig repl stack r next exit = ? where
+replaceRBP {n} {m} {A} {t} key value orig repl stack r next exit = {!!} where
     insertCase2 : (tree parent uncle grand : bt (Color ∧ A)) 
       → (stack : List (bt (Color ∧ A))) → (si : stackInvariant key tree orig stack ) 
       → (pg : ParentGrand tree parent uncle grand ) → t
@@ -832,27 +845,27 @@
     insertCase2 tree leaf uncle grand stack si (s2-1sp2 () x₁) 
     insertCase2 tree leaf uncle grand stack si (s2-s12p () x₁) 
     insertCase2 tree leaf uncle grand stack si (s2-1s2p () x₁) 
-    insertCase2 tree parent@(node kp ⟪ Red , _ ⟫ _ _) uncle grand stack si pg = ? -- next {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!}
+    insertCase2 tree parent@(node kp ⟪ Red , _ ⟫ _ _) uncle grand stack si pg = {!!} -- next {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!}
     insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) leaf grand stack si pg = {!!}
-    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Red , _ ⟫ _ _ ) grand stack si pg = ? -- next {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!}
-    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-s1p2 x x₁) = ?
+    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Red , _ ⟫ _ _ ) grand stack si pg = {!!} -- next {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!} {!!}
+    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-s1p2 x x₁) = {!!}
           -- insertCase5 key value orig tree {!!} rbio {!!} {!!} stack si {!!} ri {!!} {!!} next exit
       -- tree is left of parent, parent is left of grand
       --  node kp ⟪ Black , proj3 ⟫ left right ≡ node kp₁ vp tree n1
       --  grand ≡ node kg vg (node kp ⟪ Black , proj3 ⟫ left right) (node ku ⟪ Black , proj4 ⟫ left₁ right₁)
-    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-1sp2 x x₁) = ?
+    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-1sp2 x x₁) = {!!}
           -- rotateLeft key value orig tree {!!} repl rbio {!!} {!!} stack si {!!} ri {!!} {!!} 
           --   (λ a b c d e f h i j k l m  → insertCase5 key value a b c d {!!} {!!} h i j k l {!!} {!!} next exit ) exit
       -- tree is right of parent, parent is left of grand  rotateLeft
       --  node kp ⟪ Black , proj3 ⟫ left right ≡ node kp₁ vp n1 tree
       --  grand ≡ node kg vg (node kp ⟪ Black , proj3 ⟫ left right) (node ku ⟪ Black , proj4 ⟫ left₁ right₁)
-    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-s12p x x₁) = ?
+    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-s12p x x₁) = {!!}
           -- rotateRight key value orig tree {!!} repl rbio {!!} {!!} stack si {!!} ri {!!} {!!} 
           --    (λ a b c d e f h i j k l m  → insertCase5 key value a b c d {!!} {!!} h i j k l {!!} {!!} next exit ) exit
       -- tree is left of parent, parent is right of grand, rotateRight
       -- node kp ⟪ Black , proj3 ⟫ left right ≡ node kp₁ vp tree n1
       --  grand ≡ node kg vg (node ku ⟪ Black , proj4 ⟫ left₁ right₁) (node kp ⟪ Black , proj3 ⟫ left right)
-    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-1s2p x x₁) = ?
+    insertCase2 tree parent@(node kp ⟪ Black , _ ⟫ _ _) (node ku ⟪ Black , _ ⟫ _ _) grand stack si (s2-1s2p x x₁) = {!!}
           -- insertCase5 key value orig tree {!!} repl rbio {!!} {!!} stack si {!!} ri {!!} {!!} next exit
       -- tree is right of parent, parent is right of grand
       -- node kp ⟪ Black , proj3 ⟫ left right ≡ node kp₁ vp n1 tree
@@ -860,24 +873,24 @@
     insertCase1 : t
     insertCase1 with stackToPG (RBI.tree r) orig stack (RBI.si r)
     ... | case1 eq = exit repl stack eq record {  -- exit rot repl rbir (subst (λ k → rotatedTree k rot) (stackCase1 si eq) roti) ri 
-       od = ? ; d = ? ; rd = ?
-       ; tree = RBI.tree r ; rot = ?
-       ; origti = ?
-       ; origrb = ?
-       ; treerb = ?
-       ; replrb = ?
-       ; d=rd = ?
-       ; si = ?
-       ; rotated = ?
-       ; ri = ? }
-    ... | case2 (case1 eq ) = ? where
-        insertCase12 : (to : bt (Color ∧ A)) → {d : ℕ} → RBtreeInvariant orig d  → to ≡ orig
-          → (rr : bt (Color ∧ A)) → {dr : ℕ} → RBtreeInvariant ? dr  → rr ≡ ?
-          → {stack : List (bt (Color ∧ A))} → (si : stackInvariant key ? to stack ) 
-          → stack ≡ ? ∷ to ∷ [] → t
-        insertCase12 = ?
+       od = {!!} ; d = {!!} ; rd = {!!}
+       ; tree = RBI.tree r ; rot = {!!}
+       ; origti = {!!}
+       ; origrb = {!!}
+       ; treerb = {!!}
+       ; replrb = {!!}
+       ; d=rd = {!!}
+       ; si = {!!}
+       ; rotated = {!!}
+       ; ri = {!!} }
+    ... | case2 (case1 eq ) = {!!} where
+        insertCase12 : (to : bt (Color ∧ A)) → {d : ℕ} → RBtreeInvariant orig   → to ≡ orig
+          → (rr : bt (Color ∧ A)) → {dr : ℕ} → RBtreeInvariant {!!}   → rr ≡ {!!}
+          → {stack : List (bt (Color ∧ A))} → (si : stackInvariant key {!!} to stack ) 
+          → stack ≡ {!!} ∷ to ∷ [] → t
+        insertCase12 = {!!}
     -- exit rot repl rbir ? ? 
-    ... | case2 (case2 pg) = ? -- insertCase2 tree (PG.parent pg) (PG.uncle pg) (PG.grand pg) stack si (PG.pg pg) 
+    ... | case2 (case2 pg) = {!!} -- insertCase2 tree (PG.parent pg) (PG.uncle pg) (PG.grand pg) stack si (PG.pg pg)