               [n (delay (lazy-walk g (get-neighbors g n) #{}))])
         nbs (into {} (map nns (nodes g)))]
     (make-directed-graph
-            (nodes g)
-            (fn [n] (force (nbs n))))))
+      (nodes g)
+      (fn [n] (force (nbs n))))))
 ;; Strongly Connected Components
 
 (defn- post-ordered-visit

These sets are the strongly connected components. Each edge will
be the union of the corresponding edges of the prior graph."
  ([g]
     (component-graph g (scc g)))
  ([g sccs]
     (let [find-node-set (fn [n]
                           (some #(if (% n) % nil) sccs))
           find-neighbors (fn [ns]
                            (let [nbs1 (map (partial get-neighbors g) ns)
                                  nbs2 (map set nbs1)
                                  nbs3 (apply union nbs2)]
                              (set (map find-node-set nbs3))))
           nm (into {} (map (fn [ns] [ns (find-neighbors ns)]) sccs))]
       (make-directed-graph (set sccs) nm))))

(defn recursive-component?
  "Is the component (recieved from scc) self recursive?"

provide a set of visited notes (v) and a collection of nodes to
visit (ns)."
  ([g n]
   (lazy-walk g [n] #{}))
  ([g ns v]
   (lazy-seq (let [s (seq (drop-while v ns))
                   n (first s)
                   ns (rest s)]
               (when s
                 (cons n (lazy-walk g (concat (get-neighbors g n) ns) (conj v n))))))))

(defn transitive-closure
  "Returns the transitive closure of a graph. The neighbors are lazily computed.
