diff --git a/funcons-values.cabal b/funcons-values.cabal
--- a/funcons-values.cabal
+++ b/funcons-values.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                funcons-values
-version:             0.1.0.7
+version:             0.1.0.9
 synopsis:            Library providing values and operations on values in a fixed universe.
 description:         
     The PLanCompS project (<http://plancomps.org>) has developed a component-based approach to formal semantics.
@@ -49,7 +49,7 @@
                       ,Funcons.Operations.Internal
   other-extensions:    InstanceSigs, OverloadedStrings
   build-depends:       base >=4.8 && <5
-                      ,containers >=0.5 && <0.6
+                      ,containers >=0.5 && <= 0.6.0.1
                       ,vector >=0.12
                       ,bv >=0.5
                       ,multiset >=0.3 && <0.4
diff --git a/src/Funcons/Operations/ADTs.hs b/src/Funcons/Operations/ADTs.hs
--- a/src/Funcons/Operations/ADTs.hs
+++ b/src/Funcons/Operations/ADTs.hs
@@ -4,7 +4,6 @@
 
 import Funcons.Operations.Internal
 
-import Data.Maybe (fromJust, isJust)
 import Data.Text (pack, unpack)
 import Data.String(fromString)
 
diff --git a/src/Funcons/Operations/Characters.hs b/src/Funcons/Operations/Characters.hs
--- a/src/Funcons/Operations/Characters.hs
+++ b/src/Funcons/Operations/Characters.hs
@@ -1,10 +1,7 @@
 
 module Funcons.Operations.Characters where
 
-import Funcons.Operations.Booleans (tobool)
 import Funcons.Operations.Internal
-import Funcons.Operations.Integers
-import Funcons.Operations.Bits
 
 import Data.Char (ord,chr,isAscii)
 
diff --git a/src/Funcons/Operations/Eval.hs b/src/Funcons/Operations/Eval.hs
--- a/src/Funcons/Operations/Eval.hs
+++ b/src/Funcons/Operations/Eval.hs
@@ -4,11 +4,11 @@
 import Funcons.Operations.Expr
 import Funcons.Operations.Values hiding (showArgs)
 
-import Control.Monad
 import Data.List (intercalate)
 
 data EvalResult t = Error         (OpExpr t) (Result t)
                   | Success       t
+                  | EvalResults   [EvalResult t]
                   deriving (Show)
 
 eval :: HasValues t => OpExpr t -> EvalResult t
@@ -16,6 +16,7 @@
 
 applyEval :: OpExpr t -> Result t -> EvalResult t
 applyEval expr (Normal v) = Success v
+applyEval expr (Nondeterministic ress) = EvalResults (map (applyEval expr) ress)
 applyEval expr res = Error expr res 
  
 instance (HasValues t, Show t) => Show (OpExpr t) where
diff --git a/src/Funcons/Operations/Expr.hs b/src/Funcons/Operations/Expr.hs
--- a/src/Funcons/Operations/Expr.hs
+++ b/src/Funcons/Operations/Expr.hs
@@ -7,12 +7,17 @@
 
 type OP = String
 
-data Result t = SortErr     String -- sort mismatch
-              | DomErr      String -- domain mismatch (in case of partial op)
-              | ArityErr    String
-              | ProjErr     String -- cannot project to a value
-              | Normal      t 
+data Result t = SortErr           String -- sort mismatch
+              | DomErr            String -- domain mismatch (in case of partial op)
+              | ArityErr          String
+              | ProjErr           String -- cannot project to a value
+              | Normal            t
+              | Nondeterministic  [Result t] 
               deriving Show
+
+choice []  = error "Nondeterministic: no choice given"
+choice [t] = t
+choice ts  = Nondeterministic ts
  
 type NullaryOp t  = Result t
 type UnaryOp t    = t -> Result t
@@ -124,11 +129,12 @@
   RewritesTo _ e1 _             -> applyExpr e1
 
 instance Functor Result where
-  fmap f (SortErr err)  = SortErr err
-  fmap f (ProjErr err)  = ProjErr err
-  fmap f (DomErr err)   = DomErr err
-  fmap f (ArityErr err) = ArityErr err
-  fmap f (Normal v)     = Normal (f v)
+  fmap f (SortErr err)          = SortErr err
+  fmap f (ProjErr err)          = ProjErr err
+  fmap f (DomErr err)           = DomErr err
+  fmap f (ArityErr err)         = ArityErr err
+  fmap f (Normal v)             = Normal (f v)
+  fmap f (Nondeterministic vs)  = Nondeterministic (fmap (fmap f) vs)
 
 instance Applicative Result where
   pure = Normal
@@ -137,11 +143,12 @@
 instance Monad Result where
   return = Normal
   p >>= q = case p of
-    SortErr err   -> SortErr err
-    ProjErr err   -> ProjErr err
-    DomErr err    -> DomErr err
-    ArityErr err  -> ArityErr err
-    Normal f      -> q f 
+    SortErr err           -> SortErr err
+    ProjErr err           -> ProjErr err
+    DomErr err            -> DomErr err
+    ArityErr err          -> ArityErr err
+    Normal f              -> q f 
+    Nondeterministic fs   -> Nondeterministic (map (>>= q) fs)
 
 -- helper / smart constructors
 {-
diff --git a/src/Funcons/Operations/Floats.hs b/src/Funcons/Operations/Floats.hs
--- a/src/Funcons/Operations/Floats.hs
+++ b/src/Funcons/Operations/Floats.hs
@@ -3,8 +3,6 @@
 module Funcons.Operations.Floats where
 
 import Funcons.Operations.Internal hiding (isInt)
-import Funcons.Operations.Types
-import Funcons.Operations.Booleans (tobool)
 
 library :: HasValues t => Library t
 library = libFromList [
diff --git a/src/Funcons/Operations/Sets.hs b/src/Funcons/Operations/Sets.hs
--- a/src/Funcons/Operations/Sets.hs
+++ b/src/Funcons/Operations/Sets.hs
@@ -5,6 +5,7 @@
 import Funcons.Operations.Booleans
 import Funcons.Operations.Internal hiding (set_)
 
+import Data.List (permutations)
 import qualified Data.Set as S
 
 library :: (HasValues t, Ord t) => Library t
@@ -52,7 +53,9 @@
 set_elements_ = unaryOp set_elements
 set_elements :: HasValues t => OpExpr t -> OpExpr t
 set_elements = vUnaryOp "set-elements" op
- where op (Set s) = Normal $ inject $ multi $map inject $ S.toList s
+ where op (Set s) = Nondeterministic $ map (Normal . inject . multi 
+                                             . map inject) $ 
+                     permutations $ S.toList s
        op _ = SortErr "set-elements not applied to a set"
 
 set_size_ :: (Ord t, HasValues t) => [OpExpr t] -> OpExpr t
@@ -84,7 +87,7 @@
 some_element_ = unaryOp some_element
 some_element :: (HasValues t, Ord t) => OpExpr t -> OpExpr t
 some_element = vUnaryOp "some-element" op
-  where op (Set s) | not (S.null s) = Normal $ inject $ S.findMax s
+  where op (Set s) | not (S.null s) = choice $ map (Normal . inject) $ S.toList s
                    | otherwise      = Normal $ inject null__
         op _ = SortErr "some-element not applied to a set"
 
diff --git a/src/Funcons/Operations/Values.hs b/src/Funcons/Operations/Values.hs
--- a/src/Funcons/Operations/Values.hs
+++ b/src/Funcons/Operations/Values.hs
@@ -8,7 +8,7 @@
 import qualified Data.MultiSet as MS
 
 import qualified Data.Char as C
-import Data.Text (Text, pack, unpack)
+import Data.Text (Text, unpack)
 import Data.List (intercalate)
 import Data.Maybe (fromJust,isJust)
 import Data.String
@@ -42,6 +42,7 @@
                 | ValSeq [t] -- represents a multitude of values
         deriving (Eq,Ord,Show,Read)
 
+ascii_cons, unicode_cons :: Name 
 ascii_cons = "ascii-character"
 unicode_cons = "unicode-character"
 
@@ -50,6 +51,9 @@
 
 list :: HasValues t => [Values t] -> Values t
 list = ADTVal "list" . map inject
+
+set :: (Ord t, HasValues t) => [Values t] -> Values t
+set = Set . S.fromList
 
 vector :: HasValues t => [Values t] -> Values t
 vector = ADTVal "vector" . map inject