diff --git a/README.md b/README.md
deleted file mode 100644
--- a/README.md
+++ /dev/null
@@ -1,81 +0,0 @@
-quickcheck-property-comb
---------
-These are combinators, based on the Reader and Writer Monads, to allow for fast
-and painless Quickcheck property/invariant construction.
-
-Why?
-----
-[Quickcheck](http://hackage.haskell.org/package/QuickCheck) is a tool used to
-test cases based on constructed Properties, or essentially functions taking a
-data structure and returning a boolean True or False. 
-
-However when running tests, the only way to document their failing case
-is through labeling them after binding, e.g.: 
-
-```haskell
-inv1, inv2, inv3 :: Foo -> Bool 
-..
-fooInvariants :: Foo -> Property 
-fooInvariants f = 
-    conjoin . map property $ 
-      conjoin $ zipWith toLabeled
-        ["foo should be even", "foo should contain 3 bar", "all bar should not equal foo"] 
-        [inv1 f, inv2 f, inv3 f]
-```
-
-This gets unwieldy fast as the complexity of the data-structure increases, so
-quickcheck-property-comb provides the following:
-  - Monadically unifies composition of invariants and the documenting of those invariants for determining cause of failure.
-  - Effective diagnostics for invariants with changing post-conditions,
-    leading to <b>faster cause-of-failure diagnosis</b>.
-
-Example use
------------
-```haskell
-data (Ord l) => QuantityConsumers l =
-  QuantityConsumers {
-    atQuantity :: S.Set l,
-    qcMet :: M.Map (S.Set l) Bool,
-    qcDisjoints :: Disjoints l
-  }
-
-disjoint_sizes ::  Inv (Disjoints l)
-disjoint_sizes = do
-  doc . unlines $
-    [
-     "the intersection of all at quantity and disjoints are the only allowed",
-     "singleton sets in disjoints"
-    ]
-  disjoints <- cause 
-  -- Do some checking on disjoints 
-  return False
-
-disjoints_eq :: Inv (Disjoints l)
-disjoints_eq = do
-  doc "the solution state domain and sets formed by partition are equal"
-  ..
-  return False
-
-disjoints :: Invariants (Disjoints l)
-disjoints = do
-  sat disjoints_eq
-  sat disjoints_sizes
-
-at_quantity_in_disjoint :: Inv (QuantityConsumers l)
-at_quantity_in_disjoint = do
-  doc "all at quantity are a singleton subset in disjoints"
-
-  subsets       <- (map S.singleton) . S.toList . atQuantity <$> cause
-  disjoint_sets <- fromDisjoints <$>  cause
-
-  return . and . map ((flip S.member) disjoint_sets) $ subsets
-
-inv_quantity_consumers :: Invariants (QuantityConsumers l)
-inv_quantity_consumers = do
-  satcomp qcDisjoints disjoints
-  sat at_quantity_in_disjoint
-
--- Then to create the final property
-prop_quantity_consumers :: QuantityConsumers l -> Property
-prop_quantity_consumers q = runInvariants q inv_quantity_consumers
-```
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/quickcheck-property-comb.cabal b/quickcheck-property-comb.cabal
--- a/quickcheck-property-comb.cabal
+++ b/quickcheck-property-comb.cabal
@@ -2,7 +2,7 @@
 -- further documentation, see http://haskell.org/cabal/users-guide/
 
 name:                quickcheck-property-comb
-version:             0.1.0.1
+version:             0.1.0.2
 synopsis:            Combinators for Quickcheck Property construction and diagnostics
 description:         
   These are simple monads that aim to reduce the pain of composing
@@ -12,7 +12,7 @@
   for invariants with changing post-conditions, leading to a
   faster cause-of-failure diagnosis.
   .
-  Example case for invariants on a data structure "Consumers".
+  Example case for invariants on a data structure Consumers:
   .
   > data (Ord l) => Consumers l =
   >   Consumers {
@@ -21,33 +21,29 @@
   >     disjoints :: Disjoints l
   >   }
   >
-  > introduced_in_disjoint :: Inv (Consumers l)
-  > introduced_in_disjoint = do
-  >   doc "all at quantity are a singleton subset in disjoints"
-  >   subsets       <- (map S.singleton) . S.toList . introduced <$> cause
-  >   disjoint_sets <- disjoints <$> cause
-  >   return . and . map ((flip S.member) disjoint_sets) $ subsets
-  > 
-  > disjoint_sizes ::  Inv (Disjoints l)
-  > disjoint_sizes = do
-  >  doc . unlines $
-  >    [ "the intersection of introduced and disjoints are the only allowed",
-  >     "singleton sets in disjoints"
-  >      ]
-  >  disjoints' <- cause 
-  >  -- Do the checking
+  > disjoints_odds ::  Inv (Disjoints l)
+  > disjoints_odds = do
+  >  doc "no odd sets in disjoints"
+  >  disjoint_sets <- cause 
+  >  ..
   >  return False
   >
-  > disjoints_eq :: Inv (Disjoints l)
-  > disjoints_eq = do
-  >   doc "disjoint sets are equal in size"
-  >   -- ..
+  > disjoints_non_singletons :: Inv (Disjoints l)
+  > disjoints_non_singletons = do
+  >   ..
   >   return True
   >
   > disjoints_inv :: Invariants (Disjoints l)
   > disjoints_inv= do
-  >   sat disjoints_eq
-  >   sat disjoints_sizes
+  >   sat disjoints_odds
+  >   sat disjoints_non_singletons
+  >
+  > introduced_in_disjoint :: Inv (Consumers l)
+  > introduced_in_disjoint = do
+  >   doc "all at quantity are a singleton subset in disjoints"
+  >   subsets       <- (map S.singleton) . S.toList . introduced <$> cause
+  >   disjoint_sets <- disjoints <$> cause
+  >   return . and . map ((flip S.member) disjoint_sets) $ subsets
   > 
   > inv_consumers :: Invariants (Consumers l)
   > inv_consumers = do
@@ -55,7 +51,7 @@
   >   satcomp met met_inv
   >   sat introduced_in_disjoint
   . 
-  And to run the Consumer invariant on generated cases: 
+  And to run the invariants on generated cases:
   .
   > prop_testedFunction :: Arg -> Property
   > prop_testedFunction arg =