   "Creates an implication (premise => conclusion $\\setminus$ premise)."
   [premise conclusion]
   (let [premise (set premise)
-	conclusion (set conclusion)]
+        conclusion (set conclusion)]
     (Implication. premise (difference conclusion premise))))
 
 ;;;


(ns conexp.fca.implications
  (:use conexp.base
	conexp.fca.contexts))

;;;


  (forall [intent (context-intents ctx)]
    (respects? intent impl)))

(defn- close-under-implications
  "Computes smallest superset of start being closed under given implications."
  [implications start]
  ;; this is LinClosure
  (let [^HashMap counts (HashMap.),
        ^HashMap list   (HashMap.),
        ^HashSet update (HashSet. start),
        ^HashSet newdep (HashSet. start)]
    (doseq [impl implications]
      (.put counts impl (count (premise impl)))
      (doseq [a (premise impl)]
        (.put list a (conj (.get list a) impl))))
    (while (seq update)
      (let [a (first update)]
        (.remove update a)
        (doseq [impl (.get list a)]
          (.put counts impl (dec (.get counts impl)))
          (when (zero? (.get counts impl))
            (let [z (HashSet. (conclusion impl))]
              (.removeAll z newdep)
              (.addAll newdep z)
              (.addAll update z))))))
    (set newdep)))

(defn clop-by-implications
  "Returns closure operator given by implications."
