   ""
   [object-count attribute-count incidence-matrix #^BitSet A i]
   (let [#^BitSet A-short (.clone A)
+	#^BitSet B (BitSet.)
 	i (int i)]
     (.set A-short i true)
     (.set A-short (inc i) (int attribute-count) false)
-    (bitwise-object-derivation incidence-matrix
-			       object-count
-			       attribute-count
-			       (bitwise-attribute-derivation incidence-matrix
-							     object-count
-							     attribute-count
-							     A-short))))
+    (dotimes [obj object-count]
+      (if (forall-in-bitset A-short att (== 1 (deep-aget ints incidence-matrix obj att)))
+	(.set B obj)))
+    (dotimes [att attribute-count]
+      (if (and (not (.get A-short att))
+	       (forall-in-bitset B obj (== 1 (deep-aget ints incidence-matrix obj att))))
+	(.set A-short att)))
+    A-short))
 
 (defn next-closed-set
   ""

			incidence-matrix rows,
			empty-down empty-down-up 0))))


;; In-Close (:in-close)

;;; Luxenburger Basis

;;;

	      (int 1)
	      (int 0))))
    incidence-matrix))

(defn to-binary-context
  ""
  [context]
  (let [object-vector (vec (objects context))
	attribute-vector (vec (attributes context))

	object-count (count object-vector)
	attribute-count (count attribute-vector)

	incidence-matrix (to-binary-matrix object-vector attribute-vector (incidence context))]
    [object-vector attribute-vector,
     object-count  attribute-count,
     incidence-matrix]))

(defn bitwise-object-derivation
  ""
