         ;; find strokes that fail axiom 7
         jg-fixed (loop [jg jg-premises]
                    (if-let [jg2 (remove-bad-stroke jg)]
-                     (recur jg2) jg))]
+                     (recur jg2) jg))
+        accessible (alg/pre-traverse (graph/graph (:graph jg-fixed)) (first (shuffle (graph/nodes (:graph jg-fixed)))))]
+    #_(prn "accessible:" accessible)
+    #_(prn "not-accessible:" (set/difference (set (graph/nodes (:graph jg-fixed)))
+                                           (set accessible)))
     #_(prn "nodes" nodes)
     #_(prn "node-groups" (doall node-groups))
     #_(prn "node-groups-squared" (doall node-groups-squared))
-    jg-fixed))
+    (reduce remove-node-or-stroke
+            jg-fixed
+            (set/difference (set (graph/nodes (:graph jg-fixed)))
+                            (set accessible)))))
 
 (defn count-changes
-  [jg1 jg2]
+  [jg1 jg2 ignore]
   (assert (= (:graph jg1) (:graph jg2)))
   (let [bel1 (set (believed jg1))
-        bel2 (set (believed jg2))]
-    (count (filter (fn [n] (or (and (bel1 n) (not (bel2 n)))
-                               (and (not (bel1 n)) (bel2 n))))
+        bel2 (set (believed jg2))
+        ignore-set (set ignore)]
+    (count (filter (fn [n] (and (or (and (bel1 n) (not (bel2 n)))
+                                    (and (not (bel1 n)) (bel2 n)))
+                                (not (ignore-set n))))
                    (nodes jg1)))))
-
-(defn expand-random
-  [jg chance-expand black-strategy white-strategy]
-  (let [expandable (filter (fn [_] (> chance-expand (rand))) (nodes jg))]
-    (expand jg expandable :black-strategy black-strategy :white-strategy white-strategy)))
-
-(defn contract-random
-  [jg chance-contract black-strategy white-strategy]
-  (let [contractable (filter (fn [_] (> chance-contract (rand))) (nodes jg))]
-    (contract jg contractable :black-strategy black-strategy :white-strategy white-strategy)))
 
 (defn strategy-rand
   [_ bad-strokes bad-nodes]

  [_ bad-strokes bad-nodes]
  (if (empty? bad-nodes) (rand-nth bad-strokes) (rand-nth bad-nodes)))

(defn find-black-strategy
  [strat-name]
  (case strat-name
    "default" strategy-rand
    "pref-stroke" strategy-pref-stroke
    "pref-node" strategy-pref-node))

(defn find-white-strategy
  [strat-name]
  (case strat-name
    "default" strategy-rand
    "pref-stroke" strategy-pref-stroke
    "pref-node" strategy-pref-node))

(defn compare-expand-strategies
  []
  (let [strategies ["default" "pref-stroke" "pref-node"]
        chances-split [0.25 0.50 0.75]
        chances-expand-contract [0.02 0.04 0.06 0.08 0.10]
        chances-and [0.0 0.25 0.5 0.75 1.0]
        cases 100
        i (atom 0)
        total (* (count chances-split) (count chances-expand-contract) (count chances-and) cases)]
    (profile
      :debug :compare-expand-strategies
      (doall (apply concat
                    (for [chance-split chances-split
                          chance-expand-contract chances-expand-contract
                          chance-and chances-and
                          case (range cases)]
                      (let [jg (gen-random-andor-graph (+ 2 (rand-int 100)) chance-split chance-and)]
                        (swap! i inc)
                        (prn (format "%d/%d" @i total))
                        (if (empty? (nodes jg))
                          []
                          (for [strategy strategies
                                change-type [:expand :contract]]
                            (let [time-start (System/nanoTime)
                                  changes (if (= :expand change-type)
                                            (let [jg-new (expand-random jg chance-expand-contract
                                                                        (find-black-strategy strategy)
                                                                        (find-white-strategy strategy))]
                                              (count-changes jg jg-new))
                                            (let [jg-black (reduce assert-black jg (concat (strokes jg) (nodes jg)))
                                                  jg-new (contract-random jg-black chance-expand-contract
                                                                          (find-black-strategy strategy)
                                                                          (find-white-strategy strategy))]
                                              (count-changes jg-black jg-new)))
                                  change-pct (double (* 100.0 (/ changes (count (nodes jg)))))
                                  time-diff (- (System/nanoTime) time-start)]
                              {:ChanceSplit  chance-split :ChanceExpandContract chance-expand-contract :ChanceAnd chance-and
                               :Strategy     strategy :ChangeType (name change-type)
                               :Case         case :ChangePct change-pct :Nodes (count (nodes jg)) :Strokes (count (strokes jg))
                               :Microseconds time-diff}))))))))))

(defn dump-csv
  [results fname]

        node-groups (split-vec nodes chance-split)
        node-groups-squared (mapcat (fn [[ns1 ns2]] (split-vec (vec (concat ns1 ns2)) chance-split))
                                    node-groups)
        node-groups-cubed (mapcat (fn [[ns1 ns2]] (split-vec (vec (concat ns1 ns2)) chance-split))
                                  node-groups-squared)
        paired (map (fn [ng] (concat ng (if (> chance-and (rand)) [:forall-just] [:exists-just])))
                    node-groups-cubed)
        jg (new-just-graph)
        jg2 (reduce (fn [jg [node-group1 node-group2 linktype]]
                      #_(prn node-group1 node-group2 linktype)
