 
 (defn parallel-closures
   "Returns the set of all closures of the closure operator on the given base set.
-Computes the closures in parallel, to the extent possible."
+  Computes the closures in parallel, to the extent possible."
   [base clop]
   (loop [n        0
          closures #{(clop #{})}

;;; Searching for minimum covers

(defn- covers?
  "Technical Helper. Tests wheterh all elements in base-set are contained at least one set in sets."
  [sets base-set]
  (if (empty? base-set)
    true

                     (long (/ power 2))))))))))

(defn distinct-by-key
  "Returns a sequence of all elements of the given sequence with distinct key
  values, where key is a function from the elements of the given sequence. If
  two elements correspond to the same key, the one is chosen which appeared
  earlier in the sequence.

  This function is copied from clojure.core/distinct and adapted for using a key
  function."
  [sequence key]
  (let [step (fn step [xs seen]
               (lazy-seq
                ((fn [xs seen]
                   (when-let [s (seq xs)]
                     (let [f     (first xs)
                           key-f (key f)]
                       (if (contains? seen key-f)
                         (recur (rest s) seen)
                         (cons f (step (rest s) (conj seen key-f)))))))
                 xs seen)))]
    (step sequence #{})))

(defn reduce!
