My take on the google group question found here: https://groups.google.com/forum/#!topic/clojure/oe1Ch1oSlLk

virtual-time.clj

(ns spec-test.virtual-time
  (:require [clojure.spec :as s]
            [clojure.spec.test :as st]))

(s/def ::virtual-time
       (s/or 
        :positive-infinity #{:positive-infinity}
        :negative-infinity #{:negative-infinity}
        :number number?))
(s/fdef vt-lt
        :args (s/cat :left-vt ::virtual-time
                     :right-vt ::virtual-time)
        :ret boolean?
        :fn #(let [f (second (:left-vt (:args %)))
                   s (second (:right-vt (:args %)))
                   ret (:ret %)]
               (cond
                 (and (number? f)
                      (Double/isNaN f)) (false? ret)
                 (and (number? s)
                      (Double/isNaN s)) (false? ret)
                 (= f s) (false? ret)
                 (= :positive-infinity f) (false? ret)
                 (= :positive-infinity s) (true? ret)
                 (= :negative-infinity f) (true? ret)
                 (= :negative-infinity s) (false? ret)
                 (== f s) (false? ret)
                 (< f s) (true? ret)
                 (> f s) (false? ret))))
(s/fdef vt-eq
        :args (s/cat :left-vt ::virtual-time
                     :right-vt ::virtual-time)
        :ret boolean?
        :fn #(if
               (= (second (:left-vt (:args %))) (second (:right-vt (:args %))))
               (true? (:ret %))
               (false? (:ret %))))
(s/fdef vt-le
        :args (s/cat :left-vt ::virtual-time
                     :right-vt ::virtual-time)
        :ret boolean?
        :fn #(if (or (vt-eq (second (:left-vt (:args %))) (second (:right-vt (:args %))))
                     (vt-lt (second (:left-vt (:args %))) (second (:right-vt (:args %)))))
               (true? (:ret %))
               (false? (:ret %))))

(defn vt-lt [left-vt right-vt]
  (if (or (and (number? left-vt)
               (Double/isNaN left-vt))
          (and (number? right-vt)
               (Double/isNaN right-vt)))
    false
    (case left-vt
          :negative-infinity
          (case right-vt
                :negative-infinity false
                #_otherwise true)
          :positive-infinity false
          ;; otherwise: left-vt is a number.
          (case right-vt
                :positive-infinity true
                :negative-infinity false
                #_otherwise (< left-vt right-vt)))))

(defn vt-eq [left-vt right-vt]
  (= left-vt right-vt))

(defn vt-le [left-vt right-vt]
  (or (vt-eq left-vt right-vt)
      (vt-lt left-vt right-vt)))

(st/summarize-results (st/check))