     (make-lattice-nc base-set (fn [x y] (contains? order [x y])))))
 
 (defmethod make-lattice-nc [clojure-coll clojure-fn] [base-set order]
-  (let [base-set (set base-set),
-        inf      (memoize (fn inf [x y]
-                            (loop [elements base-set]
-                              (let [z (first elements)]
-                                (if (and (order z x)
-                                         (order z y)
-                                         (forall [a base-set]
-                                           (=> (and (order a x) (order a y))
-                                               (order a z))))
-                                  z
-                                  (recur (rest elements))))))),
-        sup      (memoize (fn sup [x y]
-                            (loop [elements base-set]
-                              (let [z (first elements)]
-                                (if (and (order x z)
-                                         (order y z)
-                                         (forall [a base-set]
-                                           (=> (and (order x a) (order y a))
-                                               (order z a))))
-                                  z
-                                  (recur (rest elements)))))))]
-    (Lattice. base-set order inf sup)))
+  (let [inf (memoize (fn inf [x y]
+                       (loop [elements base-set]
+                         (let [z (first elements)]
+                           (if (and (order z x)
+                                    (order z y)
+                                    (forall [a base-set]
+                                      (=> (and (order a x) (order a y))
+                                          (order a z))))
+                             z
+                             (recur (rest elements))))))),
+        sup (memoize (fn sup [x y]
+                       (loop [elements base-set]
+                         (let [z (first elements)]
+                           (if (and (order x z)
+                                    (order y z)
+                                    (forall [a base-set]
+                                      (=> (and (order x a) (order y a))
+                                          (order z a))))
+                             z
+                             (recur (rest elements)))))))]
+    (make-lattice-nc base-set order inf sup)))
 
 (defmethod make-lattice-nc [clojure-coll clojure-fn clojure-fn] [base-set inf sup]
-  (Lattice. (set base-set)
-            (fn [x y] (= y (sup x y)))
-            inf
-            sup))
+  (make-lattice-nc base-set
+                   (fn [x y] (= y (sup x y)))
+                   inf
+                   sup))
+
+(defmethod make-lattice-nc [clojure-coll clojure-fn clojure-fn clojure-fn]
+  [base-set order inf sup]
+  (Lattice. (set base-set) order inf sup))
 
 (defmethod make-lattice-nc :default [& args]
   (illegal-argument "The arguments " args " are not valid for a Lattice."))

  "Dualizes given lattice lat."
  [lat]
  (let [order (order lat)]
    (make-lattice-nc (base-set lat) (fn [x y] (order [y x])))))

(defn distributive?
  "Checks (primitively) whether given lattice lat is distributive or not."

(defn modular?
  "Checks (primitively) whether given lattice lat is modular or not."
  [lat]
  (let [inf  (inf lat),
        sup  (sup lat),
        base (base-set lat),
        ordr (order lat)]
    (forall [x base,
             y base,
             z base]
      (=> (ordr x z)
          (= (sup x (inf y z))
             (inf (sup x y) z))))))

(defn lattice-one
  "Returns the one element of lattice lat."
  [lat]
  (when (empty? (base-set lat))
    (illegal-argument "The lattice is empty and therefore cannot have a maximal element."))
  (let [order (order lat)]
    (reduce (fn [x a]
              (if (order x a) a x))
            (base-set lat))))

(defn lattice-zero
  "Returns the zero element of lattice lat."
  [lat]
  (when (empty? (base-set lat))
    (illegal-argument "The lattice is empty and therefore cannot have a minimal element."))
  (let [order (order lat)]
    (reduce (fn [x a]
              (if (order a x) a x))
            (base-set lat))))

(defn directly-neighboured?
  "Checks whether x is direct lower neighbour of y in lattice lat."
  [lat x y]
  (let [order (order lat)]
    (and (not= x y)
         (order x y)
         (let [base  (disj (base-set lat) x y)]
           (forall [z base]
             (not (and (order x z) (order z y))))))))

(defn lattice-upper-neighbours
  "Returns all direct upper neighbours of x in lattice lat."
  [lat x]
  (set-of y [y (base-set lat)
             :when (directly-neighboured? lat x y)]))

(defn lattice-lower-neighbours
  "Returns all direct lower neighbours of y in lattice lat."
  [lat y]
  (set-of x [x (base-set lat)
             :when (directly-neighboured? lat x y)]))

(defn lattice-atoms
  "Returns the lattice atoms of lat."
