diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,8 +1,59 @@ * Hackage: * GitHub: -* Latest Hackage released version: 8.6, 2020-02-08 +* Latest Hackage released version: 8.7, 2020-06-30 +### Version 8.7, 2020-06-30 + + * Add support for concurrent versions of solvers for query + problems. Similar to 'satWithAny', 'proveWithAny' etc., + except when we have queries. Thanks to Jeffrey Young + for the idea and the implementation. + + * Add "Documentation.SBV.Examples.Misc.Newtypes", demonstrating + how to use newtypes over existing symbolic types as + symbolic quantities themselves. Thanks to Curran McConnell + for the example. + + * Added new predicate `sNotElem`, negating `sElem`. + + * Added new predicate `distinctExcept`. This is same as `distinct` + except you can also provide an ignore list. The elements in + the first list will be checked to be distinct from each other, + or belong to the second list. This is good for writing constraints + that either require a default value or if picked be different + from each other for a set of variables. This sort of constraint + can be coded in user space, but SBV generates efficient code + instead of the obvious quadratic number of constraints. + + * Add function 'algRealToRational' that can convert an algebraic-real + to a Haskell rational. We get an either value: If the algebraic real + is exact, then it returns a 'Left' value that represents the value + precisely. Otherwise, it returns a 'Right' value, which is only + an approximation. Note: Setting 'printRealPrec' in SMTConfig + to a higher value will increase the precision at the cost of more + computation by the SMT solver. + + * Removed the 'SMTValue' class. It's functionality was not really + needed. If you ever used this class, removing it from your + type signatures should fix the issue. (You might have to + add SymVal constraint if you did not already have it.) Please + get in touch if you used this class in some cunning way and you + need its functionality back. + + * Reworked SBVBenchSuite api, Phase 1 of BenchSuite completed. + + * Add support for addAxiom command to work in the interactive mode. + Thanks to Martin Lundfall for the feedback. + + * Fixed `proveWithAny` and `satWithAny` functions so they properly + kill the solvers that did not terminate first. Previously, they + became zombies if they didn't end up quickly. Thanks to + Robert Dockins for the investigation and the fix. + + * Fixed a bug where resetAssertions call was forgetting to restore the + array and table contexts. Thanks to Martin Lundfall for reporting. + ### Version 8.6, 2020-02-08 * Fix typo in error message. Thanks to Oliver Charles @@ -324,7 +375,7 @@ then your float value will be minimized as the corresponding 32 (or 64 for doubles) bit word. Note that this methods supports infinities properly, and does not distinguish between -0 and +0. - + * Optimization routines have been generalized to work over arbitrary metric-spaces, with user-definable mappings. The simplest instance we have added is optimization over booleans, by the obvious numeric mapping. Tuples are also supported with @@ -394,7 +445,7 @@ * Existential : bAny became sAny * Universal : bAll became sAll - * [BACKWARDS COMPATIBILITY, INTERNAL] Hostorically, SBV focused on bit-vectors and machine + * [BACKWARDS COMPATIBILITY, INTERNAL] Historically, SBV focused on bit-vectors and machine words, which meant lots of internal types were named suggestive of this heritage. With the addition of `SInteger`, `SReal`, `SFloat`, `SDouble` we have expanded this, but still remained focused on atomic types. But, thanks largely to @@ -1860,7 +1911,7 @@ ### Version 2.9, 2013-01-02 - * Add support for the CVC4 SMT solver from Stanford: + * Add support for the CVC4 SMT solver from Stanford: NB. Z3 remains the default solver for SBV. To use CVC4, use the *With variants of the interface (i.e., proveWith, satWith, ..) by passing cvc4 as the solver argument. (Similarly, use 'yices' diff --git a/Data/SBV.hs b/Data/SBV.hs --- a/Data/SBV.hs +++ b/Data/SBV.hs @@ -108,7 +108,7 @@ -- -- * ABC from University of Berkeley: -- --- * CVC4 from Stanford: +-- * CVC4 from Stanford: -- -- * Boolector from Johannes Kepler University: -- @@ -156,7 +156,7 @@ , SFloat, SDouble -- ** Algebraic reals -- $algReals - , SReal, AlgReal, sRealToSInteger + , SReal, AlgReal, sRealToSInteger, algRealToRational -- ** Characters, Strings and Regular Expressions -- $strings , SChar, SString @@ -242,7 +242,7 @@ -- $enumerations , mkSymbolicEnumeration - -- * Uninterpreted sorts, constants, and functions + -- * Uninterpreted sorts, axioms, constants, and functions -- $uninterpreted , Uninterpreted(..), addAxiom @@ -255,6 +255,7 @@ , satWith, allSat, allSatWith, optimize, optimizeWith, isVacuous , isVacuousWith, isTheorem, isTheoremWith, isSatisfiable, isSatisfiableWith , proveWithAll, proveWithAny, satWithAll + , proveConcurrentWithAny, proveConcurrentWithAll, satConcurrentWithAny, satConcurrentWithAll , satWithAny, generateSMTBenchmark , solve -- * Constraints @@ -346,7 +347,7 @@ ) where import Data.SBV.Core.AlgReals -import Data.SBV.Core.Data hiding (addAxiom, forall, forall_, +import Data.SBV.Core.Data hiding (forall, forall_, mkForallVars, exists, exists_, mkExistVars, free, free_, mkFreeVars, output, symbolic, symbolics, mkSymVal, diff --git a/Data/SBV/Client.hs b/Data/SBV/Client.hs --- a/Data/SBV/Client.hs +++ b/Data/SBV/Client.hs @@ -33,7 +33,6 @@ import Data.SBV.Core.Data import Data.SBV.Core.Model -import Data.SBV.Control.Utils import Data.SBV.Provers.Prover -- | Check whether the given solver is installed and is ready to go. This call does a @@ -69,6 +68,5 @@ deriving instance Data $(typeCon) deriving instance SymVal $(typeCon) deriving instance HasKind $(typeCon) - deriving instance SMTValue $(typeCon) deriving instance SatModel $(typeCon) |] diff --git a/Data/SBV/Client/BaseIO.hs b/Data/SBV/Client/BaseIO.hs --- a/Data/SBV/Client/BaseIO.hs +++ b/Data/SBV/Client/BaseIO.hs @@ -765,16 +765,6 @@ svToSymSV :: SVal -> Symbolic SV svToSymSV = Trans.svToSymSV --- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere --- string, use for commenting purposes. The second argument is intended to hold the multiple-lines --- of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom --- itself, to see whether it's actually well-formed or is sensical by any means. --- A separate formalization of SMT-Lib would be very useful here. --- --- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.addAxiom' -addAxiom :: String -> [String] -> Symbolic () -addAxiom = Trans.addAxiom - -- | Run a symbolic computation, and return a extra value paired up with the 'Result' -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.runSymbolic' diff --git a/Data/SBV/Control.hs b/Data/SBV/Control.hs --- a/Data/SBV/Control.hs +++ b/Data/SBV/Control.hs @@ -30,7 +30,7 @@ -- * Querying the solver -- ** Extracting values - , SMTValue(..), getValue, registerUISMTFunction, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables + , getValue, registerUISMTFunction, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables -- ** Extracting the unsat core , getUnsatCore @@ -94,7 +94,7 @@ , freshArray, freshArray_, checkSat, ensureSat , checkSatUsing, getValue , getUninterpretedValue, timeout, io) -import Data.SBV.Control.Utils (SMTValue, registerUISMTFunction) +import Data.SBV.Control.Utils (registerUISMTFunction) import Data.SBV.Utils.ExtractIO (ExtractIO(..)) diff --git a/Data/SBV/Control/BaseIO.hs b/Data/SBV/Control/BaseIO.hs --- a/Data/SBV/Control/BaseIO.hs +++ b/Data/SBV/Control/BaseIO.hs @@ -17,7 +17,6 @@ import Data.SBV.Control.Query (Assignment) import Data.SBV.Control.Types (CheckSatResult, SMTInfoFlag, SMTInfoResponse, SMTOption, SMTReasonUnknown) -import Data.SBV.Control.Utils (SMTValue) import Data.SBV.Core.Concrete (CV) import Data.SBV.Core.Data (HasKind, Symbolic, SymArray, SymVal, SBool, SBV, SBVType) import Data.SBV.Core.Symbolic (Query, QueryContext, QueryState, State, SMTModel, SMTResult, SV) @@ -427,7 +426,7 @@ -- | Get the value of a term. -- -- NB. For a version which generalizes over the underlying monad, see 'Data.SBV.Trans.Control.getValue' -getValue :: SMTValue a => SBV a -> Query a +getValue :: SymVal a => SBV a -> Query a getValue = Trans.getValue -- | Get the value of an uninterpreted sort, as a String @@ -439,7 +438,7 @@ -- | Get the value of an uninterpreted function, as a list of domain, value pairs. -- The final value is the "else" clause, i.e., what the function maps values outside -- of the domain of the first list. -getFunction :: Trans.SMTFunction fun a r => fun -> Query ([(a, r)], r) +getFunction :: (SymVal a, SymVal r, Trans.SMTFunction fun a r) => fun -> Query ([(a, r)], r) getFunction = Trans.getFunction -- | Get the value of a term. If the kind is Real and solver supports decimal approximations, diff --git a/Data/SBV/Control/Query.hs b/Data/SBV/Control/Query.hs --- a/Data/SBV/Control/Query.hs +++ b/Data/SBV/Control/Query.hs @@ -483,33 +483,18 @@ -- | Upon a pop, we need to restore all arrays and tables. See: http://github.com/LeventErkok/sbv/issues/374 restoreTablesAndArrays :: (MonadIO m, MonadQuery m) => m () restoreTablesAndArrays = do st <- queryState - qs <- getQueryState - case queryTblArrPreserveIndex qs of - Nothing -> return () - Just (tc, ac) -> do tCount <- M.size <$> (io . readIORef) (rtblMap st) - aCount <- IM.size <$> (io . readIORef) (rArrayMap st) - - let tInits = [ "table" ++ show i ++ "_initializer" | i <- [tc .. tCount - 1]] - aInits = [ "array_" ++ show i ++ "_initializer" | i <- [ac .. aCount - 1]] - inits = tInits ++ aInits - - case inits of - [] -> return () -- Nothing to do - [x] -> send True $ "(assert " ++ x ++ ")" - xs -> send True $ "(assert (and " ++ unwords xs ++ "))" - --- | Upon a push, record the cut-off point for table and array restoration, if we haven't already -recordTablesAndArrayCutOff :: (MonadIO m, MonadQuery m) => m () -recordTablesAndArrayCutOff = do st <- queryState - qs <- getQueryState + tCount <- M.size <$> (io . readIORef) (rtblMap st) + aCount <- IM.size <$> (io . readIORef) (rArrayMap st) - case queryTblArrPreserveIndex qs of - Just _ -> return () -- already recorded, nothing to do - Nothing -> do tCount <- M.size <$> (io . readIORef) (rtblMap st) - aCount <- IM.size <$> (io . readIORef) (rArrayMap st) + let tInits = [ "table" ++ show i ++ "_initializer" | i <- [0 .. tCount - 1]] + aInits = [ "array_" ++ show i ++ "_initializer" | i <- [0 .. aCount - 1]] + inits = tInits ++ aInits - modifyQueryState $ \s -> s {queryTblArrPreserveIndex = Just (tCount, aCount)} + case inits of + [] -> return () -- Nothing to do + [x] -> send True $ "(assert " ++ x ++ ")" + xs -> send True $ "(assert (and " ++ unwords xs ++ "))" -- | Generalization of 'Data.SBV.Control.inNewAssertionStack' inNewAssertionStack :: (MonadIO m, MonadQuery m) => m a -> m a @@ -524,7 +509,6 @@ | i <= 0 = error $ "Data.SBV: push requires a strictly positive level argument, received: " ++ show i | True = do depth <- getAssertionStackDepth send True $ "(push " ++ show i ++ ")" - recordTablesAndArrayCutOff modifyQueryState $ \s -> s{queryAssertionStackDepth = depth + i} -- | Generalization of 'Data.SBV.Control.pop' @@ -575,7 +559,10 @@ -- | Generalization of 'Data.SBV.Control.resetAssertions' resetAssertions :: (MonadIO m, MonadQuery m) => m () resetAssertions = do send True "(reset-assertions)" - modifyQueryState $ \s -> s{queryAssertionStackDepth = 0} + modifyQueryState $ \s -> s{ queryAssertionStackDepth = 0 } + + -- Make sure we restore tables and arrays after resetAssertions: See: https://github.com/LeventErkok/sbv/issues/535 + restoreTablesAndArrays -- | Generalization of 'Data.SBV.Control.echo' echo :: (MonadIO m, MonadQuery m) => String -> m () diff --git a/Data/SBV/Control/Utils.hs b/Data/SBV/Control/Utils.hs --- a/Data/SBV/Control/Utils.hs +++ b/Data/SBV/Control/Utils.hs @@ -10,7 +10,6 @@ ----------------------------------------------------------------------------- {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} @@ -26,7 +25,7 @@ io , ask, send, getValue, getFunction, getUninterpretedValue , getValueCV, getUIFunCVAssoc, getUnsatAssumptions - , SMTValue(..), SMTFunction(..), registerUISMTFunction + , SMTFunction(..), registerUISMTFunction , getQueryState, modifyQueryState, getConfig, getObjectives, getUIs , getSBVAssertions, getSBVPgm, getQuantifiedInputs, getObservables , checkSat, checkSatUsing, getAllSatResult @@ -41,18 +40,13 @@ , executeQuery ) where -import Data.Maybe (isJust) import Data.List (sortBy, sortOn, elemIndex, partition, groupBy, tails, intercalate, nub, sort, isPrefixOf) import Data.Char (isPunctuation, isSpace, chr, ord, isDigit) import Data.Function (on) import Data.Proxy -import Data.Typeable (Typeable) -import Data.Int -import Data.Word - import qualified Data.Map.Strict as Map import qualified Data.IntMap.Strict as IMap import qualified Data.Sequence as S @@ -66,7 +60,7 @@ import Data.Time (getZonedTime) -import Data.SBV.Core.Data ( SV(..), trueSV, falseSV, CV(..), trueCV, falseCV, SBV, AlgReal, sbvToSV, kindOf, Kind(..) +import Data.SBV.Core.Data ( SV(..), trueSV, falseSV, CV(..), trueCV, falseCV, SBV, sbvToSV, kindOf, Kind(..) , HasKind(..), mkConstCV, CVal(..), SMTResult(..) , NamedSymVar, SMTConfig(..), SMTModel(..) , QueryState(..), SVal(..), Quantifier(..), cache @@ -93,26 +87,25 @@ import Data.SBV.SMT.Utils (showTimeoutValue, addAnnotations, alignPlain, debug, mergeSExpr, SBVException(..)) import Data.SBV.Utils.ExtractIO -import Data.SBV.Utils.Lib (qfsToString, isKString) +import Data.SBV.Utils.Lib (qfsToString) import Data.SBV.Utils.SExpr import Data.SBV.Utils.PrettyNum (cvToSMTLib) import Data.SBV.Control.Types -import qualified Data.Set as Set (empty, fromList, toAscList, map) +import qualified Data.Set as Set (empty, fromList, toAscList) import qualified Control.Exception as C import GHC.Stack -import Unsafe.Coerce (unsafeCoerce) -- Only used safely! - -- | 'Data.SBV.Trans.Control.QueryT' as a 'SolverContext'. instance MonadIO m => SolverContext (QueryT m) where constrain = addQueryConstraint False [] softConstrain = addQueryConstraint True [] namedConstraint nm = addQueryConstraint False [(":named", nm)] constrainWithAttribute = addQueryConstraint False + addAxiom = addQueryAxiom contextState = queryState setOption o @@ -133,6 +126,10 @@ where asrt | isSoft = "assert-soft" | True = "assert" +addQueryAxiom :: (MonadIO m, MonadQuery m) => String -> [String] -> m () +addQueryAxiom nm ls = do send True $ "; -- user given axiom: " ++ nm + send True $ intercalate "\n" ls + -- | Get the current configuration getConfig :: (MonadIO m, MonadQuery m) => m SMTConfig getConfig = queryConfig <$> getQueryState @@ -157,8 +154,8 @@ io = liftIO -- | Sync-up the external solver with new context we have generated -syncUpSolver :: (MonadIO m, MonadQuery m) => Bool -> IncState -> m () -syncUpSolver afterAPush is = do +syncUpSolver :: (MonadIO m, MonadQuery m) => IncState -> m () +syncUpSolver is = do cfg <- getConfig ls <- io $ do let swap (a, b) = (b, a) cmp (a, _) (b, _) = a `compare` b @@ -172,7 +169,7 @@ as <- readIORef (rNewAsgns is) constraints <- readIORef (rNewConstraints is) - return $ toIncSMTLib afterAPush cfg inps ks cnsts arrs tbls uis as constraints cfg + return $ toIncSMTLib cfg inps ks cnsts arrs tbls uis as constraints cfg mapM_ (send True) $ mergeSExpr ls -- | Retrieve the query context @@ -202,21 +199,17 @@ inNewContext :: (MonadIO m, MonadQuery m) => (State -> IO a) -> m a inNewContext act = do st <- queryState (is, r) <- io $ withNewIncState st act - mbQS <- io . readIORef . rQueryState $ st - let afterAPush = case mbQS of - Nothing -> False - Just qs -> isJust (queryTblArrPreserveIndex qs) - syncUpSolver afterAPush is + syncUpSolver is return r -- | Generic 'Queriable' instance for 'SymVal'/'SMTValue' values -instance (MonadIO m, SymVal a, SMTValue a) => Queriable m (SBV a) a where +instance (MonadIO m, SymVal a) => Queriable m (SBV a) a where create = freshVar_ project = getValue embed = return . literal -- | Generic 'Queriable' instance for things that are 'Fresh' and look like containers: -instance (MonadIO m, SymVal a, SMTValue a, Foldable t, Traversable t, Fresh m (t (SBV a))) => Queriable m (t (SBV a)) (t a) where +instance (MonadIO m, SymVal a, Foldable t, Traversable t, Fresh m (t (SBV a))) => Queriable m (t (SBV a)) (t a) where create = fresh project = mapM getValue embed = return . fmap literal @@ -338,187 +331,20 @@ loop [] --- | A class which allows for sexpr-conversion to values -class SMTValue a where - sexprToVal :: SExpr -> Maybe a - - default sexprToVal :: Read a => SExpr -> Maybe a - sexprToVal (ECon c) = case reads c of - [(v, "")] -> Just v - _ -> Nothing - sexprToVal _ = Nothing - --- | Integral values are easy to convert: -fromIntegralToVal :: Integral a => SExpr -> Maybe a -fromIntegralToVal (ENum (i, _)) = Just $ fromIntegral i -fromIntegralToVal _ = Nothing - -instance SMTValue Int8 where sexprToVal = fromIntegralToVal -instance SMTValue Int16 where sexprToVal = fromIntegralToVal -instance SMTValue Int32 where sexprToVal = fromIntegralToVal -instance SMTValue Int64 where sexprToVal = fromIntegralToVal -instance SMTValue Word8 where sexprToVal = fromIntegralToVal -instance SMTValue Word16 where sexprToVal = fromIntegralToVal -instance SMTValue Word32 where sexprToVal = fromIntegralToVal -instance SMTValue Word64 where sexprToVal = fromIntegralToVal -instance SMTValue Integer where sexprToVal = fromIntegralToVal - -instance SMTValue Float where - sexprToVal (EFloat f) = Just f - sexprToVal (ENum (v, _)) = Just (fromIntegral v) - sexprToVal _ = Nothing - -instance SMTValue Double where - sexprToVal (EDouble f) = Just f - sexprToVal (ENum (v, _)) = Just (fromIntegral v) - sexprToVal _ = Nothing - -instance SMTValue Bool where - sexprToVal (ENum (1, _)) = Just True - sexprToVal (ENum (0, _)) = Just False - sexprToVal _ = Nothing - -instance SMTValue AlgReal where - sexprToVal (EReal a) = Just a - sexprToVal (ENum (v, _)) = Just (fromIntegral v) - sexprToVal _ = Nothing - -instance SMTValue Char where - sexprToVal (ENum (i, _)) = Just (chr (fromIntegral i)) - sexprToVal _ = Nothing - -instance (SMTValue a, Typeable a) => SMTValue [a] where - -- NB. The conflation of String/[Char] forces us to have this bastard case here - -- with unsafeCoerce to cast back to a regular string. This is unfortunate, - -- and the ice is thin here. But it works, and is much better than a plethora - -- of overlapping instances. Sigh. - sexprToVal (ECon s) - | isKString @[a] undefined && length s >= 2 && head s == '"' && last s == '"' - = Just $ map unsafeCoerce s' - | True - = Just $ map (unsafeCoerce . c2w8) s' - where s' = qfsToString (tail (init s)) - c2w8 :: Char -> Word8 - c2w8 = fromIntegral . ord - - -- Otherwise we have a good old sequence, just parse it simply: - sexprToVal (EApp (ECon "seq.++" : rest)) = do elts <- mapM sexprToVal rest - return $ concat elts - sexprToVal (EApp [ECon "seq.unit", a]) = do a' <- sexprToVal a - return [a'] - sexprToVal (EApp [ECon "as", ECon "seq.empty", _]) = return [] - - sexprToVal _ = Nothing - -instance (SMTValue a, SMTValue b) => SMTValue (Either a b) where - sexprToVal (EApp [ECon "left_SBVEither", a]) = Left <$> sexprToVal a - sexprToVal (EApp [ECon "right_SBVEither", b]) = Right <$> sexprToVal b - sexprToVal (EApp [EApp [ECon "as", ECon "left_SBVEither", _], a]) = Left <$> sexprToVal a -- CVC4 puts full ascriptions - sexprToVal (EApp [EApp [ECon "as", ECon "right_SBVEither", _], b]) = Right <$> sexprToVal b -- CVC4 puts full ascriptions - sexprToVal _ = Nothing - -instance SMTValue a => SMTValue (Maybe a) where - sexprToVal (ECon "nothing_SBVMaybe") = return Nothing - sexprToVal (EApp [ECon "just_SBVMaybe", a]) = Just <$> sexprToVal a - sexprToVal ( EApp [ECon "as", ECon "nothing_SBVMaybe", _]) = return Nothing -- Ditto here for CVC4 - sexprToVal (EApp [EApp [ECon "as", ECon "just_SBVMaybe", _], a]) = Just <$> sexprToVal a - sexprToVal _ = Nothing - -instance SMTValue () where - sexprToVal (ECon "mkSBVTuple0") = Just () - sexprToVal _ = Nothing - -instance (Ord a, SymVal a) => SMTValue (RCSet a) where - sexprToVal e = recoverKindedValue k e >>= cvt . cvVal - where ke = kindOf (Proxy @a) - k = KSet ke - - cvt (CSet (RegularSet s)) = Just $ RegularSet $ Set.map (fromCV . CV ke) s - cvt (CSet (ComplementSet s)) = Just $ ComplementSet $ Set.map (fromCV . CV ke) s - cvt _ = Nothing - --- | Convert a sexpr of n-tuple to constituent sexprs. Z3 and CVC4 differ here on how they --- present tuples, so we accommodate both: -sexprToTuple :: Int -> SExpr -> [SExpr] -sexprToTuple n e = try e - where -- Z3 way - try (EApp (ECon f : args)) = case splitAt (length "mkSBVTuple") f of - ("mkSBVTuple", c) | all isDigit c && read c == n && length args == n -> args - _ -> bad - -- CVC4 way - try (EApp (EApp [ECon "as", ECon f, _] : args)) = try (EApp (ECon f : args)) - try _ = bad - bad = error $ "Data.SBV.sexprToTuple: Impossible: Expected a constructor for " ++ show n ++ " tuple, but got: " ++ show e - --- 2-tuple -instance (SMTValue a, SMTValue b) => SMTValue (a, b) where - sexprToVal s = case sexprToTuple 2 s of - [a, b] -> (,) <$> sexprToVal a <*> sexprToVal b - _ -> Nothing - --- 3-tuple -instance (SMTValue a, SMTValue b, SMTValue c) => SMTValue (a, b, c) where - sexprToVal s = case sexprToTuple 3 s of - [a, b, c] -> (,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c - _ -> Nothing - --- 4-tuple -instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d) => SMTValue (a, b, c, d) where - sexprToVal s = case sexprToTuple 4 s of - [a, b, c, d] -> (,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d - _ -> Nothing - --- 5-tuple -instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e) => SMTValue (a, b, c, d, e) where - sexprToVal s = case sexprToTuple 5 s of - [a, b, c, d, e] -> (,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e - _ -> Nothing - --- 6-tuple -instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f) => SMTValue (a, b, c, d, e, f) where - sexprToVal s = case sexprToTuple 6 s of - [a, b, c, d, e, f] -> (,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f - _ -> Nothing - --- 7-tuple -instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f, SMTValue g) => SMTValue (a, b, c, d, e, f, g) where - sexprToVal s = case sexprToTuple 7 s of - [a, b, c, d, e, f, g] -> (,,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f <*> sexprToVal g - _ -> Nothing - --- 8-tuple -instance (SMTValue a, SMTValue b, SMTValue c, SMTValue d, SMTValue e, SMTValue f, SMTValue g, SMTValue h) => SMTValue (a, b, c, d, e, f, g, h) where - sexprToVal s = case sexprToTuple 8 s of - [a, b, c, d, e, f, g, h] -> (,,,,,,,) <$> sexprToVal a <*> sexprToVal b <*> sexprToVal c <*> sexprToVal d <*> sexprToVal e <*> sexprToVal f <*> sexprToVal g <*> sexprToVal h - _ -> Nothing - -- | Generalization of 'Data.SBV.Control.getValue' -getValue :: (MonadIO m, MonadQuery m, SMTValue a) => SBV a -> m a +getValue :: (MonadIO m, MonadQuery m, SymVal a) => SBV a -> m a getValue s = do sv <- inNewContext (`sbvToSV` s) - let nm = show sv - cmd = "(get-value (" ++ nm ++ "))" - bad = unexpected "getValue" cmd "a model value" Nothing - - r <- ask cmd - - let extract v = case sexprToVal v of - Nothing -> bad r Nothing - Just c -> return c - - -- Along with regular extractions, also handle the oddball case of true/false request. These - -- can come from queries, so we have to handle it specifically here. - parse r bad $ \case EApp [EApp [ECon o, v]] | o == show sv -> extract v - EApp [EApp [ENum (i, _), v@(ENum (j, _))]] | sv `elem` [falseSV, trueSV] && i `elem` [0, 1] && i == j -> extract v - _ -> bad r Nothing + cv <- getValueCV Nothing sv + return $ fromCV cv -- | A class which allows for sexpr-conversion to functions -class (HasKind r, SatModel r, SMTValue r) => SMTFunction fun a r | fun -> a r where +class (HasKind r, SatModel r) => SMTFunction fun a r | fun -> a r where sexprToArg :: fun -> [SExpr] -> Maybe a smtFunName :: (MonadIO m, SolverContext m, MonadSymbolic m) => fun -> m String smtFunSaturate :: fun -> SBV r smtFunType :: fun -> SBVType smtFunDefault :: fun -> Maybe r - sexprToFun :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m) => fun -> SExpr -> m (Maybe ([(a, r)], r)) + sexprToFun :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m, SymVal r) => fun -> SExpr -> m (Maybe ([(a, r)], r)) {-# MINIMAL sexprToArg, smtFunSaturate, smtFunType #-} @@ -667,8 +493,8 @@ Just c -> SBV $ SVal k (Left c) -- | Functions of arity 1 -instance ( SymVal a, HasKind a, SMTValue a - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV r) a r where sexprToArg _ [a0] = sexprToVal a0 @@ -679,9 +505,9 @@ smtFunSaturate f = f $ mkArg (kindOf (Proxy @a)) -- | Functions of arity 2 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV r) (a, b) r where sexprToArg _ [a0, a1] = (,) <$> sexprToVal a0 <*> sexprToVal a1 @@ -693,10 +519,10 @@ (mkArg (kindOf (Proxy @b))) -- | Functions of arity 3 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV r) (a, b, c) r where sexprToArg _ [a0, a1, a2] = (,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 @@ -709,11 +535,11 @@ (mkArg (kindOf (Proxy @c))) -- | Functions of arity 4 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SymVal d, HasKind d, SMTValue d - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SymVal d, HasKind d + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV r) (a, b, c, d) r where sexprToArg _ [a0, a1, a2, a3] = (,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 @@ -727,12 +553,12 @@ (mkArg (kindOf (Proxy @d))) -- | Functions of arity 5 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SymVal d, HasKind d, SMTValue d - , SymVal e, HasKind e, SMTValue e - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SymVal d, HasKind d + , SymVal e, HasKind e + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV r) (a, b, c, d, e) r where sexprToArg _ [a0, a1, a2, a3, a4] = (,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 @@ -747,13 +573,13 @@ (mkArg (kindOf (Proxy @e))) -- | Functions of arity 6 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SymVal d, HasKind d, SMTValue d - , SymVal e, HasKind e, SMTValue e - , SymVal f, HasKind f, SMTValue f - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SymVal d, HasKind d + , SymVal e, HasKind e + , SymVal f, HasKind f + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV r) (a, b, c, d, e, f) r where sexprToArg _ [a0, a1, a2, a3, a4, a5] = (,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 @@ -769,14 +595,14 @@ (mkArg (kindOf (Proxy @f))) -- | Functions of arity 7 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SymVal d, HasKind d, SMTValue d - , SymVal e, HasKind e, SMTValue e - , SymVal f, HasKind f, SMTValue f - , SymVal g, HasKind g, SMTValue g - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SymVal d, HasKind d + , SymVal e, HasKind e + , SymVal f, HasKind f + , SymVal g, HasKind g + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> SBV r) (a, b, c, d, e, f, g) r where sexprToArg _ [a0, a1, a2, a3, a4, a5, a6] = (,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6 @@ -793,15 +619,15 @@ (mkArg (kindOf (Proxy @g))) -- | Functions of arity 8 -instance ( SymVal a, HasKind a, SMTValue a - , SymVal b, HasKind b, SMTValue b - , SymVal c, HasKind c, SMTValue c - , SymVal d, HasKind d, SMTValue d - , SymVal e, HasKind e, SMTValue e - , SymVal f, HasKind f, SMTValue f - , SymVal g, HasKind g, SMTValue g - , SymVal h, HasKind h, SMTValue h - , SatModel r, HasKind r, SMTValue r +instance ( SymVal a, HasKind a + , SymVal b, HasKind b + , SymVal c, HasKind c + , SymVal d, HasKind d + , SymVal e, HasKind e + , SymVal f, HasKind f + , SymVal g, HasKind g + , SymVal h, HasKind h + , SatModel r, HasKind r ) => SMTFunction (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> SBV h -> SBV r) (a, b, c, d, e, f, g, h) r where sexprToArg _ [a0, a1, a2, a3, a4, a5, a6, a7] = (,,,,,,,) <$> sexprToVal a0 <*> sexprToVal a1 <*> sexprToVal a2 <*> sexprToVal a3 <*> sexprToVal a4 <*> sexprToVal a5 <*> sexprToVal a6 <*> sexprToVal a7 @@ -819,7 +645,7 @@ (mkArg (kindOf (Proxy @h))) -- | Generalization of 'Data.SBV.Control.getFunction' -getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SMTFunction fun a r) => fun -> m ([(a, r)], r) +getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SymVal a, SymVal r, SMTFunction fun a r) => fun -> m ([(a, r)], r) getFunction f = do nm <- smtFunName f let cmd = "(get-value (" ++ nm ++ "))" @@ -912,6 +738,10 @@ uninterp (Right []) = Nothing -- I don't think this can actually happen, but just in case uninterp (Left _) = Nothing -- Out of luck, truly uninterpreted; we don't even know if it's inhabited. +-- | Go from an SExpr directly to a value +sexprToVal :: forall a. SymVal a => SExpr -> Maybe a +sexprToVal e = fromCV <$> recoverKindedValue (kindOf (Proxy @a)) e + -- | Recover a given solver-printed value with a possible interpretation recoverKindedValue :: Kind -> SExpr -> Maybe CV recoverKindedValue k e = case k of @@ -1034,7 +864,17 @@ , "While trying to parse: " ++ show te ] - args = sexprToTuple n te + -- | Convert a sexpr of n-tuple to constituent sexprs. Z3 and CVC4 differ here on how they + -- present tuples, so we accommodate both: + args = try te + where -- Z3 way + try (EApp (ECon f : as)) = case splitAt (length "mkSBVTuple") f of + ("mkSBVTuple", c) | all isDigit c && read c == n && length as == n -> as + _ -> bad + -- CVC4 way + try (EApp (EApp [ECon "as", ECon f, _] : as)) = try (EApp (ECon f : as)) + try _ = bad + bad = error $ "Data.SBV.sexprToTuple: Impossible: Expected a constructor for " ++ show n ++ " tuple, but got: " ++ show te walk _ [] sofar = reverse sofar walk i (Just el:es) sofar = walk (i+1) es (cvVal el : sofar) @@ -1309,7 +1149,7 @@ -- Add on observables if we're asked to do so: obsvs <- if grabObservables then getObservables - else do queryDebug ["*** In a quantified context, obvservables will not be printed."] + else do queryDebug ["*** In a quantified context, observables will not be printed."] return [] bindings <- let grab i@(ALL, _) = return (i, Nothing) diff --git a/Data/SBV/Core/AlgReals.hs b/Data/SBV/Core/AlgReals.hs --- a/Data/SBV/Core/AlgReals.hs +++ b/Data/SBV/Core/AlgReals.hs @@ -19,6 +19,7 @@ , mkPolyReal , algRealToSMTLib2 , algRealToHaskell + , algRealToRational , mergeAlgReals , isExactRational , algRealStructuralEqual @@ -32,6 +33,8 @@ import System.Random import Test.QuickCheck (Arbitrary(..)) +import Numeric (readSigned, readFloat) + -- | Algebraic reals. Note that the representation is left abstract. We represent -- rational results explicitly, while the roots-of-polynomials are represented -- implicitly by their defining equation @@ -187,7 +190,34 @@ -- standard Haskell type that can represent root-of-polynomial variety. algRealToHaskell :: AlgReal -> String algRealToHaskell (AlgRational True r) = "((" ++ show r ++ ") :: Rational)" -algRealToHaskell r = error $ "SBV.algRealToHaskell: Unsupported argument: " ++ show r +algRealToHaskell r = error $ unlines [ "" + , "SBV.algRealToHaskell: Unsupported argument:" + , "" + , " " ++ show r + , "" + , "represents an irrational number, and cannot be converted to a Haskell value." + ] + +-- | Convert an 'AlgReal' to a 'Rational'. If the 'AlgReal' is exact, then you get a 'Left' value. Otherwise, +-- you get a 'Right' value which is simply an approximation. +algRealToRational :: AlgReal -> Either Rational Rational +algRealToRational a = case a of + AlgRational True r -> Left r + AlgRational False r -> Left r + AlgPolyRoot _ Nothing -> bad + AlgPolyRoot _ (Just s) -> let trimmed = case reverse s of + '.':'.':'.':rest -> reverse rest + _ -> s + in case readSigned readFloat trimmed of + [(v, "")] -> Right v + _ -> bad + where bad = error $ unlines [ "" + , "SBV.algRealToRational: Unsupported argument:" + , "" + , " " ++ show a + , "" + , "represents an irrational number that cannot be approximated." + ] -- Try to show a rational precisely if we can, with finite number of -- digits. Otherwise, show it as a rational value. diff --git a/Data/SBV/Core/Data.hs b/Data/SBV/Core/Data.hs --- a/Data/SBV/Core/Data.hs +++ b/Data/SBV/Core/Data.hs @@ -21,7 +21,6 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} -{-# LANGUAGE TypeOperators #-} {-# OPTIONS_GHC -Wall -Werror #-} @@ -49,7 +48,7 @@ , SBVPgm(..), Symbolic, runSymbolic, State, getPathCondition, extendPathCondition , inSMTMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..) , SolverContext(..), internalVariable, internalConstraint, isCodeGenMode - , SBVType(..), newUninterpreted, addAxiom + , SBVType(..), newUninterpreted , Quantifier(..), needsExistentials , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension, smtLibReservedNames , SolverCapabilities(..) @@ -397,6 +396,12 @@ setOption :: SMTOption -> m () -- | Set the logic. setLogic :: Logic -> m () + -- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere + -- string, use for commenting purposes. The second argument is intended to hold the multiple-lines + -- of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom + -- itself, to see whether it's actually well-formed or is sensical by any means. + -- A separate formalization of SMT-Lib would be very useful here. + addAxiom :: String -> [String] -> m () -- | Set a solver time-out value, in milli-seconds. This function -- essentially translates to the SMTLib call @(set-info :timeout val)@, -- and your backend solver may or may not support it! The amount given @@ -406,7 +411,7 @@ -- | Get the state associated with this context contextState :: m State - {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, contextState #-} + {-# MINIMAL constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, addAxiom, contextState #-} -- time-out, logic, and info are simply options in our implementation, so default implementation suffices setTimeOut t = setOption $ OptionKeyword ":timeout" [show t] diff --git a/Data/SBV/Core/Floating.hs b/Data/SBV/Core/Floating.hs --- a/Data/SBV/Core/Floating.hs +++ b/Data/SBV/Core/Floating.hs @@ -223,14 +223,14 @@ -- >>> prove $ roundTrip @Int32 -- Falsifiable. Counter-example: -- s0 = RoundNearestTiesToEven :: RoundingMode - -- s1 = 134280664 :: Int32 + -- s1 = -264306721 :: Int32 -- -- Note how we get a failure on `Int32`. The counter-example value is not representable exactly as a single precision float: -- - -- >>> toRational (134280664 :: Float) - -- 134280672 % 1 + -- >>> toRational (-264306721 :: Float) + -- (-264306720) % 1 -- - -- Note how the numerator is different, it is off by 8. This is hardly surprising, since floats become sparser as + -- Note how the numerator is different, it is off by 1. This is hardly surprising, since floats become sparser as -- the magnitude increases to be able to cover all the integer values representable. toSFloat :: SRoundingMode -> SBV a -> SFloat @@ -263,16 +263,16 @@ -- Q.E.D. -- >>> prove $ roundTrip @Int64 -- Falsifiable. Counter-example: - -- s0 = RoundNearestTiesToEven :: RoundingMode - -- s1 = 8005056270191255168 :: Int64 + -- s0 = RoundTowardNegative :: RoundingMode + -- s1 = -8069753317450726624 :: Int64 -- -- Just like in the `SFloat` case, once we reach 64-bits, we no longer can exactly represent the -- integer value for all possible values: -- - -- >>> toRational (8005056270191255168 :: Double) - -- 8005056270191255552 % 1 + -- >>> toRational ( -8069753317450726624 :: Double) + -- (-8069753317450726400) % 1 -- - -- In this case the numerator is off by 384! + -- In this case the numerator is off by 224! toSDouble :: SRoundingMode -> SBV a -> SDouble -- default definition if we have an integral like diff --git a/Data/SBV/Core/Model.hs b/Data/SBV/Core/Model.hs --- a/Data/SBV/Core/Model.hs +++ b/Data/SBV/Core/Model.hs @@ -692,11 +692,27 @@ -- | Returns (symbolic) 'sTrue' if all the elements of the given list are different. distinct :: [a] -> SBool + -- | Returns (symbolic) `sTrue` if all the elements of the given list are different. The second + -- list contains exceptions, i.e., if an element belongs to that set, it will be considered + -- distinct regardless of repetition. + -- + -- >>> prove $ \a -> distinctExcept [a, a] [0::SInteger] .<=> a .== 0 + -- Q.E.D. + -- >>> prove $ \a b -> distinctExcept [a, b] [0::SWord8] .<=> (a .== b .=> a .== 0) + -- Q.E.D. + -- >>> prove $ \a b c d -> distinctExcept [a, b, c, d] [] .== distinct [a, b, c, (d::SInteger)] + -- Q.E.D. + distinctExcept :: [a] -> [a] -> SBool + -- | Returns (symbolic) 'sTrue' if all the elements of the given list are the same. allEqual :: [a] -> SBool -- | Symbolic membership test. sElem :: a -> [a] -> SBool + + -- | Symbolic negated membership test. + sNotElem :: a -> [a] -> SBool + {-# MINIMAL (.==) #-} x ./= y = sNot (x .== y) @@ -711,8 +727,18 @@ distinct [] = sTrue distinct (x:xs) = sAll (x ./=) xs .&& distinct xs - sElem x xs = sAny (.== x) xs + -- Default implementation of distinctExcept. Note that we override + -- this method for the base types to generate better code. + distinctExcept es ignored = go es + where isIgnored = (`sElem` ignored) + go [] = sTrue + go (x:xs) = let xOK = isIgnored x .|| sAll (\y -> isIgnored y .|| x ./= y) xs + in xOK .&& go xs + + x `sElem` xs = sAny (.== x) xs + x `sNotElem` xs = sNot (x `sElem` xs) + -- | Symbolic Comparisons. Similar to 'Eq', we cannot implement Haskell's 'Ord' class -- since there is no way to return an 'Ordering' value from a symbolic comparison. -- Furthermore, 'OrdSymbolic' requires 'Mergeable' to implement if-then-else, for the @@ -799,6 +825,40 @@ isBool (SBV (SVal KBool _)) = True isBool _ = False + -- Custom version of distinctExcept that generates better code for base types + -- We essentially keep track of an array and count cardinalities as we walk along. + distinctExcept [] _ = sTrue + distinctExcept [_] _ = sTrue + distinctExcept es ignored + | all isConc (es ++ ignored) + = distinct (filter ignoreConc es) + | True + = SBV (SVal KBool (Right (cache r))) + where ignoreConc x = case x `sElem` ignored of + SBV (SVal KBool (Left cv)) -> cvToBool cv + _ -> error $ "distinctExcept: Impossible happened, concrete sElem failed: " ++ show (es, ignored, x) + + ek = case head es of -- Head is safe here as we're guaranteed to have a non-empty es by pattern matching above. (Actually, there'll be at least two elements) + SBV (SVal k _) -> k + + r st = do let zero = 0 :: SInteger + + arr <- SArray <$> newSArr st (ek, KUnbounded) (\i -> "array_" ++ show i) (Just (unSBV zero)) + + let incr x table = ite (x `sElem` ignored) zero (1 + readArray table x) + + insert [] table = table + insert (x:xs) table = insert xs (writeArray table x (incr x table)) + + finalArray = insert es arr + + sbvToSV st $ sAll (\e -> readArray finalArray e .<= 1) es + + -- Sigh, we can't use isConcrete since that requires SymVal + -- constraint that we don't have here. (To support SBools.) + isConc (SBV (SVal _ (Left _))) = True + isConc _ = False + -- | If comparison is over something SMTLib can handle, just translate it. Otherwise desugar. instance (Ord a, SymVal a) => OrdSymbolic (SBV a) where a@(SBV x) .< b@(SBV y) | smtComparable "<" a b = SBV (svLessThan x y) @@ -2263,9 +2323,17 @@ softConstrain (SBV c) = imposeConstraint True [] c namedConstraint nm (SBV c) = imposeConstraint False [(":named", nm)] c constrainWithAttribute atts (SBV c) = imposeConstraint False atts c + addAxiom = addSymAxiom contextState = symbolicEnv setOption o = addNewSMTOption o + +-- | Add an axiom. Only used internally, use `addAxiom` from user programs which works over +-- both regular and query modes of usage. +addSymAxiom :: (SolverContext m, MonadIO m) => String -> [String] -> m () +addSymAxiom nm ax = do + st <- contextState + liftIO $ modifyState st raxioms ((nm, ax) :) (return ()) -- | Generalization of 'Data.SBV.assertWithPenalty' assertWithPenalty :: MonadSymbolic m => String -> SBool -> Penalty -> m () diff --git a/Data/SBV/Core/Sized.hs b/Data/SBV/Core/Sized.hs --- a/Data/SBV/Core/Sized.hs +++ b/Data/SBV/Core/Sized.hs @@ -45,7 +45,6 @@ import Data.SBV.Core.Operations import Data.SBV.Core.Symbolic -import Data.SBV.Control.Utils import Data.SBV.SMT.SMT -- Doctest only @@ -267,14 +266,6 @@ -- | 'SFiniteBits' instance for 'IntN' instance (KnownNat n, IsNonZero n) => SFiniteBits (IntN n) where sFiniteBitSize _ = intOfProxy (Proxy @n) - --- | Reading 'WordN' values in queries. -instance (KnownNat n, IsNonZero n) => SMTValue (WordN n) where - sexprToVal e = WordN <$> sexprToVal e - --- | Reading 'IntN' values in queries. -instance (KnownNat n, IsNonZero n) => SMTValue (IntN n) where - sexprToVal e = IntN <$> sexprToVal e -- | Constructing models for 'WordN' instance (KnownNat n, IsNonZero n) => SatModel (WordN n) where diff --git a/Data/SBV/Core/Symbolic.hs b/Data/SBV/Core/Symbolic.hs --- a/Data/SBV/Core/Symbolic.hs +++ b/Data/SBV/Core/Symbolic.hs @@ -33,7 +33,7 @@ , Op(..), PBOp(..), OvOp(..), FPOp(..), StrOp(..), SeqOp(..), SetOp(..), RegExp(..) , Quantifier(..), needsExistentials , RoundingMode(..) - , SBVType(..), svUninterpreted, newUninterpreted, addAxiom + , SBVType(..), svUninterpreted, newUninterpreted , SVal(..) , svMkSymVar, sWordN, sWordN_, sIntN, sIntN_ , ArrayContext(..), ArrayInfo @@ -577,7 +577,6 @@ , queryTerminate :: IO () , queryTimeOutValue :: Maybe Int , queryAssertionStackDepth :: Int - , queryTblArrPreserveIndex :: Maybe (Int, Int) } -- | Computations which support query operations. @@ -1391,9 +1390,9 @@ , "Only existential variables are supported in query mode." ] if isTracker - then modifyState st rinps (second ((:) (sv, nm)) *** Set.insert nm) + then modifyState st rinps (second ((sv, nm) :) *** Set.insert nm) $ noInteractive ["Adding a new tracker variable in interactive mode: " ++ show nm] - else modifyState st rinps (first ((:) (q, (sv, nm))) *** Set.insert nm) + else modifyState st rinps (first ((q, (sv, nm)) :) *** Set.insert nm) $ modifyIncState st rNewInps newInp return $ SVal k $ Right $ cache (const (return sv)) @@ -1401,16 +1400,6 @@ -- Also, the following will fail if we span the range of integers without finding a match, but your computer would -- die way ahead of that happening if that's the case! mkUnique prefix names = head $ dropWhile (`Set.member` names) (prefix : [prefix ++ "_" ++ show i | i <- [(0::Int)..]]) - --- | Generalization of 'Data.SBV.addAxiom' -addAxiom :: MonadSymbolic m => String -> [String] -> m () -addAxiom nm ax = do - st <- symbolicEnv - liftIO $ modifyState st raxioms ((nm, ax) :) - $ noInteractive [ "Adding a new axiom:" - , " Named: " ++ show nm - , " Axiom: " ++ unlines ax - ] -- | Generalization of 'Data.SBV.runSymbolic' runSymbolic :: MonadIO m => SBVRunMode -> SymbolicT m a -> m (a, Result) diff --git a/Data/SBV/Dynamic.hs b/Data/SBV/Dynamic.hs --- a/Data/SBV/Dynamic.hs +++ b/Data/SBV/Dynamic.hs @@ -81,6 +81,9 @@ , safeWith -- * Proving properties using multiple solvers , proveWithAll, proveWithAny, satWithAll, satWithAny + -- * Proving properties using multiple threads + , proveConcurrentWithAll, proveConcurrentWithAny + , satConcurrentWithAny, satConcurrentWithAll -- * Quick-check , svQuickCheck @@ -146,7 +149,10 @@ import Data.SBV.SMT.SMT (ThmResult(..), SatResult(..), SafeResult(..), OptimizeResult(..), AllSatResult(..), genParse) import Data.SBV (sbvCheckSolverInstallation, defaultSolverConfig, sbvAvailableSolvers) -import qualified Data.SBV as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny) +import qualified Data.SBV as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny + , proveConcurrentWithAll, proveConcurrentWithAny + , satConcurrentWithAny, satConcurrentWithAll + ) import qualified Data.SBV.Core.Data as SBV (SBV(..)) import qualified Data.SBV.Core.Model as SBV (sbvQuickCheck) import qualified Data.SBV.Provers.Prover as SBV (proveWith, satWith, safeWith, allSatWith, generateSMTBenchmark) @@ -194,6 +200,20 @@ proveWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, ThmResult) proveWithAny cfgs s = SBV.proveWithAny cfgs (fmap toSBool s) +-- | Prove a property with query mode using multiple threads. Each query +-- computation will spawn a thread and a unique instance of your solver to run +-- asynchronously. The 'Symbolic' 'SVal' is duplicated for each thread. This +-- function will block until all child threads return. +proveConcurrentWithAll :: SMTConfig -> Symbolic SVal -> [Query SVal] -> IO [(Solver, NominalDiffTime, ThmResult)] +proveConcurrentWithAll cfg s queries = SBV.proveConcurrentWithAll cfg queries (fmap toSBool s) + +-- | Prove a property with query mode using multiple threads. Each query +-- computation will spawn a thread and a unique instance of your solver to run +-- asynchronously. The 'Symbolic' 'SVal' is duplicated for each thread. This +-- function will return the first query computation that completes, killing the others. +proveConcurrentWithAny :: SMTConfig -> Symbolic SVal -> [Query SVal] -> IO (Solver, NominalDiffTime, ThmResult) +proveConcurrentWithAny cfg s queries = SBV.proveConcurrentWithAny cfg queries (fmap toSBool s) + -- | Find a satisfying assignment to a property with multiple solvers, -- running them in separate threads. The results will be returned in -- the order produced. @@ -205,6 +225,20 @@ -- to finish will be returned, remaining threads will be killed. satWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, SatResult) satWithAny cfgs s = SBV.satWithAny cfgs (fmap toSBool s) + +-- | Find a satisfying assignment to a property with multiple threads in query +-- mode. The 'Symbolic' 'SVal' represents what is known to all child query threads. +-- Each query thread will spawn a unique instance of the solver. Only the first +-- one to finish will be returned and the other threads will be killed. +satConcurrentWithAny :: SMTConfig -> [Query b] -> Symbolic SVal -> IO (Solver, NominalDiffTime, SatResult) +satConcurrentWithAny cfg qs s = SBV.satConcurrentWithAny cfg qs (fmap toSBool s) + +-- | Find a satisfying assignment to a property with multiple threads in query +-- mode. The 'Symbolic' 'SVal' represents what is known to all child query threads. +-- Each query thread will spawn a unique instance of the solver. This function +-- will block until all child threads have completed. +satConcurrentWithAll :: SMTConfig -> [Query b] -> Symbolic SVal -> IO [(Solver, NominalDiffTime, SatResult)] +satConcurrentWithAll cfg qs s = SBV.satConcurrentWithAll cfg qs (fmap toSBool s) -- | Extract a model, the result is a tuple where the first argument (if True) -- indicates whether the model was "probable". (i.e., if the solver returned unknown.) diff --git a/Data/SBV/Either.hs b/Data/SBV/Either.hs --- a/Data/SBV/Either.hs +++ b/Data/SBV/Either.hs @@ -13,7 +13,6 @@ {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} -{-# LANGUAGE TypeOperators #-} {-# OPTIONS_GHC -Wall -Werror #-} diff --git a/Data/SBV/List.hs b/Data/SBV/List.hs --- a/Data/SBV/List.hs +++ b/Data/SBV/List.hs @@ -130,7 +130,7 @@ -- Q.E.D. -- >>> sat $ \(l :: SList Word16) -> length l .>= 2 .&& listToListAt l 0 ./= listToListAt l (length l - 1) -- Satisfiable. Model: --- s0 = [0,0,256] :: [Word16] +-- s0 = [0,0,8] :: [Word16] listToListAt :: SymVal a => SList a -> SInteger -> SList a listToListAt s offset = subList s offset 1 @@ -139,7 +139,8 @@ -- -- >>> prove $ \i -> i `inRange` (0, 4) .=> [1,1,1,1,1] `elemAt` i .== (1::SInteger) -- Q.E.D. --- >>> prove $ \(l :: SList Integer) i e -> i `inRange` (0, length l - 1) .&& l `elemAt` i .== e .=> indexOf l (singleton e) .<= i +-- +-- ->>> prove $ \(l :: SList Integer) i e -> i `inRange` (0, length l - 1) .&& l `elemAt` i .== e .=> indexOf l (singleton e) .<= i -- Q.E.D. elemAt :: forall a. SymVal a => SList a -> SInteger -> SBV a elemAt l i @@ -315,8 +316,9 @@ -- | @`indexOf` l sub@. Retrieves first position of @sub@ in @l@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` l sub 0@. -- --- >>> prove $ \(l :: SList Int8) i -> i .> 0 .&& i .< length l .=> indexOf l (subList l i 1) .<= i +-- ->>> prove $ \(l :: SList Int8) i -> i .> 0 .&& i .< length l .=> indexOf l (subList l i 1) .<= i -- Q.E.D. +-- -- >>> prove $ \(l1 :: SList Word16) l2 -> length l2 .> length l1 .=> indexOf l1 l2 .== -1 -- Q.E.D. indexOf :: (Eq a, SymVal a) => SList a -> SList a -> SInteger diff --git a/Data/SBV/Maybe.hs b/Data/SBV/Maybe.hs --- a/Data/SBV/Maybe.hs +++ b/Data/SBV/Maybe.hs @@ -13,7 +13,6 @@ {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} -{-# LANGUAGE TypeOperators #-} {-# OPTIONS_GHC -Wall -Werror #-} diff --git a/Data/SBV/Provers/CVC4.hs b/Data/SBV/Provers/CVC4.hs --- a/Data/SBV/Provers/CVC4.hs +++ b/Data/SBV/Provers/CVC4.hs @@ -28,7 +28,7 @@ name = CVC4 , executable = "cvc4" , preprocess = clean - , options = const ["--lang", "smt", "--incremental", "--interactive", "--no-interactive-prompt"] + , options = const ["--lang", "smt", "--incremental", "--interactive", "--no-interactive-prompt", "--model-witness-value"] , engine = standardEngine "SBV_CVC4" "SBV_CVC4_OPTIONS" , capabilities = SolverCapabilities { supportsQuantifiers = True diff --git a/Data/SBV/Provers/MathSAT.hs b/Data/SBV/Provers/MathSAT.hs --- a/Data/SBV/Provers/MathSAT.hs +++ b/Data/SBV/Provers/MathSAT.hs @@ -41,7 +41,7 @@ , supportsOptimization = False , supportsPseudoBooleans = False , supportsCustomQueries = True - , supportsGlobalDecls = False + , supportsGlobalDecls = True , supportsDataTypes = True , supportsFlattenedModels = Nothing } diff --git a/Data/SBV/Provers/Prover.hs b/Data/SBV/Provers/Prover.hs --- a/Data/SBV/Provers/Prover.hs +++ b/Data/SBV/Provers/Prover.hs @@ -23,6 +23,7 @@ module Data.SBV.Provers.Prover ( SMTSolver(..), SMTConfig(..), Predicate , MProvable(..), Provable, proveWithAll, proveWithAny , satWithAll, satWithAny + , satConcurrentWithAny, satConcurrentWithAll, proveConcurrentWithAny, proveConcurrentWithAll , generateSMTBenchmark , Goal , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..) @@ -38,8 +39,9 @@ import Control.Monad.IO.Class (MonadIO, liftIO) import Control.DeepSeq (rnf, NFData(..)) -import Control.Concurrent.Async (async, waitAny, asyncThreadId, Async) -import Control.Exception (finally, throwTo, AsyncException(ThreadKilled)) +import Control.Concurrent.Async (async, waitAny, asyncThreadId, Async, mapConcurrently) +import Control.Exception (finally, throwTo) +import System.Exit (ExitCode(ExitSuccess)) import System.IO.Unsafe (unsafeInterleaveIO) -- only used safely! @@ -505,7 +507,7 @@ -- | Prove a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed. --- Note that we send a @ThreadKilled@ to the losing processes, but we do *not* actually wait for them +-- Note that we send an exception to the losing processes, but we do *not* actually wait for them -- to finish. In rare cases this can lead to zombie processes. In previous experiments, we found -- that some processes take their time to terminate. So, this solution favors quick turnaround. proveWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, NominalDiffTime, ThmResult) @@ -518,12 +520,46 @@ -- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed. --- Note that we send a @ThreadKilled@ to the losing processes, but we do *not* actually wait for them +-- Note that we send an exception to the losing processes, but we do *not* actually wait for them -- to finish. In rare cases this can lead to zombie processes. In previous experiments, we found -- that some processes take their time to terminate. So, this solution favors quick turnaround. satWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, NominalDiffTime, SatResult) -satWithAny = (`sbvWithAny` satWith) +satWithAny = (`sbvWithAny` satWith) +-- | Find a satisfying assignment to a property using a single solver, but +-- providing several query problems of interest, with each query running in a +-- separate thread and return the first one that returns. This can be useful to +-- use symbolic mode to drive to a location in the search space of the solver +-- and then refine the problem in query mode. If the computation is very hard to +-- solve for the solver than running in concurrent mode may provide a large +-- performance benefit. +satConcurrentWithAny :: Provable a => SMTConfig -> [Query b] -> a -> IO (Solver, NominalDiffTime, SatResult) +satConcurrentWithAny solver qs a = do (slvr,time,result) <- sbvConcurrentWithAny solver go qs a + return (slvr, time, SatResult result) + where go cfg a' q = runWithQuery True (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a' + +-- | Prove a property by running many queries each isolated to their own thread +-- concurrently and return the first that finishes, killing the others +proveConcurrentWithAny :: Provable a => SMTConfig -> [Query b] -> a -> IO (Solver, NominalDiffTime, ThmResult) +proveConcurrentWithAny solver qs a = do (slvr,time,result) <- sbvConcurrentWithAny solver go qs a + return (slvr, time, ThmResult result) + where go cfg a' q = runWithQuery False (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a' + +-- | Find a satisfying assignment to a property using a single solver, but run +-- each query problem in a separate isolated thread and wait for each thread to +-- finish. See 'satConcurrentWithAny' for more details. +satConcurrentWithAll :: Provable a => SMTConfig -> [Query b] -> a -> IO [(Solver, NominalDiffTime, SatResult)] +satConcurrentWithAll solver qs a = do results <- sbvConcurrentWithAll solver go qs a + return $ (\(a',b,c) -> (a',b,SatResult c)) <$> results + where go cfg a' q = runWithQuery True (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a' + +-- | Prove a property by running many queries each isolated to their own thread +-- concurrently and wait for each to finish returning all results +proveConcurrentWithAll :: Provable a => SMTConfig -> [Query b] -> a -> IO [(Solver, NominalDiffTime, ThmResult)] +proveConcurrentWithAll solver qs a = do results <- sbvConcurrentWithAll solver go qs a + return $ (\(a',b,c) -> (a',b,ThmResult c)) <$> results + where go cfg a' q = runWithQuery False (do _ <- q; checkNoOptimizations >> Control.getSMTResult) cfg a' + -- | Create an SMT-Lib2 benchmark. The 'Bool' argument controls whether this is a SAT instance, i.e., -- translate the query directly, or a PROVE instance, i.e., translate the negated query. generateSMTBenchmark :: (MonadIO m, MProvable m a) => Bool -> a -> m String @@ -701,7 +737,33 @@ where -- Async's `waitAnyCancel` nicely blocks; so we use this variant to ignore the -- wait part for killed threads. waitAnyFastCancel asyncs = waitAny asyncs `finally` mapM_ cancelFast asyncs - cancelFast other = throwTo (asyncThreadId other) ThreadKilled + cancelFast other = throwTo (asyncThreadId other) ExitSuccess + + +sbvConcurrentWithAny :: NFData c => SMTConfig -> (SMTConfig -> a -> QueryT m b -> IO c) -> [QueryT m b] -> a -> IO (Solver, NominalDiffTime, c) +sbvConcurrentWithAny solver what queries a = snd `fmap` (mapM runQueryInThread queries >>= waitAnyFastCancel) + where -- Async's `waitAnyCancel` nicely blocks; so we use this variant to ignore the + -- wait part for killed threads. + waitAnyFastCancel asyncs = waitAny asyncs `finally` mapM_ cancelFast asyncs + cancelFast other = throwTo (asyncThreadId other) ExitSuccess + runQueryInThread q = do beginTime <- getCurrentTime + runInThread beginTime (\cfg -> what cfg a q) solver + + +sbvConcurrentWithAll :: NFData c => SMTConfig -> (SMTConfig -> a -> QueryT m b -> IO c) -> [QueryT m b] -> a -> IO [(Solver, NominalDiffTime, c)] +sbvConcurrentWithAll solver what queries a = mapConcurrently runQueryInThread queries >>= unsafeInterleaveIO . go + where runQueryInThread q = do beginTime <- getCurrentTime + runInThread beginTime (\cfg -> what cfg a q) solver + + go [] = return [] + go as = do (d, r) <- waitAny as + -- The following filter works because the Eq instance on Async + -- checks the thread-id; so we know that we're removing the + -- correct solver from the list. This also allows for + -- running the same-solver (with different options), since + -- they will get different thread-ids. + rs <- unsafeInterleaveIO $ go (filter (/= d) as) + return (r : rs) -- | Perform action for all given configs, return all the results. sbvWithAll :: NFData b => [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO [(Solver, NominalDiffTime, b)] diff --git a/Data/SBV/SMT/SMT.hs b/Data/SBV/SMT/SMT.hs --- a/Data/SBV/SMT/SMT.hs +++ b/Data/SBV/SMT/SMT.hs @@ -45,7 +45,7 @@ import Data.Char (isSpace) import Data.Maybe (fromMaybe, isJust) import Data.Int (Int8, Int16, Int32, Int64) -import Data.List (intercalate, isPrefixOf, transpose) +import Data.List (intercalate, isPrefixOf, transpose, isInfixOf) import Data.Word (Word8, Word16, Word32, Word64) import Data.IORef (readIORef, writeIORef) @@ -711,7 +711,15 @@ , sbvExceptionExitCode = Nothing , sbvExceptionConfig = cfg { solver = (solver cfg) { executable = execPath } } , sbvExceptionReason = Nothing - , sbvExceptionHint = Nothing + , sbvExceptionHint = if "hGetLine: end of file" `isInfixOf` e + then Just [ "Solver process prematurely ended communication." + , "" + , "It is likely it was terminated because of a seg-fault." + , "Run with 'transcript=Just \"bad.smt2\"' option, and feed" + , "the generated \"bad.smt2\" file directly to the solver" + , "outside of SBV for further information." + ] + else Nothing } SolverTimeout e -> do terminateProcess pid -- NB. Do not *wait* for the process, just quit. @@ -872,7 +880,6 @@ , queryTerminate = cleanUp , queryTimeOutValue = Nothing , queryAssertionStackDepth = 0 - , queryTblArrPreserveIndex = Nothing } qsp = rQueryState ctx diff --git a/Data/SBV/SMT/SMTLib.hs b/Data/SBV/SMT/SMTLib.hs --- a/Data/SBV/SMT/SMTLib.hs +++ b/Data/SBV/SMT/SMTLib.hs @@ -32,9 +32,9 @@ SMTLib2 -> toSMTLib2 -- | Convert to SMT-Lib, in an incremental query context. -toIncSMTLib :: Bool -> SMTConfig -> SMTLibIncConverter [String] -toIncSMTLib afterAPush SMTConfig{smtLibVersion} = case smtLibVersion of - SMTLib2 -> toIncSMTLib2 afterAPush +toIncSMTLib :: SMTConfig -> SMTLibIncConverter [String] +toIncSMTLib SMTConfig{smtLibVersion} = case smtLibVersion of + SMTLib2 -> toIncSMTLib2 -- | Convert to SMTLib-2 format toSMTLib2 :: SMTLibConverter SMTLibPgm @@ -69,6 +69,6 @@ where quantifiers = map fst (fst qinps) -- | Convert to SMTLib-2 format -toIncSMTLib2 :: Bool -> SMTLibIncConverter [String] +toIncSMTLib2 :: SMTLibIncConverter [String] toIncSMTLib2 = cvt SMTLib2 where cvt SMTLib2 = SMT2.cvtInc diff --git a/Data/SBV/SMT/SMTLib2.hs b/Data/SBV/SMT/SMTLib2.hs --- a/Data/SBV/SMT/SMTLib2.hs +++ b/Data/SBV/SMT/SMTLib2.hs @@ -166,7 +166,7 @@ ++ [ "; --- optimization tracker variables ---" | not (null trackerVars) ] ++ [ "(declare-fun " ++ show s ++ " " ++ svFunType [] s ++ ") ; tracks " ++ nm | (s, nm) <- trackerVars] ++ [ "; --- constant tables ---" ] - ++ concatMap (constTable False) constTables + ++ concatMap constTable constTables ++ [ "; --- skolemized tables ---" ] ++ map (skolemTable (unwords (map svType foralls))) skolemTables ++ [ "; --- arrays ---" ] @@ -212,7 +212,7 @@ (constTables, skolemTables) = ([(t, d) | (t, Left d) <- allTables], [(t, d) | (t, Right d) <- allTables]) allTables = [(t, genTableData rm skolemMap (not (null foralls), forallArgs) (map fst consts) t) | t <- tbls] - (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg False (not (null foralls)) consts skolemMap) arrs + (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg (not (null foralls)) consts skolemMap) arrs delayedEqualities = concatMap snd skolemTables delayedAsserts [] = [] @@ -384,8 +384,8 @@ -- to do as an extra in the incremental context. See `Data.SBV.Core.Symbolic.registerKind` -- for a list of what we include, in case something doesn't show up -- and you need it! -cvtInc :: Bool -> SMTLibIncConverter [String] -cvtInc afterAPush inps newKs consts arrs tbls uis (SBVPgm asgnsSeq) cstrs cfg = +cvtInc :: SMTLibIncConverter [String] +cvtInc inps newKs consts arrs tbls uis (SBVPgm asgnsSeq) cstrs cfg = -- any new settings? settings -- sorts @@ -404,7 +404,7 @@ -- uninterpreteds ++ concatMap declUI uis -- tables - ++ concatMap (constTable afterAPush) allTables + ++ concatMap constTable allTables -- expressions ++ map (declDef cfg skolemMap tableMap) (F.toList asgnsSeq) -- delayed equalities @@ -423,7 +423,7 @@ declInp (s, _) = "(declare-fun " ++ show s ++ " () " ++ svType s ++ ")" - (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg afterAPush False consts skolemMap) arrs + (arrayConstants, arrayDelayeds, arraySetups) = unzip3 $ map (declArray cfg False consts skolemMap) arrs allTables = [(t, either id id (genTableData rm skolemMap (False, []) (map fst consts) t)) | t <- tbls] tableMap = IM.fromList $ map mkTable allTables @@ -465,20 +465,20 @@ declAx :: (String, [String]) -> String declAx (nm, ls) = (";; -- user given axiom: " ++ nm ++ "\n") ++ intercalate "\n" ls -constTable :: Bool -> (((Int, Kind, Kind), [SV]), [String]) -> [String] -constTable afterAPush (((i, ak, rk), _elts), is) = decl : zipWith wrap [(0::Int)..] is ++ setup +constTable :: (((Int, Kind, Kind), [SV]), [String]) -> [String] +constTable (((i, ak, rk), _elts), is) = decl : zipWith wrap [(0::Int)..] is ++ setup where t = "table" ++ show i decl = "(declare-fun " ++ t ++ " (" ++ smtType ak ++ ") " ++ smtType rk ++ ")" -- Arrange for initializers mkInit idx = "table" ++ show i ++ "_initializer_" ++ show (idx :: Int) initializer = "table" ++ show i ++ "_initializer" - wrap index s - | afterAPush = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")" - | True = "(assert " ++ s ++ ")" - lis = length is + + wrap index s = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")" + + lis = length is + setup - | not afterAPush = [] | lis == 0 = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed" ] | lis == 1 = [ "(define-fun " ++ initializer ++ " () Bool " ++ mkInit 0 ++ ")" @@ -488,7 +488,6 @@ , "(assert " ++ initializer ++ ")" ] - skolemTable :: String -> (((Int, Kind, Kind), [SV]), [String]) -> String skolemTable qsIn (((i, ak, rk), _elts), _) = decl where qs = if null qsIn then "" else qsIn ++ " " @@ -517,8 +516,8 @@ -- we might have to skolemize those. Implement this properly. -- The difficulty is with the Mutate/Merge: We have to postpone an init if -- the components are themselves postponed, so this cannot be implemented as a simple map. -declArray :: SMTConfig -> Bool -> Bool -> [(SV, CV)] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String], [String]) -declArray cfg afterAPush quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : zipWith wrap [(0::Int)..] (map snd pre), zipWith wrap [lpre..] (map snd post), setup) +declArray :: SMTConfig -> Bool -> [(SV, CV)] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String], [String]) +declArray cfg quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : zipWith wrap [(0::Int)..] (map snd pre), zipWith wrap [lpre..] (map snd post), setup) where constNames = map fst consts topLevel = not quantified || case ctx of ArrayFree mbi -> maybe True (`elem` constNames) mbi @@ -554,17 +553,13 @@ mkInit idx = "array_" ++ show i ++ "_initializer_" ++ show (idx :: Int) initializer = "array_" ++ show i ++ "_initializer" - wrap index s - | afterAPush = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")" - | True = "(assert " ++ s ++ ")" + wrap index s = "(define-fun " ++ mkInit index ++ " () Bool " ++ s ++ ")" lpre = length pre lAll = lpre + length post setup - | not afterAPush = [] - | lAll == 0 = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed" - ] + | lAll == 0 = [ "(define-fun " ++ initializer ++ " () Bool true) ; no initializiation needed" | not quantified] | lAll == 1 = [ "(define-fun " ++ initializer ++ " () Bool " ++ mkInit 0 ++ ")" , "(assert " ++ initializer ++ ")" ] diff --git a/Data/SBV/Set.hs b/Data/SBV/Set.hs --- a/Data/SBV/Set.hs +++ b/Data/SBV/Set.hs @@ -308,13 +308,13 @@ -- >>> sat $ \i -> hasSize (full :: SSet Integer) i -- Unsatisfiable -- --- >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j +-- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `union` b) k .=> k .>= i `smax` j -- Q.E.D. -- --- >>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j +-- ->>> prove $ \a b i j k -> hasSize (a :: SSet Integer) i .&& hasSize (b :: SSet Integer) j .&& hasSize (a `intersection` b) k .=> k .<= i `smin` j -- Q.E.D. -- --- >>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0 +-- ->>> prove $ \a k -> hasSize (a :: SSet Integer) k .=> k .>= 0 -- Q.E.D. hasSize :: (Ord a, SymVal a) => SSet a -> SInteger -> SBool hasSize sa si diff --git a/Data/SBV/String.hs b/Data/SBV/String.hs --- a/Data/SBV/String.hs +++ b/Data/SBV/String.hs @@ -133,7 +133,7 @@ -- Q.E.D. -- >>> sat $ \s -> length s .>= 2 .&& strToStrAt s 0 ./= strToStrAt s (length s - 1) -- Satisfiable. Model: --- s0 = "\NUL\NUL\DLE" :: String +-- s0 = "\NUL\NUL\EOT" :: String strToStrAt :: SString -> SInteger -> SString strToStrAt s offset = subStr s offset 1 @@ -142,7 +142,8 @@ -- -- >>> prove $ \i -> i .>= 0 .&& i .<= 4 .=> "AAAAA" `strToCharAt` i .== literal 'A' -- Q.E.D. --- >>> prove $ \s i c -> i `inRange` (0, length s - 1) .&& s `strToCharAt` i .== c .=> indexOf s (singleton c) .<= i +-- +-- ->>> prove $ \s i c -> i `inRange` (0, length s - 1) .&& s `strToCharAt` i .== c .=> indexOf s (singleton c) .<= i -- Q.E.D. strToCharAt :: SString -> SInteger -> SChar strToCharAt s i @@ -310,8 +311,9 @@ -- | @`indexOf` s sub@. Retrieves first position of @sub@ in @s@, @-1@ if there are no occurrences. -- Equivalent to @`offsetIndexOf` s sub 0@. -- --- >>> prove $ \s i -> i .> 0 .&& i .< length s .=> indexOf s (subStr s i 1) .<= i +-- ->>> prove $ \s i -> i .> 0 .&& i .< length s .=> indexOf s (subStr s i 1) .<= i -- Q.E.D. +-- -- >>> prove $ \s1 s2 -> length s2 .> length s1 .=> indexOf s1 s2 .== -1 -- Q.E.D. indexOf :: SString -> SString -> SInteger @@ -341,7 +343,6 @@ -- | @`strToNat` s@. Retrieve integer encoded by string @s@ (ground rewriting only). -- Note that by definition this function only works when @s@ only contains digits, -- that is, if it encodes a natural number. Otherwise, it returns '-1'. --- See for details. -- -- >>> prove $ \s -> let n = strToNat s in length s .== 1 .=> (-1) .<= n .&& n .<= 9 -- Q.E.D. @@ -357,7 +358,6 @@ -- | @`natToStr` i@. Retrieve string encoded by integer @i@ (ground rewriting only). -- Again, only naturals are supported, any input that is not a natural number -- produces empty string, even though we take an integer as an argument. --- See for details. -- -- >>> prove $ \i -> length (natToStr i) .== 3 .=> i .<= 999 -- Q.E.D. diff --git a/Data/SBV/Tools/BoundedList.hs b/Data/SBV/Tools/BoundedList.hs --- a/Data/SBV/Tools/BoundedList.hs +++ b/Data/SBV/Tools/BoundedList.hs @@ -145,3 +145,6 @@ -- | Bounded insertion sort bsort :: (Ord a, SymVal a) => Int -> SList a -> SList a bsort cnt = bfoldr cnt (binsert cnt) [] + +-- Hlint is thinking "OverloadedLists" is wrong, but GHC wants it. +{-# ANN module ("HLint: ignore Unused LANGUAGE pragma" :: String) #-} diff --git a/Data/SBV/Tools/Polynomial.hs b/Data/SBV/Tools/Polynomial.hs --- a/Data/SBV/Tools/Polynomial.hs +++ b/Data/SBV/Tools/Polynomial.hs @@ -14,7 +14,6 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE TypeFamilies #-} -{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wall -Werror #-} diff --git a/Data/SBV/Tools/Range.hs b/Data/SBV/Tools/Range.hs --- a/Data/SBV/Tools/Range.hs +++ b/Data/SBV/Tools/Range.hs @@ -87,11 +87,13 @@ -- [(0.0,oo)] -- >>> ranges $ \x -> x .< (0::SReal) -- [(-oo,0.0)] -ranges :: forall a. (Ord a, Num a, SymVal a, SMTValue a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => (SBV a -> SBool) -> IO [Range a] +-- >>> ranges $ \(x :: SWord8) -> 2*x .== 4 +-- [[2,3),(129,130]] +ranges :: forall a. (Ord a, Num a, SymVal a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => (SBV a -> SBool) -> IO [Range a] ranges = rangesWith defaultSMTCfg -- | Compute ranges, using the given solver configuration. -rangesWith :: forall a. (Ord a, Num a, SymVal a, SMTValue a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => SMTConfig -> (SBV a -> SBool) -> IO [Range a] +rangesWith :: forall a. (Ord a, Num a, SymVal a, SatModel a, Metric a, SymVal (MetricSpace a), SatModel (MetricSpace a)) => SMTConfig -> (SBV a -> SBool) -> IO [Range a] rangesWith cfg prop = do mbBounds <- getInitialBounds case mbBounds of Nothing -> return [] @@ -135,45 +137,68 @@ Just r -> r _ -> error $ "Data.SBV.ranges.getRegVal: Cannot parse " ++ show cv - IndependentResult m <- optimizeWith cfg Independent $ do x <- free_ - constrain $ prop x - minimize "min" x - maximize "max" x - case head (map snd m) of - Unsatisfiable{} -> return Nothing - Unknown{} -> error "Solver said Unknown!" - ProofError{} -> error (show (IndependentResult m)) - _ -> let Just (Just mi) = getModelObjectiveValue "min" `fmap` ("min" `lookup` m) - Just (Just ma) = getModelObjectiveValue "max" `fmap` ("max" `lookup` m) - in return $ Just $ Range (getGenVal mi) (getGenVal ma) + getBound cstr = do let objName = "boundValue" + res@(LexicographicResult m) <- optimizeWith cfg Lexicographic $ do x <- free_ + constrain $ prop x + cstr objName x + case m of + Unsatisfiable{} -> return Nothing + Unknown{} -> error "Solver said Unknown!" + ProofError{} -> error (show res) + _ -> return $ getModelObjectiveValue objName m - bisect :: Range a -> IO (Maybe [Range a]) - bisect (Range lo hi) = runSMTWith cfg $ do - x <- free_ + mi <- getBound minimize + ma <- getBound maximize + case (mi, ma) of + (Just minV, Just maxV) -> return $ Just $ Range (getGenVal minV) (getGenVal maxV) + _ -> return Nothing - let restrict v open closed = case v of - Unbounded -> sTrue - Open a -> x `open` literal a - Closed a -> x `closed` literal a + -- Is this range satisfiable? Returns a witness to it. + witness :: Range a -> Symbolic (SBV a) + witness (Range lo hi) = do x :: SBV a <- free_ - lower = restrict lo (.>) (.>=) - upper = restrict hi (.<) (.<=) + let restrict v open closed = case v of + Unbounded -> sTrue + Open a -> x `open` literal a + Closed a -> x `closed` literal a - constrain $ lower .&& upper .&& sNot (prop x) + lower = restrict lo (.>) (.>=) + upper = restrict hi (.<) (.<=) - query $ do cs <- checkSat - case cs of - Unsat -> return Nothing - Unk -> error "Data.SBV.interval.bisect: Solver said unknown!" - Sat -> do midV <- Open <$> getValue x - return $ Just [Range lo midV, Range midV hi] + constrain $ lower .&& upper + return x + + isFeasible :: Range a -> IO Bool + isFeasible r = runSMTWith cfg $ do _ <- witness r + + query $ do cs <- checkSat + case cs of + Unsat -> return False + Unk -> error "Data.SBV.interval.isFeasible: Solver said unknown!" + Sat -> return True + + bisect :: Range a -> IO (Maybe [Range a]) + bisect r@(Range lo hi) = runSMTWith cfg $ do x <- witness r + + constrain $ sNot (prop x) + + query $ do cs <- checkSat + case cs of + Unsat -> return Nothing + Unk -> error "Data.SBV.interval.bisect: Solver said unknown!" + Sat -> do midV <- Open <$> getValue x + return $ Just [Range lo midV, Range midV hi] + search :: [Range a] -> [Range a] -> IO [Range a] search [] sofar = return $ reverse sofar - search (c:cs) sofar = do mbCS <- bisect c - case mbCS of - Nothing -> search cs (c:sofar) - Just xss -> search (xss ++ cs) sofar + search (c:cs) sofar = do feasible <- isFeasible c + if feasible + then do mbCS <- bisect c + case mbCS of + Nothing -> search cs (c:sofar) + Just xss -> search (xss ++ cs) sofar + else search cs sofar {-# ANN rangesWith ("HLint: ignore Replace case with fromMaybe" :: String) #-} diff --git a/Data/SBV/Trans.hs b/Data/SBV/Trans.hs --- a/Data/SBV/Trans.hs +++ b/Data/SBV/Trans.hs @@ -80,11 +80,12 @@ -- * Enumerations , mkSymbolicEnumeration - -- * Uninterpreted sorts, constants, and functions + -- * Uninterpreted sorts, axioms, constants, and functions , Uninterpreted(..), addAxiom -- * Properties, proofs, and satisfiability , Predicate, Goal, MProvable(..), Provable, proveWithAll, proveWithAny , satWithAll + , proveConcurrentWithAny, proveConcurrentWithAll, satConcurrentWithAny, satConcurrentWithAll , satWithAny, generateSMTBenchmark , solve -- * Constraints diff --git a/Data/SBV/Trans/Control.hs b/Data/SBV/Trans/Control.hs --- a/Data/SBV/Trans/Control.hs +++ b/Data/SBV/Trans/Control.hs @@ -28,7 +28,7 @@ -- * Querying the solver -- ** Extracting values - , SMTValue(..), getValue, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables + , getValue, getFunction, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason, getObservables -- ** Extracting the unsat core , getUnsatCore @@ -77,7 +77,7 @@ import Data.SBV.Core.Symbolic (MonadQuery(..), QueryT, Query, SymbolicT, QueryContext(..)) import Data.SBV.Control.Query -import Data.SBV.Control.Utils (SMTValue(..), queryDebug, executeQuery, getFunction) +import Data.SBV.Control.Utils (queryDebug, executeQuery, getFunction) import Data.SBV.Utils.ExtractIO diff --git a/Data/SBV/Utils/SExpr.hs b/Data/SBV/Utils/SExpr.hs --- a/Data/SBV/Utils/SExpr.hs +++ b/Data/SBV/Utils/SExpr.hs @@ -147,6 +147,7 @@ cvt (EApp [ECon "/", ENum a, ENum b]) = return $ EReal (fromInteger (fst a) / fromInteger (fst b)) cvt (EApp [ECon "-", EReal a]) = return $ EReal (-a) cvt (EApp [ECon "-", ENum a]) = return $ ENum (-(fst a), snd a) + -- bit-vector value as CVC4 prints: (_ bv0 16) for instance cvt (EApp [ECon "_", ENum a, ENum _b]) = return $ ENum a cvt (EApp [ECon "root-obj", EApp (ECon "+":trms), ENum k]) = do ts <- mapM getCoeff trms @@ -155,6 +156,18 @@ cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum ( 8, _), ENum (24, _)]]) = getFloat n cvt (EApp [ECon "as", n, ECon "Float64"]) = getDouble n cvt (EApp [ECon "as", n, ECon "Float32"]) = getFloat n + + -- Deal with CVC4's approximate reals + cvt x@(EApp [ECon "witness", EApp [EApp [ECon v, ECon "Real"]] + , EApp [ECon "or", EApp [ECon "=", ECon v', val], _]]) | v == v' = do + approx <- cvt val + case approx of + ENum (s, _) -> return $ EReal $ mkPolyReal (Left (False, show s)) + EReal aval -> case aval of + AlgRational _ r -> return $ EReal $ AlgRational False r + _ -> return $ EReal aval + _ -> die $ "Cannot parse a CVC4 approximate value from: " ++ show x + -- NB. Note the lengths on the mantissa for the following two are 23/52; not 24/53! cvt (EApp [ECon "fp", ENum (s, Just 1), ENum ( e, Just 8), ENum (m, Just 23)]) = return $ EFloat $ getTripleFloat s e m cvt (EApp [ECon "fp", ENum (s, Just 1), ENum ( e, Just 11), ENum (m, Just 52)]) = return $ EDouble $ getTripleDouble s e m diff --git a/Documentation/SBV/Examples/Existentials/Diophantine.hs b/Documentation/SBV/Examples/Existentials/Diophantine.hs --- a/Documentation/SBV/Examples/Existentials/Diophantine.hs +++ b/Documentation/SBV/Examples/Existentials/Diophantine.hs @@ -74,15 +74,15 @@ -- We have: -- -- >>> test --- NonHomogeneous [[1,0,0],[0,2,0]] [[0,1,1],[1,0,2]] +-- NonHomogeneous [[0,2,0],[1,0,0]] [[0,1,1],[1,0,2]] -- -- which means that the solutions are of the form: -- --- @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@ +-- @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@ -- -- OR -- --- @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@ +-- @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@ -- -- for arbitrary @k@, @k'@. It's easy to see that these are really solutions -- to the equation given. It's harder to see that they cover all possibilities, diff --git a/Documentation/SBV/Examples/Lists/BoundedMutex.hs b/Documentation/SBV/Examples/Lists/BoundedMutex.hs --- a/Documentation/SBV/Examples/Lists/BoundedMutex.hs +++ b/Documentation/SBV/Examples/Lists/BoundedMutex.hs @@ -98,8 +98,7 @@ -- so long as both the agents and the arbiter act according to the rules. The check is bounded up-to-the -- given concrete bound; so this is an example of a bounded-model-checking style proof. We have: -- --- Test turned off. See: https://github.com/Z3Prover/z3/issues/2956 --- checkMutex 20 +-- >>> checkMutex 20 -- All is good! checkMutex :: Int -> IO () checkMutex b = runSMT $ do diff --git a/Documentation/SBV/Examples/Lists/Fibonacci.hs b/Documentation/SBV/Examples/Lists/Fibonacci.hs --- a/Documentation/SBV/Examples/Lists/Fibonacci.hs +++ b/Documentation/SBV/Examples/Lists/Fibonacci.hs @@ -21,6 +21,7 @@ import Data.SBV.Control -- | Compute a prefix of the fibonacci numbers. We have: +-- -- >>> mkFibs 10 -- [1,1,2,3,5,8,13,21,34,55] mkFibs :: Int -> IO [Integer] diff --git a/Documentation/SBV/Examples/Misc/Floating.hs b/Documentation/SBV/Examples/Misc/Floating.hs --- a/Documentation/SBV/Examples/Misc/Floating.hs +++ b/Documentation/SBV/Examples/Misc/Floating.hs @@ -58,19 +58,19 @@ -- -- >>> assocPlusRegular -- Falsifiable. Counter-example: --- x = 5.615828e-4 :: Float --- y = -2.2688436e-3 :: Float --- z = -2047.9991 :: Float +-- x = 128.00029 :: Float +-- y = -7.27236e-4 :: Float +-- z = -6.875994e-3 :: Float -- -- Indeed, we have: -- --- >>> let x = 5.615828e-4 :: Float --- >>> let y = -2.2688436e-3 :: Float --- >>> let z = -2047.9991 :: Float +-- >>> let x = 128.00029 :: Float +-- >>> let y = -7.27236e-4 :: Float +-- >>> let z = -6.875994e-3 :: Float -- >>> x + (y + z) --- -2048.001 +-- 127.99268 -- >>> (x + y) + z --- -2048.0007 +-- 127.99269 -- -- Note the difference in the results! assocPlusRegular :: IO ThmResult @@ -92,13 +92,13 @@ -- -- >>> nonZeroAddition -- Falsifiable. Counter-example: --- a = -1.9999999 :: Float --- b = 9.403954e-38 :: Float +-- a = 5.060287e28 :: Float +-- b = 3.6780381e19 :: Float -- -- Indeed, we have: -- --- >>> let a = -1.9999999 :: Float --- >>> let b = 9.403954e-38 :: Float +-- >>> let a = 5.060287e28 :: Float +-- >>> let b = 3.6780381e19 :: Float -- >>> a + b == a -- True -- >>> b == 0 @@ -121,15 +121,15 @@ -- -- >>> multInverse -- Falsifiable. Counter-example: --- a = -1.910829855912238e-308 :: Double +-- a = 2.4907063e38 :: Float -- -- Indeed, we have: -- --- >>> let a = -1.910829855912238e-308 :: Double +-- >>> let a = 2.4907063e38 :: Float -- >>> a * (1/a) --- 0.9999999999999999 +-- 1.0000001 multInverse :: IO ThmResult -multInverse = prove $ do a <- sDouble "a" +multInverse = prove $ do a <- sFloat "a" constrain $ fpIsPoint a constrain $ fpIsPoint (1/a) return $ a * (1/a) .== 1 @@ -147,33 +147,33 @@ -- -- >>> roundingAdd -- Satisfiable. Model: --- rm = RoundNearestTiesToAway :: RoundingMode --- x = 1.0 :: Float --- y = -0.43749997 :: Float +-- rm = RoundTowardPositive :: RoundingMode +-- x = -2.3509886e-38 :: Float +-- y = -6.0e-45 :: Float -- -- (Note that depending on your version of Z3, you might get a different result.) -- Unfortunately we can't directly validate this result at the Haskell level, as Haskell only supports -- 'RoundNearestTiesToEven'. We have: -- --- >>> 1.0 + (-0.43749997) :: Float --- 0.5625 +-- >>> -2.3509886e-38 + (-6.0e-45) :: Float +-- -2.3509893e-38 -- --- While we cannot directly see the result when the mode is 'RoundNearestTiesToAway' in Haskell, we can use +-- While we cannot directly see the result when the mode is 'RoundTowardPositive' in Haskell, we can use -- SBV to provide us with that result thusly: -- --- >>> sat $ \z -> z .== fpAdd sRoundNearestTiesToAway 1.0 (-0.43749997 :: SFloat) +-- >>> sat $ \z -> z .== fpAdd sRoundTowardPositive (-2.3509886e-38) (-6.0e-45 :: SFloat) -- Satisfiable. Model: --- s0 = 0.56250006 :: Float +-- s0 = -2.350989e-38 :: Float -- --- We can see why these two resuls are indeed different: The 'RoundNearestTiesToAway' --- (which rounds away from zero) produces a larger result. Indeed, if we treat these numbers +-- We can see why these two resuls are indeed different: The 'RoundTowardPositive' +-- (which rounds towards positive infinity from zero) produces a larger result. Indeed, if we treat these numbers -- as 'Double' values, we get: -- --- >> 1.0 + (-0.43749997 :: Double) --- 0.56250003 +-- >> -2.3509886e-38 + (-6.0e-45) :: Double +-- -2.3509892e-38 -- -- we see that the "more precise" result is larger than what the 'Float' value is, justifying the --- larger value with 'RoundNearestTiesToAway'. A more detailed study is beyond our current scope, so we'll +-- larger value with 'RoundTowardPositive'. A more detailed study is beyond our current scope, so we'll -- merely note that floating point representation and semantics is indeed a thorny -- subject, and point to as -- an excellent guide. diff --git a/Documentation/SBV/Examples/Misc/Newtypes.hs b/Documentation/SBV/Examples/Misc/Newtypes.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/Misc/Newtypes.hs @@ -0,0 +1,88 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.Misc.Newtypes +-- Copyright : (c) Curran McConnell +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Demonstrates how to create symbolic newtypes with the same behaviour as +-- their wrapped type. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module Documentation.SBV.Examples.Misc.Newtypes where + +import Prelude hiding (ceiling) +import Data.SBV +import qualified Data.SBV.Internals as SI + +-- | A 'Metres' is a newtype wrapper around 'Integer'. +newtype Metres = Metres Integer deriving (Real, Integral, Num, Enum, Eq, Ord) + +-- | Symbolic version of 'Metres'. +type SMetres = SBV Metres + +-- | To use 'Metres' symbolically, we associate it with the underlying symbolic +-- type's kind. +instance HasKind Metres where + kindOf _ = KUnbounded + +-- | The 'SymVal' instance simply uses stock definitions. This is always +-- possible for newtypes that simply wrap over an existing symbolic type. +instance SymVal Metres where + mkSymVal = SI.genMkSymVar KUnbounded + literal = SI.genLiteral KUnbounded + fromCV = SI.genFromCV + +-- | Similarly, we can create another newtype, this time wrapping over 'Word16'. As an example, +-- consider measuring the human height in centimetres? The tallest person in history, +-- Robert Wadlow, was 272 cm. We don't need negative values, so 'Word16' is the smallest type that +-- suits our needs. +newtype HumanHeightInCm = HumanHeightInCm Word16 deriving (Real, Integral, Num, Enum, Eq, Ord) + +-- | Symbolic version of 'HumanHeightInCm'. +type SHumanHeightInCm = SBV HumanHeightInCm + +-- | Symbolic instance simply follows the underlying type, just like 'Metres'. +instance HasKind HumanHeightInCm where + kindOf _ = KBounded False 16 + +-- | Similarly here, for the 'SymVal' instance. +instance SymVal HumanHeightInCm where + mkSymVal = SI.genMkSymVar $ KBounded False 16 + literal = SI.genLiteral $ KBounded False 16 + fromCV = SI.genFromCV + +-- | The tallest human ever was 272 cm. We can simply use 'literal' to lift it +-- to the symbolic space. +tallestHumanEver :: SHumanHeightInCm +tallestHumanEver = literal 272 + +-- | Given a distance between a floor and a ceiling, we can see whether +-- the human can stand in that room. Comparison is expressed using 'sFromIntegral'. +ceilingHighEnoughForHuman :: SMetres -> SHumanHeightInCm -> SBool +ceilingHighEnoughForHuman ceiling humanHeight = humanHeight' .< ceiling' + where -- In a real codebase, the code for comparing these newtypes + -- should be reusable, perhaps through a typeclass. + ceiling' = literal 100 * sFromIntegral ceiling :: SInteger + humanHeight' = sFromIntegral humanHeight :: SInteger + +-- | Now, suppose we want to see whether we could design a room with a ceiling +-- high enough that any human could stand in it. We have: +-- +-- >>> sat problem +-- Satisfiable. Model: +-- floorToCeiling = 3 :: Integer +-- humanheight = 255 :: Word16 +problem :: Predicate +problem = do + ceiling :: SMetres <- free "floorToCeiling" + humanHeight :: SHumanHeightInCm <- free "humanheight" + constrain $ humanHeight .<= tallestHumanEver + + return $ ceilingHighEnoughForHuman ceiling humanHeight diff --git a/Documentation/SBV/Examples/Optimization/ExtField.hs b/Documentation/SBV/Examples/Optimization/ExtField.hs --- a/Documentation/SBV/Examples/Optimization/ExtField.hs +++ b/Documentation/SBV/Examples/Optimization/ExtField.hs @@ -24,16 +24,16 @@ -- >>> optimize Independent problem -- Objective "one-x": Optimal in an extension field: -- one-x = oo :: Integer --- min_y = 7.0 + (2.0 * epsilon) :: Real --- min_z = 5.0 + epsilon :: Real +-- min_y = 7.0 + (3.0 * epsilon) :: Real +-- min_z = 5.0 + (2.0 * epsilon) :: Real -- Objective "min_y": Optimal in an extension field: -- one-x = oo :: Integer --- min_y = 7.0 + (2.0 * epsilon) :: Real --- min_z = 5.0 + epsilon :: Real +-- min_y = 7.0 + (3.0 * epsilon) :: Real +-- min_z = 5.0 + (2.0 * epsilon) :: Real -- Objective "min_z": Optimal in an extension field: -- one-x = oo :: Integer --- min_y = 7.0 + (2.0 * epsilon) :: Real --- min_z = 5.0 + epsilon :: Real +-- min_y = 7.0 + (3.0 * epsilon) :: Real +-- min_z = 5.0 + (2.0 * epsilon) :: Real problem :: Goal problem = do x <- sInteger "x" y <- sReal "y" diff --git a/Documentation/SBV/Examples/ProofTools/BMC.hs b/Documentation/SBV/Examples/ProofTools/BMC.hs --- a/Documentation/SBV/Examples/ProofTools/BMC.hs +++ b/Documentation/SBV/Examples/ProofTools/BMC.hs @@ -83,7 +83,7 @@ -- BMC: Iteration: 2 -- BMC: Iteration: 3 -- BMC: Solution found at iteration 3 --- Right (3,[(0,10),(0,6),(2,6),(2,2)]) +-- Right (3,[(0,10),(2,10),(2,6),(2,2)]) -- -- As expected, there's a solution in this case. Furthermore, since the BMC engine -- found a solution at depth @3@, we also know that there is no solution at diff --git a/Documentation/SBV/Examples/Queries/AllSat.hs b/Documentation/SBV/Examples/Queries/AllSat.hs --- a/Documentation/SBV/Examples/Queries/AllSat.hs +++ b/Documentation/SBV/Examples/Queries/AllSat.hs @@ -20,10 +20,8 @@ import Data.SBV import Data.SBV.Control -import Data.List - -- | Find all solutions to @x + y .== 10@ for positive @x@ and @y@, but at each --- iteration we would like to ensure that the value of @x@ we get is at least twice as large as +-- iteration we would like to ensure that the value of @x@ we get is one more than -- the previous one. This is rather silly, but demonstrates how we can dynamically -- query the result and put in new constraints based on those. goodSum :: Symbolic [(Integer, Integer)] @@ -37,13 +35,16 @@ -- Capture the "next" solution function: let next i sofar = do - io $ putStrLn $ "Iteration: " ++ show (i :: Int) + io $ putStrLn $ "Iteration: " ++ show (i :: Integer) - cs <- checkSat + -- Using a check-sat assuming, we force the solver to walk through + -- the entire range of x's + cs <- checkSatAssuming [x .== literal (i-1)] + case cs of Unk -> error "Too bad, solver said unknown.." -- Won't happen Unsat -> do io $ putStrLn "No other solution!" - return sofar + return $ reverse sofar Sat -> do xv <- getValue x yv <- getValue y @@ -56,9 +57,6 @@ constrain $ x ./= literal xv .|| y ./= literal yv - -- Also request @x@ to be twice as large, for demo purposes: - constrain $ x .>= 2 * literal xv - -- loop around! next (i+1) ((xv, yv) : sofar) @@ -77,12 +75,23 @@ -- Iteration: 3 -- Current solution is: (2,8) -- Iteration: 4 --- Current solution is: (4,6) +-- Current solution is: (3,7) -- Iteration: 5 --- Current solution is: (8,2) +-- Current solution is: (4,6) -- Iteration: 6 +-- Current solution is: (5,5) +-- Iteration: 7 +-- Current solution is: (6,4) +-- Iteration: 8 +-- Current solution is: (7,3) +-- Iteration: 9 +-- Current solution is: (8,2) +-- Iteration: 10 +-- Current solution is: (9,1) +-- Iteration: 11 +-- Current solution is: (10,0) +-- Iteration: 12 -- No other solution! --- [(0,10),(1,9),(2,8),(4,6),(8,2)] +-- [(0,10),(1,9),(2,8),(3,7),(4,6),(5,5),(6,4),(7,3),(8,2),(9,1),(10,0)] demo :: IO () -demo = do ss <- runSMT goodSum - print $ sort ss +demo = print =<< runSMT goodSum diff --git a/Documentation/SBV/Examples/Queries/Concurrency.hs b/Documentation/SBV/Examples/Queries/Concurrency.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/Queries/Concurrency.hs @@ -0,0 +1,170 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.Queries.Concurrency +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- When we would like to solve a set of related problems we can use query mode +-- to perform push's and pop's. However performing a push and a pop is still +-- single threaded and so each solution will need to wait for the previous +-- solution to be found. In this example we show a class of functions +-- 'Data.SBV.satConcurrentAll' and 'Data.SBV.satConcurrentAny' which spin up +-- independent solver instances and runs query computations concurrently. The +-- children query computations are allowed to communicate with one another as +-- demonstrated in the second demo +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.Queries.Concurrency where + +import Data.SBV +import Data.SBV.Control +import Control.Concurrent +import Control.Monad.IO.Class (liftIO) + +-- | Find all solutions to @x + y .== 10@ for positive @x@ and @y@, but at each +-- iteration we would like to ensure that the value of @x@ we get is at least +-- twice as large as the previous one. This is rather silly, but demonstrates +-- how we can dynamically query the result and put in new constraints based on +-- those. +shared :: MVar (SInteger, SInteger) -> Symbolic () +shared v = do + x <- sInteger "x" + y <- sInteger "y" + constrain $ y .<= 10 + constrain $ x .<= 10 + constrain $ x + y .== 10 + liftIO $ putMVar v (x,y) + +-- | In our first query we'll define a constraint that will not be known to the +-- shared or second query and then solve for an answer that will differ from the +-- first query. Note that we need to pass an MVar in so that we can operate on +-- the shared variables. In general, the variables you want to operate on should +-- be defined in the shared part of the query and then passed to the children +-- queries via channels, MVars, or TVars. In this query we constrain x to be +-- less than y and then return the sum of the values. We add a threadDelay just +-- for demonstration purposes +queryOne :: MVar (SInteger, SInteger) -> Query (Maybe Integer) +queryOne v = do + io $ putStrLn $ "[One]: Waiting" + liftIO $ threadDelay 5000000 + io $ putStrLn $ "[One]: Done" + (x,y) <- liftIO $ takeMVar v + constrain $ x .< y + + cs <- checkSat + case cs of + Unk -> error "Too bad, solver said unknown.." -- Won't happen + Unsat -> do io $ putStrLn "No other solution!" + return Nothing + + Sat -> do xv <- getValue x + yv <- getValue y + io $ putStrLn $ "[One]: Current solution is: " ++ show (xv, yv) + return $ Just (xv + yv) + +-- | In the second query we constrain for an answer where y is smaller than x, +-- and then return the product of the found values. +queryTwo :: MVar (SInteger, SInteger) -> Query (Maybe Integer) +queryTwo v = do + (x,y) <- liftIO $ takeMVar v + io $ putStrLn $ "[Two]: got values" ++ show (x,y) + constrain $ y .< x + + cs <- checkSat + case cs of + Unk -> error "Too bad, solver said unknown.." -- Won't happen + Unsat -> do io $ putStrLn "No other solution!" + return Nothing + + Sat -> do yv <- getValue y + xv <- getValue x + io $ putStrLn $ "[Two]: Current solution is: " ++ show (xv, yv) + return $ Just (xv * yv) + +-- | Run the demo several times to see that the children threads will change ordering. +demo :: IO () +demo = do + v <- newEmptyMVar + putStrLn $ "[Main]: Hello from main, kicking off children: " + results <- satConcurrentWithAll z3 [queryOne v, queryTwo v] (shared v) + putStrLn $ "[Main]: Children spawned, waiting for results" + putStrLn $ "[Main]: Here they are: " + putStrLn $ show results + +-- | Example computation. +sharedDependent :: MVar (SInteger, SInteger) -> Symbolic () +sharedDependent v = do -- constrain positive and sum: + x <- sInteger "x" + y <- sInteger "y" + constrain $ y .<= 10 + constrain $ x .<= 10 + constrain $ x + y .== 10 + liftIO $ putMVar v (x,y) + +-- | In our first query we will make a constrain, solve the constraint and +-- return the values for our variables, then we'll mutate the MVar sending +-- information to the second query. Note that you could use channels, or TVars, +-- or TMVars, whatever you need here, we just use MVars for demonstration +-- purposes. Also note that this effectively creates an ordering between the +-- children queries +firstQuery :: MVar (SInteger, SInteger) -> MVar (SInteger , SInteger) -> Query (Maybe Integer) +firstQuery v1 v2 = do + (x,y) <- liftIO $ takeMVar v1 + io $ putStrLn $ "[One]: got vars...working..." + constrain $ x .< y + + cs <- checkSat + case cs of + Unk -> error "Too bad, solver said unknown.." -- Won't happen + Unsat -> do io $ putStrLn "No other solution!" + return Nothing + + Sat -> do xv <- getValue x + yv <- getValue y + io $ putStrLn $ "[One]: Current solution is: " ++ show (xv, yv) + io $ putStrLn $ "[One]: Place vars for [Two]" + liftIO $ putMVar v2 (literal (xv + yv), literal (xv * yv)) + return $ Just (xv + yv) + +-- | In the second query we create a new variable z, and then a symbolic query +-- using information from the first query and return a solution that uses the +-- new variable and the old variables. Each child query is run in a separate +-- instance of z3 so you can think of this query as driving to a point in the +-- search space, then waiting for more information, once it gets that +-- information it will run a completely separate computation from the first one +-- and return its results. +secondQuery :: MVar (SInteger, SInteger) -> Query (Maybe Integer) +secondQuery v2 = do + (x,y) <- liftIO $ takeMVar v2 + io $ putStrLn $ "[Two]: got values" ++ show (x,y) + z <- freshVar "z" + constrain $ z .> x + y + + cs <- checkSat + case cs of + Unk -> error "Too bad, solver said unknown.." -- Won't happen + Unsat -> do io $ putStrLn "No other solution!" + return Nothing + + Sat -> do yv <- getValue y + xv <- getValue x + zv <- getValue z + io $ putStrLn $ "[Two]: My solution is: " ++ show (zv + xv, zv + yv) + return $ Just (zv * xv * yv) + +-- | In our second demonstration we show how through the use of concurrency +-- constructs the user can have children queries communicate with one another. +-- Note that the children queries are independent and so anything side-effectual +-- like a push or a pop will be isolated to that child thread, unless of course +-- it happens in shared. +demoDependent :: IO () +demoDependent = do + v1 <- newEmptyMVar + v2 <- newEmptyMVar + results <- satConcurrentWithAll z3 [firstQuery v1 v2, secondQuery v2] (sharedDependent v1) + print results diff --git a/Documentation/SBV/Examples/Uninterpreted/Multiply.hs b/Documentation/SBV/Examples/Uninterpreted/Multiply.hs --- a/Documentation/SBV/Examples/Uninterpreted/Multiply.hs +++ b/Documentation/SBV/Examples/Uninterpreted/Multiply.hs @@ -61,15 +61,14 @@ -- and if you work out the truth-table presented, you'll see that it is exactly that. Of course, -- you can use SBV to prove this. First, define the model we were given to make it symbolic: -- --- >>> :{ --- mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool +--- mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool -- mul22_hi a1 a0 b1 b0 = ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sFalse]) sTrue -- $ ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sTrue ]) sTrue -- $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sFalse, sTrue ]) sTrue -- $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sTrue , sTrue ]) sTrue -- $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sFalse, sTrue ]) sTrue -- $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sTrue , sFalse]) sTrue --- sFalse +-- sFalse- >>> :{ -- :} -- -- Now we can say: diff --git a/Documentation/SBV/Examples/WeakestPreconditions/Basics.hs b/Documentation/SBV/Examples/WeakestPreconditions/Basics.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/WeakestPreconditions/Basics.hs @@ -0,0 +1,176 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.WeakestPreconditions.Basics +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Some basic aspects of weakest preconditions, demostrating programs +-- that do not use while loops. We use a simple increment program as +-- an example. +----------------------------------------------------------------------------- + +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveFoldable #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DeriveTraversable #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE NamedFieldPuns #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Documentation.SBV.Examples.WeakestPreconditions.Basics where + +import Data.SBV +import Data.SBV.Control + +import Data.SBV.Tools.WeakestPreconditions + +import GHC.Generics (Generic) + +-- * Program state + +-- | The state for the swap program, parameterized over a base type @a@. +data IncS a = IncS { x :: a -- ^ Input value + , y :: a -- ^ Output + } + deriving (Show, Generic, Mergeable, Functor, Foldable, Traversable) + +-- | Show instance for 'IncS'. The above deriving clause would work just as well, +-- but we want it to be a little prettier here, and hence the @OVERLAPS@ directive. +instance {-# OVERLAPS #-} (SymVal a, Show a) => Show (IncS (SBV a)) where + show (IncS x y) = "{x = " ++ sh x ++ ", y = " ++ sh y ++ "}" + where sh v = case unliteral v of + Nothing -> "" + Just l -> show l + +-- | 'Fresh' instance for the program state +instance SymVal a => Fresh IO (IncS (SBV a)) where + fresh = IncS <$> freshVar_ <*> freshVar_ + +-- | Helper type synonym +type I = IncS SInteger + +-- * The algorithm + +-- | The increment algorithm: +-- +-- @ +-- y = x+1 +-- @ +-- +-- The point here isn't really that this program is interesting, but we want to +-- demonstrate various aspects of WP proofs. So, we take a before and after +-- program to annotate our algorithm so we can experiment later. +algorithm :: Stmt I -> Stmt I -> Stmt I +algorithm before after = Seq [ before + , Assign $ \st@IncS{x} -> st{y = x+1} + , after + ] + +-- | Precondition for our program. Strictly speaking, we don't really need any preconditions, +-- but for example purposes, we'll require @x@ to be non-negative. +pre :: I -> SBool +pre IncS{x} = x .>= 0 + +-- | Postcondition for our program: @y@ must @x+1@. +post :: I -> SBool +post IncS{x, y} = y .== x+1 + +-- | Stability: @x@ must remain unchanged. +noChange :: Stable I +noChange = [stable "x" x] + +-- | A program is the algorithm, together with its pre- and post-conditions. +imperativeInc :: Stmt I -> Stmt I -> Program I +imperativeInc before after = Program { setup = return () + , precondition = pre + , program = algorithm before after + , postcondition = post + , stability = noChange + } + +-- * Correctness + +-- | State the correctness with respect to before/after programs. In the simple +-- case of nothing prior/after, we have the obvious proof: +-- +-- >>> correctness Skip Skip +-- Total correctness is established. +-- Q.E.D. +correctness :: Stmt I -> Stmt I -> IO (ProofResult (IncS Integer)) +correctness before after = wpProveWith defaultWPCfg{wpVerbose=True} (imperativeInc before after) + +-- * Example proof attempts +-- +-- $examples + +{- $examples +It is instructive to look at how the proof changes as we put in different @pre@ and @post@ values. + +== Violating the post condition + +If we stick in an extra increment for @y@ after, we can easily break the postcondition: + +>>> :set -XNamedFieldPuns +>>> import Control.Monad (void) +>>> void $ correctness Skip $ Assign $ \st@IncS{y} -> st{y = y+1} +Following proof obligation failed: +================================== + Postcondition fails: + Start: IncS {x = 0, y = 0} + End : IncS {x = 0, y = 2} + +We're told that the program ends up in a state where @x=0@ and @y=2@, violating the requirement @y=x+1@, as expected. + +== Using 'assert' + +There are two main use cases for 'assert', which merely ends up being a call to 'Abort'. +One is making sure the inputs are well formed. And the other is the user putting in their +own invariants into the code. + +Let's assume that we only want to accept strictly positive values of @x@. We can try: + +>>> void $ correctness (assert "x > 0" (\st@IncS{x} -> x .> 0)) Skip +Following proof obligation failed: +================================== + Abort "x > 0" condition is satisfiable: + Before: IncS {x = 0, y = 0} + After : IncS {x = 0, y = 0} + +Recall that our precondition ('pre') required @x@ to be non-negative. So, we can put in something weaker and it would be fine: + +>>> void $ correctness (assert "x > -5" (\st@IncS{x} -> x .> -5)) Skip +Total correctness is established. + +In this case the precondition to our program ensures that the 'assert' will always be satisfied. + +As another example, let us put a post assertion that @y@ is even: + +>>> void $ correctness Skip (assert "y is even" (\st@IncS{y} -> y `sMod` 2 .== 0)) +Following proof obligation failed: +================================== + Abort "y is even" condition is satisfiable: + Before: IncS {x = 0, y = 0} + After : IncS {x = 0, y = 1} + +It is important to emphasize that you can put whatever invariant you might want: + +>>> void $ correctness Skip (assert "y > x" (\st@IncS{x, y} -> y .> x)) +Total correctness is established. + +== Violating stability + +What happens if our program modifies @x@? After all, we can simply set @x=10@ and @y=11@ and our post condition would be satisfied: + +>>> void $ correctness Skip (Assign $ \st -> st{x = 10, y = 11}) +Following proof obligation failed: +================================== + Stability fails for "x": + Before: IncS {x = 0, y = 1} + After : IncS {x = 10, y = 11} + +So, the stability condition prevents programs from cheating! +-} diff --git a/Documentation/SBV/Examples/WeakestPreconditions/Fib.hs b/Documentation/SBV/Examples/WeakestPreconditions/Fib.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/Fib.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/Fib.hs @@ -50,7 +50,7 @@ Just l -> show l -- | 'Fresh' instance for the program state -instance (SymVal a, SMTValue a) => Fresh IO (FibS (SBV a)) where +instance SymVal a => Fresh IO (FibS (SBV a)) where fresh = FibS <$> freshVar_ <*> freshVar_ <*> freshVar_ <*> freshVar_ -- | Helper type synonym diff --git a/Documentation/SBV/Examples/WeakestPreconditions/GCD.hs b/Documentation/SBV/Examples/WeakestPreconditions/GCD.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/GCD.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/GCD.hs @@ -56,7 +56,7 @@ Just l -> show l -- | 'Fresh' instance for the program state -instance (SymVal a, SMTValue a) => Fresh IO (GCDS (SBV a)) where +instance SymVal a => Fresh IO (GCDS (SBV a)) where fresh = GCDS <$> freshVar_ <*> freshVar_ <*> freshVar_ <*> freshVar_ -- | Helper type synonym diff --git a/Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs b/Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/IntDiv.hs @@ -49,7 +49,7 @@ Just l -> show l -- | 'Fresh' instance for the program state -instance (SymVal a, SMTValue a) => Fresh IO (DivS (SBV a)) where +instance SymVal a => Fresh IO (DivS (SBV a)) where fresh = DivS <$> freshVar_ <*> freshVar_ <*> freshVar_ <*> freshVar_ -- | Helper type synonym diff --git a/Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs b/Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/IntSqrt.hs @@ -53,7 +53,7 @@ Just l -> show l -- | 'Fresh' instance for the program state -instance (SymVal a, SMTValue a) => Fresh IO (SqrtS (SBV a)) where +instance SymVal a => Fresh IO (SqrtS (SBV a)) where fresh = SqrtS <$> freshVar_ <*> freshVar_ <*> freshVar_ <*> freshVar_ -- | Helper type synonym diff --git a/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs b/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs --- a/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs +++ b/Documentation/SBV/Examples/WeakestPreconditions/Sum.hs @@ -48,7 +48,7 @@ Just l -> show l -- | 'Fresh' instance for the program state -instance (SymVal a, SMTValue a) => Fresh IO (SumS (SBV a)) where +instance SymVal a => Fresh IO (SumS (SBV a)) where fresh = SumS <$> freshVar_ <*> freshVar_ <*> freshVar_ -- | Helper type synonym @@ -208,7 +208,7 @@ After : SumS {n = 2, i = 2, s = 3} Here, we posed the extra incorrect invariant that @s <= i@ must be maintained, and SBV found us a reachable state that violates the invariant. The -show /before/ state indeed satisfies @s <= i@, but the /after/ state does not. Note that the proof fails in this case not because the program +/before/ state indeed satisfies @s <= i@, but the /after/ state does not. Note that the proof fails in this case not because the program is incorrect, but the stipulated invariant is not valid. == Having a bad measure, Part I @@ -221,8 +221,8 @@ Following proof obligation failed: ================================== Measure for loop "i < n" is negative: - State : SumS {n = 2, i = 1, s = 1} - Measure: -1 + State : SumS {n = 3, i = 2, s = 3} + Measure: -2 The failure is pretty obvious in this case: Measure produces a negative value. @@ -241,5 +241,7 @@ After : SumS {n = 1, i = 1, s = 1} Measure: 2 -Clearly, as @i@ increases, so does our bogus measure @n+i@. +Clearly, as @i@ increases, so does our bogus measure @n+i@. Note that a counterexample where @i@ is +negative is also possible for this failure, as the SMT solver will find a counter-example to induction, not +necessarily a reachable state. Obviously, all such failures need to be addressed for the full proof. -} diff --git a/SBVBenchSuite/BenchSuite/Bench/Bench.hs b/SBVBenchSuite/BenchSuite/Bench/Bench.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Bench/Bench.hs @@ -0,0 +1,247 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Bench.Bench +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Assessing the overhead of calling solving examples via sbv vs individual solvers +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE ExistentialQuantification #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Bench.Bench + ( run + , run' + , runWith + , runIOWith + , runIO + , runPure + , rGroup + , runOverheadBenchMark + , runBenchMark + , onConfig + , onDesc + , runner + , onProblem + , Runner(..) + , using + ) where + +import Control.DeepSeq (NFData (..), rwhnf) +import System.Directory (getCurrentDirectory) +import System.IO +import System.IO.Silently (silence) + +import Gauge.Main + +import qualified System.Process as P +import qualified Utils.SBVBenchFramework as U + +-- | The type of the problem to benchmark. This allows us to operate on Runners +-- as values themselves yet still have a unified interface with gauge. +data Problem = forall a . U.Provable a => Problem a + +-- | Similarly to Problem, BenchResult is boilerplate for a nice api +data BenchResult = forall a . (Show a, NFData a) => BenchResult a + +-- | A bench unit is a solver and a problem that represents an input problem +-- for the solver to solve +type BenchUnit = (U.SMTConfig, FilePath) + +-- | A runner is anything that allows the solver to solve, such as: +-- 'Data.SBV.proveWith' or 'Data.SBV.satWith'. We utilize existential types to +-- lose type information and create a unified interface with gauge. We +-- require a runner in order to generate a 'Data.SBV.transcript' and then to run +-- the actual benchmark. We bundle this redundantly into a record so that the +-- benchmarks can be defined in each respective module, with the run function +-- that makes sense for that problem, and then redefined in 'SBVBench'. This is +-- useful because problems that require 'Data.SBV.allSatWith' can lead to a lot +-- of variance in the benchmarking data. Single benchmark runners like +-- 'Data.SBV.satWith' and 'Data.SBV.proveWith' work best. +data RunnerI = RunnerI { runI :: (U.SMTConfig -> Problem -> IO BenchResult) + , config :: U.SMTConfig + , description :: String + , problem :: Problem + } + +-- | GADT to allow arbritrary nesting of runners. This copies criterion's design +-- so that we don't have to separate out runners that run a single benchmark +-- from runners that need to run several benchmarks +data Runner where + RBenchmark :: Benchmark -> Runner -- ^ a wrapper around gauge benchmarks + Runner :: RunnerI -> Runner -- ^ a single run + RunnerGroup :: [Runner] -> Runner -- ^ a group of runs + +-- | Convenience boilerplate functions, simply avoiding a lens dependency +using :: Runner -> (Runner -> Runner) -> Runner +using = flip ($) + +-- | Set the runner function +runner :: (Show c, NFData c) => + (forall a. U.Provable a => U.SMTConfig -> a -> IO c) -> Runner -> Runner +runner r' (Runner r@RunnerI{..}) = Runner $ r{runI = toRun r'} +runner r' (RunnerGroup rs) = RunnerGroup $ runner r' <$> rs +runner _ x = x + +toRun :: (Show c, NFData c) => + (forall a. U.Provable a => U.SMTConfig -> a -> IO c) + -> U.SMTConfig + -> Problem + -> IO BenchResult +toRun f c p = BenchResult <$> helper p + -- similar to helper in onProblem, this is lmap from profunctor land, i.e., we + -- curry with a config, then change the runner function from (a -> IO c), to + -- (Problem -> IO c) + where helper (Problem a) = f c a + +onConfig :: (U.SMTConfig -> U.SMTConfig) -> RunnerI -> RunnerI +onConfig f r@RunnerI{..} = r{config = f config} + +onDesc :: (String -> String) -> RunnerI -> RunnerI +onDesc f r@RunnerI{..} = r{description = f description} + +onProblem :: (forall a. a -> a) -> RunnerI -> RunnerI +onProblem f r@RunnerI{..} = r{problem = (helper problem)} + where + -- helper function to avoid profunctor dependency, this is simply fmap, or + -- rmap for profunctor land + helper :: Problem -> Problem + helper (Problem p) = Problem $ f p + + +-- | Filepath to /dev/null +devNull :: FilePath +#ifndef WINDOWS +devNull = "/dev/null" +#else +devNull = "NUL" +#endif + +-- | to bench a solver without interfacing through SBV we call transcript to +-- have SBV generate the input file for the solver and then create a process to +-- initiate execution on the solver. Note that we redirect stdout to /dev/devNull +-- or NUL on windows +runStandaloneSolver :: BenchUnit -> IO () +runStandaloneSolver (slvr, fname) = + withFile devNull WriteMode $ + (\h -> do (_,_,_,ph) <- P.createProcess (P.shell command){P.std_out = P.UseHandle h} + _ <- P.waitForProcess ph + return ()) + where command = U.mkExecString slvr fname + +-- | Given a file name, a solver config, and a problem to solve, create an +-- environment for the gauge benchmark by generating a transcript file +standaloneEnv :: RunnerI -> IO FilePath -> IO BenchUnit +standaloneEnv RunnerI{..} f = f >>= go problem + where + -- generate a transcript for the unit + go p file = do pwd <- getCurrentDirectory + let fPath = mconcat [pwd,"/",file] + _ <- runI config{U.transcript = Just fPath} p >> return () + return (config,fPath) + +-- | Cleanup the environment created by gauge by removing the transcript file +-- used to run the standalone solver +standaloneCleanup :: BenchUnit -> IO () +standaloneCleanup (_,fPath) = P.callCommand $ "rm " ++ fPath + +-- | To construct a benchmark to test SBV's overhead we setup an environment +-- with gauge where a symbolic computation is emitted to a transcript file. +-- To test the solver without respect to SBV (standalone) we pass the transcript +-- file to the solver using the same primitives SBV does. Not that mkFileName +-- generates a random filename that is removed at the end of the benchmark. This +-- function exposes the solver and the solve interface in case the user would +-- like to benchmark with something other than 'Data.SBV.z3' and so that we can +-- benchmark all solving variants, e.g., 'Data.SBV.proveWith', +-- 'Data.SBV.satWith', 'Data.SBV.allProveWith' etc. +mkOverheadBenchMark' :: RunnerI -> Benchmark +mkOverheadBenchMark' r@RunnerI{..} = + envWithCleanup + (standaloneEnv r U.mkFileName) + standaloneCleanup $ + \ ~unit -> + bgroup description [ bench "standalone" $ nfIO $ runStandaloneSolver unit + -- notice for sbv benchmark; we pull the solver out of unit and + -- use the input problem not the transcript in the unit + , bench "sbv" $ nfIO $ runI (fst unit) problem + ] + +runOverheadBenchMark :: Runner -> Benchmark +runOverheadBenchMark (Runner r@RunnerI{..}) = mkOverheadBenchMark' r +runOverheadBenchMark (RunnerGroup rs) = bgroup "" $ -- leave the description close to the benchmark/problem definition + runOverheadBenchMark <$> rs +runOverheadBenchMark (RBenchmark b) = b + + +-- | make a normal benchmark without the overhead comparision. Notice this is +-- just unpacking the Runner record +mkBenchMark :: RunnerI -> Benchmark +mkBenchMark RunnerI{..} = bgroup description [bench "" . nfIO $! runI config problem] + +-- | Convert a Runner or a group of Runners to Benchmarks, this is an api level +-- function to convert the runners defined in each file to benchmarks which can +-- be run by gauge +runBenchMark :: Runner -> Benchmark +runBenchMark (Runner r@RunnerI{..}) = mkBenchMark r +runBenchMark (RunnerGroup rs) = bgroup "" $ runBenchMark <$> rs +runBenchMark (RBenchmark b) = b + +-- | This is just a wrapper around the RunnerI constructor and serves as the main +-- entry point to make a runner for a user in case they need something custom. +run' :: (NFData b, Show b) => + (forall a. U.Provable a => U.SMTConfig -> a -> IO b) + -> U.SMTConfig + -> String + -> Problem + -> Runner +run' r config description problem = Runner $ RunnerI{..} + where runI = toRun r + +-- | Convenience function for creating benchmarks that exposes a configuration +runWith :: U.Provable a => U.SMTConfig -> String -> a -> Runner +runWith c d p = run' U.satWith c d (Problem p) + +-- | Main entry point for simple benchmarks. See 'mkRunner'' or 'mkRunnerWith' +-- for versions of this function that allows custom inputs. If you have some use +-- case that is not considered then you can simply overload the record fields. +run :: U.Provable a => String -> a -> Runner +run d p = runWith U.z3 d p `using` runner U.satWith + +-- | Entry point for problems that return IO or to benchmark IO results +runIOWith :: NFData a => (a -> Benchmarkable) -> String -> a -> Runner +runIOWith f d = RBenchmark . bench d . f + +-- | Benchmark an IO result of sbv, this could be codegen, return models, etc.. +-- See @runIOWith@ for a version which allows the consumer to select the +-- Benchmarkable injection function +runIO :: NFData a => String -> IO a -> Runner +runIO d = RBenchmark . bench d . nfIO . silence + +-- | Benchmark an pure result +runPure :: NFData a => String -> (a -> b) -> a -> Runner +runPure d = (RBenchmark . bench d) .: whnf + where (.:) = (.).(.) + +-- | create a runner group. Useful for benchmarks that need to run several +-- benchmarks. See 'BenchSuite.Puzzles.NQueens' for an example. +rGroup :: [Runner] -> Runner +rGroup = RunnerGroup + +-- | Orphaned instances just for benchmarking +instance NFData U.AllSatResult where + rnf (U.AllSatResult (a, b, c, results)) = + rnf a `seq` rnf b `seq` rnf c `seq` rwhnf results + +-- | Unwrap the existential type to make gauge happy +instance NFData BenchResult where rnf (BenchResult a) = rnf a diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/BitTricks.hs b/SBVBenchSuite/BenchSuite/BitPrecise/BitTricks.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/BitTricks.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.BitTricks +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.BitTricks +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.BitTricks(benchmarks) where + +import Documentation.SBV.Examples.BitPrecise.BitTricks +import BenchSuite.Bench.Bench as B + +import Data.SBV (proveWith) + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.run "Fast-min" fastMinCorrect `using` runner proveWith + , B.run "Fast-max" fastMaxCorrect `using` runner proveWith + ] diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/BrokenSearch.hs b/SBVBenchSuite/BenchSuite/BitPrecise/BrokenSearch.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/BrokenSearch.hs @@ -0,0 +1,42 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.BrokenSearch +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.BrokenSearch +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.BrokenSearch(benchmarks) where + +import Documentation.SBV.Examples.BitPrecise.BrokenSearch +import BenchSuite.Bench.Bench as B + +import Data.SBV (proveWith,sInt32,(.>=),(.<=),(.==),sFromIntegral,SInt64,sDiv,constrain) + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.run "Arith.MidPointFixed" (checkCorrect midPointFixed) `using` runner Data.SBV.proveWith + , B.run "Arith-Overflow" (checkCorrect midPointAlternative) `using` runner Data.SBV.proveWith + ] + + where checkCorrect f = do low <- sInt32 "low" + high <- sInt32 "high" + + constrain $ low .>= 0 + constrain $ low .<= high + + let low', high' :: SInt64 + low' = sFromIntegral low + high' = sFromIntegral high + mid' = (low' + high') `sDiv` 2 + + mid = f low high + + return $ sFromIntegral mid .== mid' diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/Legato.hs b/SBVBenchSuite/BenchSuite/BitPrecise/Legato.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/Legato.hs @@ -0,0 +1,40 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.Legato +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.Legato +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.Legato(benchmarks) where + +import Documentation.SBV.Examples.BitPrecise.Legato +import BenchSuite.Bench.Bench as B + +import Data.SBV + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.run "Correctness.Legato" correctnessThm `using` runner Data.SBV.proveWith + , B.runIO "CodeGen.Legato" legatoInC + ] + where correctnessThm = do + lo <- sWord "lo" + + x <- sWord "x" + y <- sWord "y" + + regX <- sWord "regX" + regA <- sWord "regA" + + flagC <- sBool "flagC" + flagZ <- sBool "flagZ" + + return $ legatoIsCorrect (x, y, lo, regX, regA, flagC, flagZ) diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/MergeSort.hs b/SBVBenchSuite/BenchSuite/BitPrecise/MergeSort.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/MergeSort.hs @@ -0,0 +1,34 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.MergeSort +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.MergeSort +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.MergeSort(benchmarks) where + +import Documentation.SBV.Examples.BitPrecise.MergeSort +import BenchSuite.Bench.Bench as B + +import Data.SBV + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.run "Correctness.MergeSort 10" (correctness' 10) `using` runner Data.SBV.proveWith + , B.run "Correctness.MergeSort 100" (correctness' 100) `using` runner Data.SBV.proveWith + , B.run "Correctness.MergeSort 1000" (correctness' 1000) `using` runner Data.SBV.proveWith + , B.runIO "CodeGen.MergeSort 10" $ codeGen 10 + , B.runIO "CodeGen.MergeSort 100" $ codeGen 100 + , B.runIO "CodeGen.MergeSort 1000" $ codeGen 1000 + ] + where correctness' n = do xs <- mkFreeVars n + let ys = mergeSort xs + return $ nonDecreasing ys .&& isPermutationOf xs ys diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs b/SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/MultMask.hs @@ -0,0 +1,31 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.MultMask +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.MultMask +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.MultMask(benchmarks) where + +import BenchSuite.Bench.Bench as B + +import Data.SBV + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.runWith conf "MultMask" find + ] + where find = do mask <- exists "mask" + mult <- exists "mult" + inp <- forall "inp" + let res = (mask .&. inp) * (mult :: SWord64) + solve [inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]] + conf = z3{printBase=16, satCmd = "(check-sat-using (and-then simplify smtfd))"} diff --git a/SBVBenchSuite/BenchSuite/BitPrecise/PrefixSum.hs b/SBVBenchSuite/BenchSuite/BitPrecise/PrefixSum.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/BitPrecise/PrefixSum.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.BitPrecise.PrefixSum +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.BitPrecise.PrefixSum +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.BitPrecise.PrefixSum(benchmarks) where + +import Documentation.SBV.Examples.BitPrecise.PrefixSum +import BenchSuite.Bench.Bench as B + +import Data.SBV + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ B.run "Correctness.PrefixSum 8" (flIsCorrect 8 (0,(+))) `using` runner proveWith + , B.run "Correctness.PrefixSum 16" (flIsCorrect 16 (0,smax)) `using` runner proveWith + ] diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/AddSub.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/AddSub.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/AddSub.hs @@ -0,0 +1,23 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.AddSub +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.AddSub +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.AddSub(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.AddSub + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "genAddSub" genAddSub diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/CRC_USB5.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/CRC_USB5.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/CRC_USB5.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.CRC_USB5 +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.CRC_USB5 +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.CRC_USB5(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.CRC_USB5 + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Correctness" crcGood + , runIO "CodeGen 1" cg1 + , runIO "CodeGen 2" cg2 + ] diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/Fibonacci.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/Fibonacci.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/Fibonacci.hs @@ -0,0 +1,30 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.Fibonacci +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.Fibonacci +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.Fibonacci(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.Fibonacci + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Fib1 1" $ genFib1 1 + , runIO "Fib1 10" $ genFib1 10 + , runIO "Fib1 20" $ genFib1 20 + , runIO "Fib2 1" $ genFib1 1 + , runIO "Fib2 10" $ genFib1 10 + , runIO "Fib2 20" $ genFib1 20 + ] diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/GCD.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/GCD.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/GCD.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.GCD +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.GCD +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.GCD(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.GCD +import Data.SBV + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "Correctness" sgcdIsCorrect `using` runner proveWith + , runIO "CodeGen" genGCDInC + ] diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/PopulationCount.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/PopulationCount.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/PopulationCount.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.PopulationCount +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.PopulationCount +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.PopulationCount(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.PopulationCount +import Data.SBV + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "Correctness" fastPopCountIsCorrect `using` runner proveWith + , runIO "CodeGen" genPopCountInC + ] diff --git a/SBVBenchSuite/BenchSuite/CodeGeneration/Uninterpreted.hs b/SBVBenchSuite/BenchSuite/CodeGeneration/Uninterpreted.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/CodeGeneration/Uninterpreted.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.CodeGeneration.Uninterpreted +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.CodeGeneration.Uninterpreted +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.CodeGeneration.Uninterpreted(benchmarks) where + +import Documentation.SBV.Examples.CodeGeneration.Uninterpreted +import Data.SBV + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "Correctness" testLeft `using` runner proveWith + , runIO "CodeGen" genCCode + ] + where testLeft = \x y -> tstShiftLeft x y 0 .== x + y diff --git a/SBVBenchSuite/BenchSuite/Crypto/AES.hs b/SBVBenchSuite/BenchSuite/Crypto/AES.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Crypto/AES.hs @@ -0,0 +1,35 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Crypto.AES +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Crypto.AES +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Crypto.AES(benchmarks) where + +import Documentation.SBV.Examples.Crypto.AES +import Data.SBV + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "InverseGF" inverseGFPrf `using` runner proveWith + , run "Correctness.SBoxInverse" sboxInverseCorrect `using` runner proveWith + , runPure "t128Enc" (fmap hex8) t128Enc + , runPure "t128Dec" (fmap hex8) t128Dec + , runPure "t192Enc" (fmap hex8) t192Enc + , runPure "t192Dec" (fmap hex8) t192Dec + , runPure "t256Enc" (fmap hex8) t256Enc + , runPure "t256Dec" (fmap hex8) t256Dec + , runIO "CodeGen.AES128Lib" cgAES128Library + ] + where inverseGFPrf = \x -> x ./= 0 .=> x `gf28Mult` gf28Inverse x .== 1 diff --git a/SBVBenchSuite/BenchSuite/Crypto/RC4.hs b/SBVBenchSuite/BenchSuite/Crypto/RC4.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Crypto/RC4.hs @@ -0,0 +1,31 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Crypto.RC4 +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Crypto.RC4 +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Crypto.RC4(benchmarks) where + +import Documentation.SBV.Examples.Crypto.RC4 + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Correctness" rc4IsCorrect + , runPure "encrypt 1" (concatMap hex2) $ encrypt "Key" "Plaintext" + , runPure "encrypt 2" (concatMap hex2) $ encrypt "Wiki" "pedia" + , runPure "encrypt 3" (concatMap hex2) $ encrypt "Secret" "Attack at dawn" + , runPure "decrypt 1" (decrypt "Key") [0xbb, 0xf3, 0x16, 0xe8, 0xd9, 0x40, 0xaf, 0x0a, 0xd3] + , runPure "decrypt 2" (decrypt "Wiki") [0x10, 0x21, 0xbf, 0x04, 0x20] + , runPure "decrypt 3" (decrypt "Secret") [0x45, 0xa0, 0x1f, 0x64, 0x5f, 0xc3, 0x5b, 0x38, 0x35, 0x52, 0x54, 0x4b, 0x9b, 0xf5] + ] diff --git a/SBVBenchSuite/BenchSuite/Crypto/SHA.hs b/SBVBenchSuite/BenchSuite/Crypto/SHA.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Crypto/SHA.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Crypto.SHA +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Crypto.SHA +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Crypto.SHA(benchmarks) where + +import Documentation.SBV.Examples.Crypto.SHA + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "CodeGeneration" cgSHA256 + , runPure "knownTests 1" knownAnswerTests 1 + , runPure "knownTests 10" knownAnswerTests 10 + , runPure "knownTests 24" knownAnswerTests 24 + ] diff --git a/SBVBenchSuite/BenchSuite/Existentials/CRCPolynomial.hs b/SBVBenchSuite/BenchSuite/Existentials/CRCPolynomial.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Existentials/CRCPolynomial.hs @@ -0,0 +1,23 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Existentials.CRCPolynomial +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Existentials.CRCPolynomial +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Existentials.CRCPolynomial(benchmarks) where + +import Documentation.SBV.Examples.Existentials.CRCPolynomial + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "FindPolynomials" findHD4Polynomials diff --git a/SBVBenchSuite/BenchSuite/Existentials/Diophantine.hs b/SBVBenchSuite/BenchSuite/Existentials/Diophantine.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Existentials/Diophantine.hs @@ -0,0 +1,31 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Existentials.Diophantine +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Existentials.Diophantine +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Existentials.Diophantine(benchmarks) where + +import Documentation.SBV.Examples.Existentials.Diophantine +import Control.DeepSeq + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Test" test + , runIO "Sailors" sailors + ] + + + +instance NFData Solution where rnf x = seq x () diff --git a/SBVBenchSuite/BenchSuite/Lists/BoundedMutex.hs b/SBVBenchSuite/BenchSuite/Lists/BoundedMutex.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Lists/BoundedMutex.hs @@ -0,0 +1,30 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Lists.BoundedMutex +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Lists.BoundedMutex +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Lists.BoundedMutex(benchmarks) where + +import Documentation.SBV.Examples.Lists.BoundedMutex + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "CheckMutex.1" $ checkMutex 1 + , runIO "CheckMutex.10" $ checkMutex 10 + , runIO "CheckMutex.20" $ checkMutex 20 + , runIO "NotFair.1" $ notFair 1 + , runIO "NotFair.10" $ notFair 10 + , runIO "NotFair.20" $ notFair 20 + ] diff --git a/SBVBenchSuite/BenchSuite/Lists/Fibonacci.hs b/SBVBenchSuite/BenchSuite/Lists/Fibonacci.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Lists/Fibonacci.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Lists.Fibonacci +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Lists.Fibonacci +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Lists.Fibonacci(benchmarks) where + +import Documentation.SBV.Examples.Lists.Fibonacci +import Data.SBV + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "GenFibs" $ runSMT genFibs + ] diff --git a/SBVBenchSuite/BenchSuite/Lists/Nested.hs b/SBVBenchSuite/BenchSuite/Lists/Nested.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Lists/Nested.hs @@ -0,0 +1,25 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Lists.Nested +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Lists.Nested +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Lists.Nested(benchmarks) where + +import Documentation.SBV.Examples.Lists.Nested + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Nested.Example" nestedExample + ] diff --git a/SBVBenchSuite/BenchSuite/Misc/Auxiliary.hs b/SBVBenchSuite/BenchSuite/Misc/Auxiliary.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Auxiliary.hs @@ -0,0 +1,25 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Auxiliary +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Auxiliary +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.Auxiliary(benchmarks) where + +import Documentation.SBV.Examples.Misc.Auxiliary + +import BenchSuite.Bench.Bench as S +import Utils.SBVBenchFramework + + +-- benchmark suite +benchmarks :: Runner +benchmarks = S.run "Birthday" problem `using` runner allSatWith diff --git a/SBVBenchSuite/BenchSuite/Misc/Enumerate.hs b/SBVBenchSuite/BenchSuite/Misc/Enumerate.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Enumerate.hs @@ -0,0 +1,39 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Enumerate +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Enumerate +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Misc.Enumerate(benchmarks) where + +import Documentation.SBV.Examples.Misc.Enumerate + +import BenchSuite.Bench.Bench +import Utils.SBVBenchFramework + + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "Elts" _elts `using` runner allSatWith + , run "Four" _four + , run "MaxE" _maxE + , run "MinE" _minE + ] + where _elts = \(x::SE) -> x .== x + _four = \a b c (d::SE) -> distinct [a, b, c, d] + _maxE = do mx <- exists "maxE" + e <- forall "e" + return $ mx .>= (e::SE) + _minE = do mx <- exists "minE" + e <- forall "e" + return $ mx .<= (e::SE) diff --git a/SBVBenchSuite/BenchSuite/Misc/Floating.hs b/SBVBenchSuite/BenchSuite/Misc/Floating.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Floating.hs @@ -0,0 +1,61 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Floating +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Floating +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Misc.Floating(benchmarks) where + +import Documentation.SBV.Examples.Misc.Floating + +import BenchSuite.Bench.Bench +import Utils.SBVBenchFramework + + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ run "notAssoc" (assocPlus (0/0)) `using` runner proveWith + , run "AssocPlusReg" _assocPlusRegular `using` runner proveWith + , run "NonZeroAddition" _nonZeroAddition `using` runner proveWith + , run "MultInverse" _multInverse `using` runner proveWith + , run "RoundingAdd" _roundingAdd + ] + where _assocPlusRegular = do [x, y, z] <- sFloats ["x", "y", "z"] + let lhs = x+(y+z) + rhs = (x+y)+z + -- make sure we do not overflow at the intermediate points + constrain $ fpIsPoint lhs + constrain $ fpIsPoint rhs + return $ lhs .== rhs + + _nonZeroAddition = do [a, b] <- sFloats ["a", "b"] + constrain $ fpIsPoint a + constrain $ fpIsPoint b + constrain $ a + b .== a + return $ b .== 0 + + _multInverse = do a <- sFloat "a" + constrain $ fpIsPoint a + constrain $ fpIsPoint (1/a) + return $ a * (1/a) .== 1 + + _roundingAdd = do m :: SRoundingMode <- free "rm" + constrain $ m ./= literal RoundNearestTiesToEven + x <- sFloat "x" + y <- sFloat "y" + let lhs = fpAdd m x y + let rhs = x + y + constrain $ fpIsPoint lhs + constrain $ fpIsPoint rhs + return $ lhs ./= rhs diff --git a/SBVBenchSuite/BenchSuite/Misc/ModelExtract.hs b/SBVBenchSuite/BenchSuite/Misc/ModelExtract.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/ModelExtract.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.ModelExtract +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.ModelExtract +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.ModelExtract(benchmarks) where + +import Documentation.SBV.Examples.Misc.ModelExtract + +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "genVals" genVals diff --git a/SBVBenchSuite/BenchSuite/Misc/Newtypes.hs b/SBVBenchSuite/BenchSuite/Misc/Newtypes.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Newtypes.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Newtypes +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Newtypes +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.Newtypes(benchmarks) where + +import Documentation.SBV.Examples.Misc.Newtypes + +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "Problem" problem diff --git a/SBVBenchSuite/BenchSuite/Misc/NoDiv0.hs b/SBVBenchSuite/BenchSuite/Misc/NoDiv0.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/NoDiv0.hs @@ -0,0 +1,31 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.NoDiv0 +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.NoDiv0 +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Misc.NoDiv0(benchmarks) where + +import Documentation.SBV.Examples.Misc.NoDiv0 + +import Data.SBV +import Control.DeepSeq +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "test.1" test1 + , runIO "test.2" test2 + ] + +instance NFData SafeResult where rnf x = seq x () diff --git a/SBVBenchSuite/BenchSuite/Misc/Polynomials.hs b/SBVBenchSuite/BenchSuite/Misc/Polynomials.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Polynomials.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Polynomials +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Polynomials +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.Polynomials(benchmarks) where + +import Documentation.SBV.Examples.Misc.Polynomials + +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "testGF28 " testGF28 diff --git a/SBVBenchSuite/BenchSuite/Misc/SetAlgebra.hs b/SBVBenchSuite/BenchSuite/Misc/SetAlgebra.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/SetAlgebra.hs @@ -0,0 +1,131 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.SetAlgebra +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.SetAlgebra +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Misc.SetAlgebra(benchmarks) where + +import Data.SBV hiding (complement) +import Data.SBV.Set +import Documentation.SBV.Examples.Misc.SetAlgebra + +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup $ fmap (`using` _prove) + [ run "Commutivity.Union" commutivityCup + , run "Commutivity.Intersection" commutivityCap + , run "Associativity.Union" assocCup + , run "Associativity.Intersection" assocCap + , run "Distributivity.Union" distribCup + , run "Distributivity.Intersection" distribCap + , run "Identity.Union" identCup + , run "Identity.Intersection" identCap + , run "Complement.Union" compCup + , run "Complement.Intersection" compCap + , run "Complement.Empty" compEmpty + , run "Complement.Complement" compComp + , run "Complement.Full" compFull + , run "Complement.Unique" compUniq + , run "Idempotency.Cup" idempCup + , run "Idempotency.Cap" idempCap + , run "Domination.Cup" domCup + , run "Domination.Cap" domCap + , run "Absorption.Cup" absorbCup + , run "Absorption.Cap" absorbCap + , run "Intersection.Difference" intdiff + , run "DeMorgans.Cup" demorgCup + , run "DeMorgans.Cap" demorgCap + , run "InclusionIsPO" incPo + , run "SubsetEquality" subEq + , run "SubsetEquality.Transitivity" subEqTrans + , run "JoinMeet.1" joinMeet1 + , run "JoinMeet.2" joinMeet2 + , run "JoinMeet.3" joinMeet3 + , run "JoinMeet.4" joinMeet4 + , run "JoinMeet.5" joinMeet5 + , run "SubsetChar.Union" subsetCharCup + , run "SubsetChar.Intersection" subsetCharCap + , run "SubsetChar.Implication" subsetCharImpl + , run "SubsetChar.Complement" subsetCharComp + + , run "RelativeComplements.Union" relCompCup + , run "RelativeComplements.Intersection" relCompCap + , run "RelativeComplements.UnionInters" relCompCapCup + , run "RelativeComplements.InterInters.1" relCompCapCap + , run "RelativeComplements.InterInters.2" relCompCapCap2 + , run "RelativeComplements.UnionUnion" relCompCupCup + , run "RelativeComplements.Identity" relCompIdent + , run "RelativeComplements.UnitLeft" relCompUnitL + , run "RelativeComplements.UnitRight" relCompUnitR + , run "RelativeComplements.ComplementIdentity" relCompCompInt + , run "RelativeComplements.ComplementUnion" relCompCompUni + , run "RelativeComplements.CompComp" relCompComp + , run "RelativeComplements.CompFull" relCompFull + , run "DistributionSubset.Union" distSubset1 + , run "DistributionSubset.Intersection" distSubset2 + ] + where _prove = runner proveWith + commutivityCup = \(a :: SI) b -> a `union` b .== b `union` a + commutivityCap = \(a :: SI) b -> a `intersection` b .== b `intersection` a + assocCup = \(a :: SI) b c -> a `union` (b `union` c) .== (a `union` b) `union` c + assocCap = \(a :: SI) b c -> a `intersection` (b `intersection` c) .== (a `intersection` b) `intersection` c + distribCup = \(a :: SI) b c -> a `union` (b `intersection` c) .== (a `union` b) `intersection` (a `union` c) + distribCap = \(a :: SI) b c -> a `intersection` (b `union` c) .== (a `intersection` b) `union` (a `intersection` c) + identCup = \(a :: SI) -> a `union` empty .== a + identCap = \(a :: SI) -> a `intersection` full .== a + compCup = \(a :: SI) -> a `union` complement a .== full + compCap = \(a :: SI) -> a `intersection` complement a .== empty + compEmpty = complement (empty :: SI) .== full + compComp = \(a :: SI) -> complement (complement a) .== a + compFull = complement (full :: SI) .== empty + compUniq = \(a :: SI) b -> a `union` b .== full .&& a `intersection` b .== empty .<=> b .== complement a + idempCup = \(a :: SI) -> a `union` a .== a + idempCap = \(a :: SI) -> a `intersection` a .== a + domCup = \(a :: SI) -> a `union` full .== full + domCap = \(a :: SI) -> a `intersection` empty .== empty + absorbCup = \(a :: SI) b -> a `union` (a `intersection` b) .== a + absorbCap = \(a :: SI) b -> a `intersection` (a `union` b) .== a + intdiff = \(a :: SI) b -> a `intersection` b .== a `difference` (a `difference` b) + demorgCup = \(a :: SI) b -> complement (a `union` b) .== complement a `intersection` complement b + demorgCap = \(a :: SI) b -> complement (a `intersection` b) .== complement a `union` complement b + incPo = \(a :: SI) -> a `isSubsetOf` a + subEq = \(a :: SI) b -> a `isSubsetOf` b .&& b `isSubsetOf` a .<=> a .== b + subEqTrans = \(a :: SI) b c -> a `isSubsetOf` b .&& b `isSubsetOf` c .=> a `isSubsetOf` c + joinMeet1 = \(a :: SI) b -> a `isSubsetOf` (a `union` b) + joinMeet2 = \(a :: SI) b c -> a `isSubsetOf` c .&& b `isSubsetOf` c .=> (a `union` b) `isSubsetOf` c + joinMeet3 = \(a :: SI) b -> (a `intersection` b) `isSubsetOf` a + joinMeet4 = \(a :: SI) b -> (a `intersection` b) `isSubsetOf` b + joinMeet5 = \(a :: SI) b c -> c `isSubsetOf` a .&& c `isSubsetOf` b .=> c `isSubsetOf` (a `intersection` b) + subsetCharCup = \(a :: SI) b -> a `isSubsetOf` b .<=> a `union` b .== b + subsetCharCap = \(a :: SI) b -> a `isSubsetOf` b .<=> a `intersection` b .== a + subsetCharImpl = \(a :: SI) b -> a `isSubsetOf` b .<=> a `difference` b .== empty + subsetCharComp = \(a :: SI) b -> a `isSubsetOf` b .<=> complement b `isSubsetOf` complement a + relCompCup = \(a :: SI) b c -> c \\ (a `union` b) .== (c \\ a) `intersection` (c \\ b) + relCompCap = \(a :: SI) b c -> c \\ (a `intersection` b) .== (c \\ a) `union` (c \\ b) + relCompCapCup = \(a :: SI) b c -> c \\ (b \\ a) .== (a `intersection` c) `union` (c \\ b) + relCompCapCap = \(a :: SI) b c -> (b \\ a) `intersection` c .== (b `intersection` c) \\ a + relCompCapCap2 = \(a :: SI) b c -> (b \\ a) `intersection` c .== b `intersection` (c \\ a) + relCompCupCup = \(a :: SI) b c -> (b \\ a) `union` c .== (b `union` c) \\ (a \\ c) + relCompIdent = \(a :: SI) -> a \\ a .== empty + relCompUnitL = \(a :: SI) -> empty \\ a .== empty + relCompUnitR = \(a :: SI) -> empty \\ empty .== a + relCompCompInt = \(a :: SI) b -> b \\ a .== complement a `intersection` b + relCompCompUni = \(a :: SI) b -> complement (b \\ a) .== a `union` complement b + relCompComp = \(a :: SI) -> full \\ a .== complement a + relCompFull = \(a :: SI) -> a \\ full .== empty + distSubset1 = \(a :: SI) b c -> a `isSubsetOf` (b `union` c) .=> a `isSubsetOf` b .&& a `isSubsetOf` c + distSubset2 = \(a :: SI) b c -> (b `intersection` c) `isSubsetOf` a .=> b `isSubsetOf` a .&& c `isSubsetOf` a diff --git a/SBVBenchSuite/BenchSuite/Misc/SoftConstrain.hs b/SBVBenchSuite/BenchSuite/Misc/SoftConstrain.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/SoftConstrain.hs @@ -0,0 +1,37 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.SoftConstrain +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.SoftConstrain +----------------------------------------------------------------------------- + +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.SoftConstrain(benchmarks) where + +import Data.SBV +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "SoftConstrain" softC + where softC = do x <- sString "x" + y <- sString "y" + + constrain $ x .== "x-must-really-be-hello" + constrain $ y ./= "y-can-be-anything-but-hello" + + -- Now add soft-constraints to indicate our preference + -- for what these variables should be: + softConstrain $ x .== "default-x-value" + softConstrain $ y .== "default-y-value" + + return sTrue diff --git a/SBVBenchSuite/BenchSuite/Misc/Tuple.hs b/SBVBenchSuite/BenchSuite/Misc/Tuple.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Misc/Tuple.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Misc.Tuple +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Misc.Tuple +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Misc.Tuple(benchmarks) where + +import Documentation.SBV.Examples.Misc.Tuple + +import BenchSuite.Bench.Bench + + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "Tuple" example diff --git a/SBVBenchSuite/BenchSuite/Optimization/Enumerate.hs b/SBVBenchSuite/BenchSuite/Optimization/Enumerate.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/Enumerate.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.Enumerate +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Optimization.Enumerate +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Optimization.Enumerate(benchmarks) where + +import Documentation.SBV.Examples.Optimization.Enumerate +import BenchSuite.Bench.Bench as B + +import BenchSuite.Optimization.Instances() + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Enumerate.AlmostWeekend" almostWeekend + , runIO "Enumerate.WeekendJustOver" weekendJustOver + , runIO "Enumerate.firstWeekend" firstWeekend + ] diff --git a/SBVBenchSuite/BenchSuite/Optimization/ExtField.hs b/SBVBenchSuite/BenchSuite/Optimization/ExtField.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/ExtField.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.ExtField +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Optimization.ExtField +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Optimization.ExtField(benchmarks) where + +import Documentation.SBV.Examples.Optimization.ExtField +import BenchSuite.Bench.Bench as B +import BenchSuite.Optimization.Instances() + +import Data.SBV + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "ExtField.problem" problem `using` runner (flip optimizeWith Lexicographic) diff --git a/SBVBenchSuite/BenchSuite/Optimization/Instances.hs b/SBVBenchSuite/BenchSuite/Optimization/Instances.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/Instances.hs @@ -0,0 +1,23 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.Instance +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Helper file to provide common orphaned instances for Optimization benchmarks +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Optimization.Instances where + +import Data.SBV + +import Control.DeepSeq + + +-- | orphaned instance for benchmarks +instance NFData OptimizeResult where rnf x = seq x () diff --git a/SBVBenchSuite/BenchSuite/Optimization/LinearOpt.hs b/SBVBenchSuite/BenchSuite/Optimization/LinearOpt.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/LinearOpt.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.LinearOpt +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Optimization.LinearOpt +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Optimization.LinearOpt(benchmarks) where + +import Documentation.SBV.Examples.Optimization.LinearOpt +import BenchSuite.Bench.Bench as B +import BenchSuite.Optimization.Instances() + +import Data.SBV + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "LinearOpt.problem" problem `using` runner (flip optimizeWith Lexicographic) diff --git a/SBVBenchSuite/BenchSuite/Optimization/Production.hs b/SBVBenchSuite/BenchSuite/Optimization/Production.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/Production.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.Production +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Optimization.Production +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Optimization.Production(benchmarks) where + +import Documentation.SBV.Examples.Optimization.Production +import BenchSuite.Bench.Bench as B +import BenchSuite.Optimization.Instances() + +import Data.SBV + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "Production.production" production `using` runner (flip optimizeWith Lexicographic) diff --git a/SBVBenchSuite/BenchSuite/Optimization/VM.hs b/SBVBenchSuite/BenchSuite/Optimization/VM.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Optimization/VM.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Optimization.VM +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Optimization.VM +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Optimization.VM(benchmarks) where + +import Documentation.SBV.Examples.Optimization.VM +import BenchSuite.Bench.Bench as B +import BenchSuite.Optimization.Instances() + +import Data.SBV + + +-- benchmark suite +benchmarks :: Runner +benchmarks = run "VM.allocate" allocate `using` runner (flip optimizeWith Lexicographic) diff --git a/SBVBenchSuite/BenchSuite/Overhead/SBVOverhead.hs b/SBVBenchSuite/BenchSuite/Overhead/SBVOverhead.hs deleted file mode 100644 --- a/SBVBenchSuite/BenchSuite/Overhead/SBVOverhead.hs +++ /dev/null @@ -1,208 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : BenchSuite.Batch.SBVOverhead --- Copyright : (c) Jeffrey Young --- License : BSD3 --- Maintainer: erkokl@gmail.com --- Stability : experimental --- --- Assessing the overhead of calling solving examples via sbv vs individual solvers ------------------------------------------------------------------------------ - -{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE ExistentialQuantification #-} -{-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE GADTs #-} -{-# LANGUAGE RankNTypes #-} -{-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE ScopedTypeVariables #-} - -module BenchSuite.Overhead.SBVOverhead - ( runner - , runner' - , runnerWith - , rGroup - , mkOverheadBenchMark - , onConfig - , onDesc - , setRunner - , onProblem - , Runner(..) - , using - ) where - -import Control.DeepSeq (NFData (..), rwhnf) -import System.Directory (getCurrentDirectory) -import System.IO - -import Criterion.Main - -import qualified System.Process as P -import qualified Utils.SBVBenchFramework as U - --- | The type of the problem to benchmark. This allows us to operate on Runners --- as values themselves yet still have a unified interface with criterion. -data Problem = forall a . U.Provable a => Problem a - --- | Similarly to Problem, BenchResult is boilerplate for a nice api -data BenchResult = forall a . (Show a, NFData a) => BenchResult a - --- | A bench unit is a solver and a problem that represents an input problem --- for the solver to solve -type BenchUnit = (U.SMTConfig, FilePath) - --- | A runner is anything that allows the solver to solve, such as: --- 'Data.SBV.proveWith' or 'Data.SBV.satWith'. We utilize existential types to --- lose type information and create a unified interface with criterion. We --- require a runner in order to generate a 'Data.SBV.transcript' and then to run --- the actual benchmark. We bundle this redundantly into a record so that the --- benchmarks can be defined in each respective module, with the run function --- that makes sense for that problem, and then redefined in 'SBVBench'. This is --- useful because problems that require 'Data.SBV.allSatWith' can lead to a lot --- of variance in the benchmarking data. Single benchmark runners like --- 'Data.SBV.satWith' and 'Data.SBV.proveWith' work best. -data RunnerI = RunnerI { run :: (U.SMTConfig -> Problem -> IO BenchResult) - , config :: U.SMTConfig - , description :: String - , problem :: Problem -} - --- | GADT to allow arbritrary nesting of runners. This copies criterion's design --- so that we don't have to separate out runners that run a single benchmark --- from runners that need to run several benchmarks -data Runner where - Runner :: RunnerI -> Runner -- ^ a single run - RunnerGroup :: [Runner] -> Runner -- ^ a group of runs - --- | Convenience boilerplate functions, simply avoiding a lens dependency -using :: Runner -> (Runner -> Runner) -> Runner -using = flip ($) - -setRunner :: (Show c, NFData c) => - (forall a. U.Provable a => U.SMTConfig -> a -> IO c) -> Runner -> Runner -setRunner r' (Runner r@RunnerI{..}) = Runner $ r{run = toRun r'} -setRunner r' (RunnerGroup rs) = RunnerGroup $ setRunner r' <$> rs - -toRun :: (Show c, NFData c) => - (forall a. U.Provable a => U.SMTConfig -> a -> IO c) - -> U.SMTConfig - -> Problem - -> IO BenchResult -toRun f c p = BenchResult <$> helper p - -- simpler to helper in onProblem, this is lmap from profunctor land, i.e., we - -- curry with a config, then change the runner function from (a -> IO c), to - -- (Problem -> IO c) - where helper (Problem a) = f c a - -onConfig :: (U.SMTConfig -> U.SMTConfig) -> RunnerI -> RunnerI -onConfig f r@RunnerI{..} = r{config = f config} - -onDesc :: (String -> String) -> RunnerI -> RunnerI -onDesc f r@RunnerI{..} = r{description = f description} - -onProblem :: (forall a. a -> a) -> RunnerI -> RunnerI -onProblem f r@RunnerI{..} = r{problem = (helper problem)} - where - -- helper function to avoid profunctor dependency, this is simply fmap, or - -- rmap for profunctor land - helper :: Problem -> Problem - helper (Problem p) = Problem $ f p - - --- | Filepath to /dev/null -devNull :: FilePath -#ifndef WINDOWS -devNull = "/dev/null" -#else -devNull = "NUL" -#endif - --- | to bench a solver without interfacing through SBV we call transcript to --- have SBV generate the input file for the solver and then create a process to --- initiate execution on the solver. Note that we redirect stdout to /dev/devNull --- or NUL on windows -runStandaloneSolver :: BenchUnit -> IO () -runStandaloneSolver (slvr, fname) = - withFile devNull WriteMode $ - (\h -> do (_,_,_,ph) <- P.createProcess (P.shell command){P.std_out = P.UseHandle h} - _ <- P.waitForProcess ph - return ()) - where command = U.mkExecString slvr fname - --- | Given a file name, a solver config, and a problem to solve, create an --- environment for the criterion benchmark by generating a transcript file -standaloneEnv :: RunnerI -> IO FilePath -> IO BenchUnit -standaloneEnv RunnerI{..} f = f >>= go problem - where - -- generate a transcript for the unit - go p file = do pwd <- getCurrentDirectory - let fPath = mconcat [pwd,"/",file] - _ <- run config{U.transcript = Just fPath} p >> return () - return (config,fPath) - --- | Cleanup the environment created by criterion by removing the transcript --- file used to run the standalone solver -standaloneCleanup :: BenchUnit -> IO () -standaloneCleanup (_,fPath) = P.callCommand $ "rm " ++ fPath - --- | To construct a benchmark to test SBV's overhead we setup an environment --- with criterion where a symbolic computation is emitted to a transcript file. --- To test the solver without respect to SBV (standalone) we pass the transcript --- file to the solver using the same primitives SBV does. Not that mkFileName --- generates a random filename that is removed at the end of the benchmark. This --- function exposes the solver and the solve interface in case the user would --- like to benchmark with something other than 'Data.SBV.z3' and so that we can --- benchmark all solving variants, e.g., 'Data.SBV.proveWith', --- 'Data.SBV.satWith', 'Data.SBV.allProveWith' etc. -mkOverheadBenchMark' :: RunnerI -> Benchmark -mkOverheadBenchMark' r@RunnerI{..} = - envWithCleanup - (standaloneEnv r U.mkFileName) - standaloneCleanup $ - \ ~unit -> - bgroup description [ bench "standalone" $ nfIO $ runStandaloneSolver unit - -- notice for sbv benchmark; we pull the solver out of unit and - -- use the input problem not the transcript in the unit - , bench "sbv" $ nfIO $ run (fst unit) problem - ] - -mkOverheadBenchMark :: Runner -> Benchmark -mkOverheadBenchMark (Runner r@RunnerI{..}) = mkOverheadBenchMark' r -mkOverheadBenchMark (RunnerGroup rs) = bgroup "" $ -- leave the description close to the benchmark/problem definition - mkOverheadBenchMark <$> rs - --- | This is just a wrapper around the RunnerI constructor and serves as the main --- entry point to make a runner for a user in case they need something custom. -runner' :: (NFData b, Show b) => - (forall a. U.Provable a => U.SMTConfig -> a -> IO b) - -> U.SMTConfig - -> String - -> Problem - -> Runner -runner' r config description problem = Runner $ RunnerI{..} - where run = toRun r - --- | Convenience function for creating benchmarks that exposes a configuration -runnerWith :: U.Provable a => U.SMTConfig -> String -> a -> Runner -runnerWith c d p = runner' U.satWith c d (Problem p) - --- | Main entry point for simple benchmarks. See 'mkRunner'' or 'mkRunnerWith' --- for versions of this function that allows custom inputs. If you have some use --- case that is not considered then you can simply overload the record fields. -runner :: U.Provable a => String -> a -> Runner -runner d p = runnerWith U.z3 d p `using` setRunner U.satWith - --- | create a runner group. Useful for benchmarks that need to run several --- benchmarks. See 'BenchSuite.Puzzles.NQueens' for an example. -rGroup :: [Runner] -> Runner -rGroup = RunnerGroup - --- | Orphaned instances just for benchmarking -instance NFData U.AllSatResult where - rnf (U.AllSatResult (a, b, c, results)) = - rnf a `seq` rnf b `seq` rnf c `seq` rwhnf results - --- | Unwrap the existential type to make criterion happy -instance NFData BenchResult where rnf (BenchResult a) = rnf a diff --git a/SBVBenchSuite/BenchSuite/ProofTools/BMC.hs b/SBVBenchSuite/BenchSuite/ProofTools/BMC.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/ProofTools/BMC.hs @@ -0,0 +1,30 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.ProofTools.BMC +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.ProofTools.BMC +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.ProofTools.BMC(benchmarks) where + +import Control.DeepSeq +import Documentation.SBV.Examples.ProofTools.BMC + +import BenchSuite.Bench.Bench as B + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "ex1" ex1 + , runIO "ex2" ex2 + ] + + +instance NFData a => NFData (S a) where rnf a = seq a () diff --git a/SBVBenchSuite/BenchSuite/ProofTools/Fibonacci.hs b/SBVBenchSuite/BenchSuite/ProofTools/Fibonacci.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/ProofTools/Fibonacci.hs @@ -0,0 +1,30 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.ProofTools.Fibonacci +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.ProofTools.Fibonacci +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.ProofTools.Fibonacci(benchmarks) where + +import Control.DeepSeq + +import Data.SBV.Tools.Induction +import Documentation.SBV.Examples.ProofTools.Fibonacci + +import BenchSuite.Bench.Bench as B + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "Correctness" fibCorrect + + +instance NFData a => NFData (S a) where rnf a = seq a () +instance NFData a => NFData (InductionResult a) where rnf a = seq a () diff --git a/SBVBenchSuite/BenchSuite/ProofTools/Strengthen.hs b/SBVBenchSuite/BenchSuite/ProofTools/Strengthen.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/ProofTools/Strengthen.hs @@ -0,0 +1,36 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.ProofTools.Strengthen +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.ProofTools.Strengthen +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.ProofTools.Strengthen(benchmarks) where + +import Control.DeepSeq + +import Data.SBV.Tools.Induction +import Documentation.SBV.Examples.ProofTools.Strengthen + +import BenchSuite.Bench.Bench as B + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "ex1" ex1 + , runIO "ex2" ex2 + , runIO "ex3" ex3 + , runIO "ex4" ex4 + , runIO "ex5" ex5 + , runIO "ex6" ex6 + ] + +instance NFData a => NFData (S a) where rnf a = seq a () +instance NFData a => NFData (InductionResult a) where rnf a = seq a () diff --git a/SBVBenchSuite/BenchSuite/ProofTools/Sum.hs b/SBVBenchSuite/BenchSuite/ProofTools/Sum.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/ProofTools/Sum.hs @@ -0,0 +1,29 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.ProofTools.Sum +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.ProofTools.Sum +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.ProofTools.Sum(benchmarks) where + +import Control.DeepSeq + +import Data.SBV.Tools.Induction +import Documentation.SBV.Examples.ProofTools.Sum + +import BenchSuite.Bench.Bench as B + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "Correctness" sumCorrect + +instance NFData a => NFData (S a) +instance NFData a => NFData (InductionResult a) where rnf a = seq a () diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Birthday.hs b/SBVBenchSuite/BenchSuite/Puzzles/Birthday.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Birthday.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Birthday.hs @@ -16,10 +16,10 @@ import Documentation.SBV.Examples.Puzzles.Birthday +import BenchSuite.Bench.Bench as S import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead -- benchmark suite benchmarks :: Runner -benchmarks = runner "Birthday" puzzle `using` setRunner allSatWith +benchmarks = S.run "Birthday" puzzle `using` runner allSatWith diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Coins.hs b/SBVBenchSuite/BenchSuite/Puzzles/Coins.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Coins.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Coins.hs @@ -17,12 +17,12 @@ import Documentation.SBV.Examples.Puzzles.Coins import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "Coins" coinsPgm +benchmarks = S.run "Coins" coinsPgm where coinsPgm = do cs <- mapM mkCoin [1..6] mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]] constrain $ sAnd $ zipWith (.>=) cs (tail cs) diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Counts.hs b/SBVBenchSuite/BenchSuite/Puzzles/Counts.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Counts.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Counts.hs @@ -17,11 +17,11 @@ import Documentation.SBV.Examples.Puzzles.Counts import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "Counts" countPgm `using` setRunner allSatWith +benchmarks = S.run "Counts" countPgm `using` runner allSatWith where countPgm = forAll_ puzzle' >>= return -- avoiding 'output' here again puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9] diff --git a/SBVBenchSuite/BenchSuite/Puzzles/DogCatMouse.hs b/SBVBenchSuite/BenchSuite/Puzzles/DogCatMouse.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/DogCatMouse.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/DogCatMouse.hs @@ -15,12 +15,12 @@ module BenchSuite.Puzzles.DogCatMouse(benchmarks) where import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "DogCatMouse" p `using` setRunner allSatWith +benchmarks = S.run "DogCatMouse" p `using` runner allSatWith where p = do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"] solve [ dog .>= 1 -- at least one dog , cat .>= 1 -- at least one cat diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Euler185.hs b/SBVBenchSuite/BenchSuite/Puzzles/Euler185.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Euler185.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Euler185.hs @@ -17,9 +17,9 @@ import Documentation.SBV.Examples.Puzzles.Euler185 import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "Euler185" euler185 `using` setRunner allSatWith +benchmarks = S.run "Euler185" euler185 `using` runner allSatWith diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Garden.hs b/SBVBenchSuite/BenchSuite/Puzzles/Garden.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Garden.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Garden.hs @@ -19,10 +19,10 @@ import Documentation.SBV.Examples.Puzzles.Garden import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite -benchmarks :: Runner -benchmarks = runnerWith s "Garden" puzzle `using` setRunner allSatWith +benchmarks :: Runner +benchmarks = S.runWith s "Garden" puzzle `using` runner allSatWith where s = z3{satTrackUFs = False, isNonModelVar = ("_modelIgnore" `isSuffixOf`)} diff --git a/SBVBenchSuite/BenchSuite/Puzzles/LadyAndTigers.hs b/SBVBenchSuite/BenchSuite/Puzzles/LadyAndTigers.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/LadyAndTigers.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/LadyAndTigers.hs @@ -16,12 +16,12 @@ import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "Puzzles.LadyAndTigers" p `using` setRunner allSatWith +benchmarks = S.run "Puzzles.LadyAndTigers" p `using` runner allSatWith where p = do -- One boolean for each of the correctness of the signs diff --git a/SBVBenchSuite/BenchSuite/Puzzles/MagicSquare.hs b/SBVBenchSuite/BenchSuite/Puzzles/MagicSquare.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/MagicSquare.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/MagicSquare.hs @@ -17,14 +17,14 @@ import Documentation.SBV.Examples.Puzzles.MagicSquare import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner benchmarks = rGroup - [ runner "MagicSquare.magic 2" (mkMagic 2) `using` setRunner allSatWith - , runner "MagicSquare.magic 3" (mkMagic 3) `using` setRunner allSatWith + [ S.run "MagicSquare.magic 2" (mkMagic 2) `using` runner allSatWith + , S.run "MagicSquare.magic 3" (mkMagic 3) `using` runner allSatWith ] mkMagic :: Int -> Symbolic SBool diff --git a/SBVBenchSuite/BenchSuite/Puzzles/NQueens.hs b/SBVBenchSuite/BenchSuite/Puzzles/NQueens.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/NQueens.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/NQueens.hs @@ -17,20 +17,20 @@ import Documentation.SBV.Examples.Puzzles.NQueens import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner benchmarks = rGroup - [ runner "NQueens.NQueens 1" (mkQueens 1) `using` setRunner allSatWith - , runner "NQueens.NQueens 2" (mkQueens 2) `using` setRunner allSatWith - , runner "NQueens.NQueens 3" (mkQueens 3) `using` setRunner allSatWith - , runner "NQueens.NQueens 4" (mkQueens 4) `using` setRunner allSatWith - , runner "NQueens.NQueens 5" (mkQueens 5) `using` setRunner allSatWith - , runner "NQueens.NQueens 6" (mkQueens 6) `using` setRunner allSatWith - , runner "NQueens.NQueens 7" (mkQueens 7) `using` setRunner allSatWith - , runner "NQueens.NQueens 8" (mkQueens 8) `using` setRunner allSatWith + [ S.run "NQueens.NQueens 1" (mkQueens 1) `using` runner allSatWith + , S.run "NQueens.NQueens 2" (mkQueens 2) `using` runner allSatWith + , S.run "NQueens.NQueens 3" (mkQueens 3) `using` runner allSatWith + , S.run "NQueens.NQueens 4" (mkQueens 4) `using` runner allSatWith + , S.run "NQueens.NQueens 5" (mkQueens 5) `using` runner allSatWith + , S.run "NQueens.NQueens 6" (mkQueens 6) `using` runner allSatWith + , S.run "NQueens.NQueens 7" (mkQueens 7) `using` runner allSatWith + , S.run "NQueens.NQueens 8" (mkQueens 8) `using` runner allSatWith ] mkQueens :: Int -> Symbolic SBool diff --git a/SBVBenchSuite/BenchSuite/Puzzles/SendMoreMoney.hs b/SBVBenchSuite/BenchSuite/Puzzles/SendMoreMoney.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/SendMoreMoney.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/SendMoreMoney.hs @@ -16,12 +16,12 @@ import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner -benchmarks = runner "Puzzles.SendMoreMoney" p `using` setRunner allSatWith +benchmarks = S.run "Puzzles.SendMoreMoney" p `using` runner allSatWith where p = do ds@[s,e,n,d,m,o,r,y] <- mapM sInteger ["s", "e", "n", "d", "m", "o", "r", "y"] let isDigit x = x .>= 0 .&& x .<= 9 diff --git a/SBVBenchSuite/BenchSuite/Puzzles/Sudoku.hs b/SBVBenchSuite/BenchSuite/Puzzles/Sudoku.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/Sudoku.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/Sudoku.hs @@ -17,13 +17,13 @@ import Documentation.SBV.Examples.Puzzles.Sudoku import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner benchmarks = rGroup - [ runner ("sudoku " ++ show n) (checkPuzzle s) `using` setRunner allSatWith + [ S.run ("sudoku " ++ show n) (checkPuzzle s) `using` runner allSatWith | (n, s) <- zip [(0::Int)..] diff --git a/SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs b/SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs --- a/SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs +++ b/SBVBenchSuite/BenchSuite/Puzzles/U2Bridge.hs @@ -17,17 +17,17 @@ import Documentation.SBV.Examples.Puzzles.U2Bridge import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench as S -- benchmark suite benchmarks :: Runner benchmarks = rGroup - [ runner "U2Bridge_cnt1" (count 1) `using` setRunner allSatWith - , runner "U2Bridge_cnt2" (count 2) `using` setRunner allSatWith - , runner "U2Bridge_cnt3" (count 3) `using` setRunner allSatWith - , runner "U2Bridge_cnt4" (count 4) `using` setRunner allSatWith - , runner "U2Bridge_cnt6" (count 6) `using` setRunner allSatWith + [ S.run "U2Bridge_cnt1" (count 1) `using` runner allSatWith + , S.run "U2Bridge_cnt2" (count 2) `using` runner allSatWith + , S.run "U2Bridge_cnt3" (count 3) `using` runner allSatWith + , S.run "U2Bridge_cnt4" (count 4) `using` runner allSatWith + , S.run "U2Bridge_cnt6" (count 6) `using` runner allSatWith ] where act = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2) diff --git a/SBVBenchSuite/BenchSuite/Queries/AllSat.hs b/SBVBenchSuite/BenchSuite/Queries/AllSat.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/AllSat.hs @@ -0,0 +1,22 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.AllSat +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.AllSat +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.AllSat(benchmarks) where + +import Documentation.SBV.Examples.Queries.AllSat + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = runIO "AllSat" demo diff --git a/SBVBenchSuite/BenchSuite/Queries/CaseSplit.hs b/SBVBenchSuite/BenchSuite/Queries/CaseSplit.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/CaseSplit.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.CaseSplit +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.CaseSplit +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.CaseSplit(benchmarks) where + +import Documentation.SBV.Examples.Queries.CaseSplit + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup [ runIO "CaseSplit.1" csDemo1 + , runIO "CaseSplit.2" csDemo2 + ] diff --git a/SBVBenchSuite/BenchSuite/Queries/Concurrency.hs b/SBVBenchSuite/BenchSuite/Queries/Concurrency.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/Concurrency.hs @@ -0,0 +1,26 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.Concurrency +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.Concurrency +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.Concurrency(benchmarks) where + +import Documentation.SBV.Examples.Queries.Concurrency + +import BenchSuite.Bench.Bench + +-- these benchmarks won't run in multithreaded mode. The benchmark target is not +-- build as -threaded +benchmarks :: Runner +benchmarks = rGroup [ runIO "Concurrency.demo" demo + , runIO "Concurrency.demoDependent" demoDependent + ] diff --git a/SBVBenchSuite/BenchSuite/Queries/Enums.hs b/SBVBenchSuite/BenchSuite/Queries/Enums.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/Enums.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.Enums +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.Enums +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Queries.Enums(benchmarks) where + +import Documentation.SBV.Examples.Queries.Enums + +import Control.DeepSeq +import BenchSuite.Bench.Bench + +-- | orphaned instance for benchmarks +instance NFData Day where rnf x = seq x () + +benchmarks :: Runner +benchmarks = rGroup [ runIO "Enums.findDays" findDays + ] diff --git a/SBVBenchSuite/BenchSuite/Queries/FourFours.hs b/SBVBenchSuite/BenchSuite/Queries/FourFours.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/FourFours.hs @@ -0,0 +1,22 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.FourFours +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.FourFours +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.FourFours(benchmarks) where + +import Documentation.SBV.Examples.Queries.FourFours + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = runIO "FourFours.puzzle" puzzle diff --git a/SBVBenchSuite/BenchSuite/Queries/GuessNumber.hs b/SBVBenchSuite/BenchSuite/Queries/GuessNumber.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/GuessNumber.hs @@ -0,0 +1,22 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.GuessNumber +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.GuessNumber +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Queries.GuessNumber(benchmarks) where + +import Documentation.SBV.Examples.Queries.GuessNumber + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = runIO "GuessNumber.play" play diff --git a/SBVBenchSuite/BenchSuite/Queries/Interpolants.hs b/SBVBenchSuite/BenchSuite/Queries/Interpolants.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/Interpolants.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.Interpolants +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.Interpolants +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.Interpolants(benchmarks) where + +import Documentation.SBV.Examples.Queries.Interpolants + +import BenchSuite.Bench.Bench + +import Data.SBV + +benchmarks :: Runner +benchmarks = runIO "Interpolants.evenOdd" $ runSMT evenOdd diff --git a/SBVBenchSuite/BenchSuite/Queries/UnsatCore.hs b/SBVBenchSuite/BenchSuite/Queries/UnsatCore.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Queries/UnsatCore.hs @@ -0,0 +1,22 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Queries.UnsatCore +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Queries.UnsatCore +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Queries.UnsatCore(benchmarks) where + +import Documentation.SBV.Examples.Queries.UnsatCore + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = runIO "UnsatCore.ucCore" ucCore diff --git a/SBVBenchSuite/BenchSuite/Strings/RegexCrossword.hs b/SBVBenchSuite/BenchSuite/Strings/RegexCrossword.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Strings/RegexCrossword.hs @@ -0,0 +1,27 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Strings.RegexCrossword +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Strings.RegexCrossword +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Strings.RegexCrossword(benchmarks) where + +import Documentation.SBV.Examples.Strings.RegexCrossword + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "puzzle1" $ puzzle1 + , runIO "puzzle2" $ puzzle2 + , runIO "puzzle3" $ puzzle3 + ] diff --git a/SBVBenchSuite/BenchSuite/Strings/SQLInjection.hs b/SBVBenchSuite/BenchSuite/Strings/SQLInjection.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Strings/SQLInjection.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Strings.SQLInjection +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Strings.SQLInjection +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Strings.SQLInjection(benchmarks) where + +import Documentation.SBV.Examples.Strings.SQLInjection +import Data.List + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = runIO "FindInjection" $ ("'; DROP TABLE 'users" `Data.List.isSuffixOf`) <$> findInjection exampleProgram diff --git a/SBVBenchSuite/BenchSuite/Transformers/SymbolicEval.hs b/SBVBenchSuite/BenchSuite/Transformers/SymbolicEval.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Transformers/SymbolicEval.hs @@ -0,0 +1,30 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Transformers.SymbolicEval +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Transformers.SymbolicEval +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.Transformers.SymbolicEval(benchmarks) where + +import Documentation.SBV.Examples.Transformers.SymbolicEval +import Control.DeepSeq + +import BenchSuite.Bench.Bench + +-- benchmark suite +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Example.1" ex1 + , runIO "Example.2" ex2 + , runIO "Example.3" ex3 + ] + +instance NFData CheckResult where rnf x = seq x () diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/AUF.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/AUF.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/AUF.hs @@ -0,0 +1,35 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.AUF +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.AUF +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Uninterpreted.AUF(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.AUF +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "SArray" array `using` runner proveWith + , run "SFunArray" funArray `using` runner proveWith + ] + where array = do x <- free "x" + y <- free "y" + a :: SArray Word32 Word32 <- newArray_ Nothing + return $ thm x y a + funArray = do x <- free "x" + y <- free "y" + a :: SFunArray Word32 Word32 <- newArray_ Nothing + return $ thm x y a diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/Deduce.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/Deduce.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/Deduce.hs @@ -0,0 +1,35 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.Deduce +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Deduce +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Uninterpreted.Deduce(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.Deduce +import Data.SBV + +import Prelude hiding (not, or, and) +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "test" t `using` runner proveWith + ] + where t = do addAxiom "OR distributes over AND" ax1 + addAxiom "de Morgan" ax2 + addAxiom "double negation" ax3 + p <- free "p" + q <- free "q" + r <- free "r" + return $ not (p `or` (q `and` r)) + .== (not p `and` not q) `or` (not p `and` not r) diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/Function.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/Function.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/Function.hs @@ -0,0 +1,25 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.Function +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Function +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Uninterpreted.Function(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.Function +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "thmGood" thmGood `using` runner proveWith + ] diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/Multiply.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/Multiply.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/Multiply.hs @@ -0,0 +1,38 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.Multiply +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Multiply +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Uninterpreted.Multiply(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.Multiply +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "synthMul22" synthMul22 `using` runner satWith + , run "Correctness" correct `using` runner proveWith + ] + where + mul22_hi :: SBool -> SBool -> SBool -> SBool -> SBool + mul22_hi a1 a0 b1 b0 = ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sFalse]) sTrue + $ ite ([a1, a0, b1, b0] .== [sFalse, sTrue , sTrue , sTrue ]) sTrue + $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sFalse, sTrue ]) sTrue + $ ite ([a1, a0, b1, b0] .== [sTrue , sFalse, sTrue , sTrue ]) sTrue + $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sFalse, sTrue ]) sTrue + $ ite ([a1, a0, b1, b0] .== [sTrue , sTrue , sTrue , sFalse]) sTrue + sFalse + + correct = \a1 a0 b1 b0 -> mul22_hi a1 a0 b1 b0 .== (a1 .&& b0) .<+> (a0 .&& b1) diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/Shannon.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/Shannon.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/Shannon.hs @@ -0,0 +1,43 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.Shannon +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Shannon +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} +{-# LANGUAGE ScopedTypeVariables #-} + +module BenchSuite.Uninterpreted.Shannon(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.Shannon +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "shannon" _shannon `using` runner proveWith + , run "shannon2" _shannon2 `using` runner proveWith + , run "noWiggle" _noWiggle `using` runner proveWith + , run "univOk" _univOK `using` runner proveWith + , run "existsOk" _existsOK `using` runner proveWith + ] + where _shannon = \x y z -> f x y z .== (x .&& pos f y z .|| sNot x .&& neg f y z) + _shannon2 = \x y z -> f x y z .== ((x .|| neg f y z) .&& (sNot x .|| pos f y z)) + _noWiggle = \y z -> sNot (f' y z) .<=> pos f y z .== neg f y z + _univOK = \y z -> f'' y z .=> pos f y z .&& neg f y z + _existsOK = \y z -> f''' y z .=> pos f y z .|| neg f y z + + +f :: Ternary +f = uninterpret "f" +f', f'', f''' :: Binary +f' = derivative f +f'' = universal f +f''' = existential f diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/Sort.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/Sort.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/Sort.hs @@ -0,0 +1,32 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.Sort +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.Sort +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Uninterpreted.Sort(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.Sort +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = rGroup + [ run "t1" _t1 `using` runner satWith + , run "r2" _t1 `using` runner satWith + ] + where _t1 = do x <- free "x" + return $ f x ./= x + + _t2 = do x <- free "x" + addAxiom "Q" ["(assert (forall ((x Q) (y Q)) (= x y)))"] + return $ f x ./= x diff --git a/SBVBenchSuite/BenchSuite/Uninterpreted/UISortAllSat.hs b/SBVBenchSuite/BenchSuite/Uninterpreted/UISortAllSat.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/Uninterpreted/UISortAllSat.hs @@ -0,0 +1,23 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.Uninterpreted.UISortAllSat +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.Uninterpreted.UISortAllSat +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module BenchSuite.Uninterpreted.UISortAllSat(benchmarks) where + +import Documentation.SBV.Examples.Uninterpreted.UISortAllSat +import Data.SBV + +import BenchSuite.Bench.Bench + +benchmarks :: Runner +benchmarks = run "genLs" genLs `using` runner allSatWith -- could be expensive diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Append.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Append.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Append.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Append +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Append +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.WeakestPreconditions.Append(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.Append + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + + +-- | orphaned instance for benchmarks +instance NFData a => NFData (AppC a) where rnf x = seq x () + +benchmarks :: Runner +benchmarks = runIO "Correctness.Append" correctness diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Basics.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Basics.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Basics.hs @@ -0,0 +1,38 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Basics +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Basics +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.Basics(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.Basics +import Data.SBV +import Data.SBV.Tools.WeakestPreconditions + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (IncS a) + + +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Correctness.Basics skip" (correctness Skip Skip) + , runIO "Correctness.Basics y+1" (correctness Skip $ Assign $ \st@IncS{y} -> st{y = y+1}) + , runIO "Correctness.Basics x>0" $ correctness (assert "x > 0" (\st@IncS{x} -> x .> 0)) Skip + , runIO "Correctness.Basics x>-5" $ correctness (assert "x > -5" (\st@IncS{x} -> x .> -5)) Skip + , runIO "Correctness.Basics y is even" $ correctness Skip (assert "y is even" (\st@IncS{y} -> y `sMod` 2 .== 0)) + , runIO "Correctness.Basics y > x" $ correctness Skip (assert "y > x" (\st@IncS{x, y} -> y .> x)) + , runIO "Correctness.Basics skip-assign" $ correctness Skip (Assign $ \st -> st{x = 10, y = 11}) + ] diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Fib.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Fib.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Fib.hs @@ -0,0 +1,32 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Fig +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Fig +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.Fib(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.Fib +import Data.SBV.Tools.WeakestPreconditions + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (FibS a) + + +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Correctness.Fib" correctness + , runIO "ImperativeFib" $ traceExecution imperativeFib $ FibS {n = 3, i = 0, k = 0, m = 0} + ] diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/GCD.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/GCD.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/GCD.hs @@ -0,0 +1,32 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.GCD +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.GCD +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.GCD(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.GCD +import Data.SBV.Tools.WeakestPreconditions + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (GCDS a) + + +benchmarks :: Runner +benchmarks = rGroup + [ runIO "Correctness.GCD" correctness + , runIO "ImperativeGCD" $ traceExecution imperativeGCD $ GCDS {x = 14, y = 4, i = 0, j = 0} + ] diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Instances.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Instances.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Instances.hs @@ -0,0 +1,24 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Instance +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Helper file to provide common orphaned instances for WeakestPrecondition benchmarks +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} + +module BenchSuite.WeakestPreconditions.Instances where + +import Data.SBV.Tools.WeakestPreconditions + +import Control.DeepSeq + + +-- | orphaned instance for benchmarks +instance NFData a => NFData (ProofResult a) where rnf x = seq x () +instance NFData a => NFData (Status a) where rnf x = seq x () diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntDiv.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntDiv.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntDiv.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.IntDiv +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.IntDiv +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.IntDiv(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.IntDiv + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (DivS a) + + +benchmarks :: Runner +benchmarks = runIO "Correctness.IntDiv" correctness diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntSqrt.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntSqrt.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/IntSqrt.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.IntSqrt +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.IntSqrt +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.IntSqrt(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.IntSqrt + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (SqrtS a) + + +benchmarks :: Runner +benchmarks = runIO "Correctness.IntSqrt" correctness diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Length.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Length.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Length.hs @@ -0,0 +1,28 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Length +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Length +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.Length(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.Length + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (LenS a) + + +benchmarks :: Runner +benchmarks = runIO "Correctness.Length" correctness diff --git a/SBVBenchSuite/BenchSuite/WeakestPreconditions/Sum.hs b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Sum.hs new file mode 100644 --- /dev/null +++ b/SBVBenchSuite/BenchSuite/WeakestPreconditions/Sum.hs @@ -0,0 +1,45 @@ +----------------------------------------------------------------------------- +-- | +-- Module : BenchSuite.WeakestPreconditions.Sum +-- Copyright : (c) Jeffrey Young +-- Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bench suite for Documentation.SBV.Examples.WeakestPreconditions.Sum +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror -fno-warn-orphans #-} +{-# LANGUAGE NamedFieldPuns #-} + +module BenchSuite.WeakestPreconditions.Sum(benchmarks) where + +import Documentation.SBV.Examples.WeakestPreconditions.Sum +import Data.SBV + +import Control.DeepSeq +import BenchSuite.Bench.Bench +import BenchSuite.WeakestPreconditions.Instances() + +instance NFData a => NFData (SumS a) + + +benchmarks :: Runner +benchmarks = rGroup [ runIO "Correctness.Sum.correctInvariant" $ correctness correctInvariant (Just measure) + , runIO "Correctness.Sum.alwaysFalseInvariant" $ correctness alwaysFalseInvariant Nothing + , runIO "Correctness.Sum.alwaysTrueInvariant" $ correctness alwaysTrueInvariant Nothing + , runIO "Correctness.Sum.loopInvariant" $ correctness loopInvariant Nothing + , runIO "Correctness.Sum.badMeasure1" $ correctness badMeasure1Invariant (Just badMeasure1) + , runIO "Correctness.Sum.badMeasure2" $ correctness badMeasure2Invariant (Just badMeasure2) + ] + where + correctInvariant SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n + measure SumS{n, i} = [n - i] + alwaysFalseInvariant _ = sFalse + alwaysTrueInvariant _ = sTrue + loopInvariant SumS{n, i, s} = s .<= i .&& s .== (i*(i+1)) `sDiv` 2 .&& i .<= n + badMeasure1Invariant SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n + badMeasure1 SumS{i} = [- i] + badMeasure2Invariant SumS{n, i, s} = s .== (i*(i+1)) `sDiv` 2 .&& i .<= n + badMeasure2 SumS{n, i} = [n + i] diff --git a/SBVBenchSuite/SBVBench.hs b/SBVBenchSuite/SBVBench.hs --- a/SBVBenchSuite/SBVBench.hs +++ b/SBVBenchSuite/SBVBench.hs @@ -2,6 +2,7 @@ -- | -- Module : SBVBench -- Copyright : (c) Jeffrey Young +-- Levent Erkok -- License : BSD3 -- Maintainer: erkokl@gmail.com -- Stability : experimental @@ -11,13 +12,14 @@ module Main where -import Criterion.Main -import Criterion.Types (Config (..)) +import Gauge.Main +import Gauge.Main.Options (defaultConfig, Config(..)) import Utils.SBVBenchFramework -import BenchSuite.Overhead.SBVOverhead +import BenchSuite.Bench.Bench +-- | Puzzles import qualified BenchSuite.Puzzles.Birthday import qualified BenchSuite.Puzzles.Coins import qualified BenchSuite.Puzzles.Counts @@ -31,31 +33,135 @@ import qualified BenchSuite.Puzzles.Sudoku import qualified BenchSuite.Puzzles.U2Bridge +-- | BitPrecise +import qualified BenchSuite.BitPrecise.BitTricks +import qualified BenchSuite.BitPrecise.BrokenSearch +import qualified BenchSuite.BitPrecise.Legato +import qualified BenchSuite.BitPrecise.MergeSort +import qualified BenchSuite.BitPrecise.MultMask +import qualified BenchSuite.BitPrecise.PrefixSum + +-- | Queries +import qualified BenchSuite.Queries.AllSat +import qualified BenchSuite.Queries.CaseSplit +import qualified BenchSuite.Queries.Concurrency +import qualified BenchSuite.Queries.Enums +import qualified BenchSuite.Queries.FourFours +import qualified BenchSuite.Queries.GuessNumber +import qualified BenchSuite.Queries.Interpolants +import qualified BenchSuite.Queries.UnsatCore + +-- | Weakest Preconditions +import qualified BenchSuite.WeakestPreconditions.Append +import qualified BenchSuite.WeakestPreconditions.Basics +import qualified BenchSuite.WeakestPreconditions.Fib +import qualified BenchSuite.WeakestPreconditions.GCD +import qualified BenchSuite.WeakestPreconditions.IntDiv +import qualified BenchSuite.WeakestPreconditions.IntSqrt +import qualified BenchSuite.WeakestPreconditions.Length +import qualified BenchSuite.WeakestPreconditions.Sum + +-- | Optimization +import qualified BenchSuite.Optimization.Enumerate +import qualified BenchSuite.Optimization.ExtField +import qualified BenchSuite.Optimization.LinearOpt +import qualified BenchSuite.Optimization.Production +import qualified BenchSuite.Optimization.VM + +-- | Uninterpreted +import qualified BenchSuite.Uninterpreted.AUF +import qualified BenchSuite.Uninterpreted.Deduce +import qualified BenchSuite.Uninterpreted.Function +import qualified BenchSuite.Uninterpreted.Multiply +import qualified BenchSuite.Uninterpreted.Shannon +import qualified BenchSuite.Uninterpreted.Sort +import qualified BenchSuite.Uninterpreted.UISortAllSat + +-- | Proof Tools +import qualified BenchSuite.ProofTools.BMC +import qualified BenchSuite.ProofTools.Fibonacci +import qualified BenchSuite.ProofTools.Strengthen +import qualified BenchSuite.ProofTools.Sum + +-- | Code Generation +import qualified BenchSuite.CodeGeneration.AddSub +import qualified BenchSuite.CodeGeneration.CRC_USB5 +import qualified BenchSuite.CodeGeneration.Fibonacci +import qualified BenchSuite.CodeGeneration.GCD +import qualified BenchSuite.CodeGeneration.PopulationCount +import qualified BenchSuite.CodeGeneration.Uninterpreted + +-- | Crypto +import qualified BenchSuite.Crypto.AES +import qualified BenchSuite.Crypto.RC4 +import qualified BenchSuite.Crypto.SHA + +-- | Miscellaneous +import qualified BenchSuite.Misc.Auxiliary +import qualified BenchSuite.Misc.Enumerate +import qualified BenchSuite.Misc.Floating +import qualified BenchSuite.Misc.ModelExtract +import qualified BenchSuite.Misc.Newtypes +import qualified BenchSuite.Misc.NoDiv0 +import qualified BenchSuite.Misc.Polynomials +import qualified BenchSuite.Misc.SetAlgebra +import qualified BenchSuite.Misc.SoftConstrain +import qualified BenchSuite.Misc.Tuple + +-- | Lists +import qualified BenchSuite.Lists.BoundedMutex +import qualified BenchSuite.Lists.Fibonacci +import qualified BenchSuite.Lists.Nested + +-- | Strings +import qualified BenchSuite.Strings.RegexCrossword +import qualified BenchSuite.Strings.SQLInjection + +-- | Existentials +import qualified BenchSuite.Existentials.CRCPolynomial +import qualified BenchSuite.Existentials.Diophantine + +-- | Transformers +import qualified BenchSuite.Transformers.SymbolicEval + + -- | Custom config to limit benchmarks to 5 minutes of runtime. This is required -- because we can easily generate benchmarks that take a lot of wall time to -- solve, especially with 'Data.SBV.allSatWith' calls benchConfig :: Config -benchConfig = defaultConfig {timeLimit = 300.00} +benchConfig = defaultConfig {timeLimit = Just 300.00} -- The bench harness main :: IO () main = defaultMainWith benchConfig $ [ puzzles + , bitPrecise + , queries + , weakestPreconditions + , optimizations + , uninterpreted + , proofTools + , codeGeneration + , crypto + , misc + , lists + , strings + , transformers ] -- | Benchmarks for 'Documentation.SBV.Examples.Puzzles'. Each benchmark file -- defines a 'benchmarks' function which returns a --- 'BenchSuite.Overhead.SBVOverhead.Runner'. We want to allow benchmarks to be --- defined as closely as possible to the problems being solver. But for --- practical reasons we may desire to prevent benchmarking 'Data.SBV.allSat' --- calls because they could timeout. Thus by using --- 'BenchSuite.Overhead.SBVOverhead.Runner' we can define the benchmark --- mirroring the logic of the symbolic program. But that might be expensive to --- benchmark, so using this method we can change solver details _without_ --- redefining the benchmark, as I have done below by converting all examples to --- use 'Data.SBV.satWith'. +-- 'BenchSuite.Bench.Bench.Runner'. We want to allow benchmarks to be defined as +-- closely as possible to the problems being solved. But for practical reasons +-- we may desire to prevent benchmarking 'Data.SBV.allSat' calls because they +-- could timeout. Thus by using 'BenchSuite.Bench.Bench.Runner' we can define +-- the benchmark mirroring the logic of the symbolic program and change solver +-- details _without_ redefining the benchmark, as I have done below by +-- converting all examples to use 'Data.SBV.satWith'. For benchmarks which do +-- not need to run with different solver configurations, such as queries we run +-- with `BenchSuite.Bench.Bench.Runner.runIO` puzzles :: Benchmark -puzzles = bgroup "Puzzles" $ (mkOverheadBenchMark . setRunner satWith) <$> +puzzles = bgroup "Puzzles" $ runBenchMark <$> [ BenchSuite.Puzzles.Coins.benchmarks , BenchSuite.Puzzles.Counts.benchmarks , BenchSuite.Puzzles.Birthday.benchmarks @@ -69,3 +175,133 @@ , BenchSuite.Puzzles.Sudoku.benchmarks , BenchSuite.Puzzles.U2Bridge.benchmarks ] + + +bitPrecise :: Benchmark +bitPrecise = bgroup "BitPrecise" $ runBenchMark <$> + [ BenchSuite.BitPrecise.BitTricks.benchmarks + , BenchSuite.BitPrecise.BrokenSearch.benchmarks + , BenchSuite.BitPrecise.Legato.benchmarks + , BenchSuite.BitPrecise.MergeSort.benchmarks + , BenchSuite.BitPrecise.MultMask.benchmarks + , BenchSuite.BitPrecise.PrefixSum.benchmarks + ] + + +queries :: Benchmark +queries = bgroup "Queries" $ runBenchMark <$> + [ BenchSuite.Queries.AllSat.benchmarks + , BenchSuite.Queries.CaseSplit.benchmarks + , BenchSuite.Queries.Concurrency.benchmarks + , BenchSuite.Queries.Enums.benchmarks + , BenchSuite.Queries.FourFours.benchmarks + , BenchSuite.Queries.GuessNumber.benchmarks + , BenchSuite.Queries.Interpolants.benchmarks + , BenchSuite.Queries.UnsatCore.benchmarks + ] + + +weakestPreconditions :: Benchmark +weakestPreconditions = bgroup "WeakestPreconditions" $ runBenchMark <$> + [ BenchSuite.WeakestPreconditions.Append.benchmarks + , BenchSuite.WeakestPreconditions.Basics.benchmarks + , BenchSuite.WeakestPreconditions.Fib.benchmarks + , BenchSuite.WeakestPreconditions.GCD.benchmarks + , BenchSuite.WeakestPreconditions.IntDiv.benchmarks + , BenchSuite.WeakestPreconditions.IntSqrt.benchmarks + , BenchSuite.WeakestPreconditions.Length.benchmarks + , BenchSuite.WeakestPreconditions.Sum.benchmarks + ] + + +optimizations :: Benchmark +optimizations = bgroup "Optimizations" $ runBenchMark <$> + [ BenchSuite.Optimization.Enumerate.benchmarks + , BenchSuite.Optimization.ExtField.benchmarks + , BenchSuite.Optimization.LinearOpt.benchmarks + , BenchSuite.Optimization.Production.benchmarks + , BenchSuite.Optimization.VM.benchmarks + ] + + +uninterpreted :: Benchmark +uninterpreted = bgroup "Uninterpreted" $ runBenchMark <$> + [ BenchSuite.Uninterpreted.AUF.benchmarks + , BenchSuite.Uninterpreted.Deduce.benchmarks + , BenchSuite.Uninterpreted.Function.benchmarks + , BenchSuite.Uninterpreted.Multiply.benchmarks + , BenchSuite.Uninterpreted.Shannon.benchmarks + , BenchSuite.Uninterpreted.Sort.benchmarks + , BenchSuite.Uninterpreted.UISortAllSat.benchmarks + ] + + +proofTools :: Benchmark +proofTools = bgroup "ProofTools" $ runBenchMark <$> + [ BenchSuite.ProofTools.BMC.benchmarks + , BenchSuite.ProofTools.Fibonacci.benchmarks + , BenchSuite.ProofTools.Strengthen.benchmarks + , BenchSuite.ProofTools.Sum.benchmarks + ] + + +codeGeneration :: Benchmark +codeGeneration = bgroup "CodeGeneration" $ runBenchMark <$> + [ BenchSuite.CodeGeneration.AddSub.benchmarks + , BenchSuite.CodeGeneration.CRC_USB5.benchmarks + , BenchSuite.CodeGeneration.Fibonacci.benchmarks + , BenchSuite.CodeGeneration.GCD.benchmarks + , BenchSuite.CodeGeneration.PopulationCount.benchmarks + , BenchSuite.CodeGeneration.Uninterpreted.benchmarks + ] + + +crypto :: Benchmark +crypto = bgroup "Crypto" $ runBenchMark <$> + [ BenchSuite.Crypto.AES.benchmarks + , BenchSuite.Crypto.RC4.benchmarks + , BenchSuite.Crypto.SHA.benchmarks + ] + + +misc :: Benchmark +misc = bgroup "Miscellaneous" $ runBenchMark <$> + [ BenchSuite.Misc.Auxiliary.benchmarks + , BenchSuite.Misc.Enumerate.benchmarks + , BenchSuite.Misc.Floating.benchmarks + , BenchSuite.Misc.ModelExtract.benchmarks + , BenchSuite.Misc.Newtypes.benchmarks + , BenchSuite.Misc.NoDiv0.benchmarks + , BenchSuite.Misc.Polynomials.benchmarks + , BenchSuite.Misc.SetAlgebra.benchmarks + , BenchSuite.Misc.SoftConstrain.benchmarks + , BenchSuite.Misc.Tuple.benchmarks + ] + + +lists :: Benchmark +lists = bgroup "Lists" $ runBenchMark <$> + [ BenchSuite.Lists.BoundedMutex.benchmarks + , BenchSuite.Lists.Fibonacci.benchmarks + , BenchSuite.Lists.Nested.benchmarks + ] + + +strings :: Benchmark +strings = bgroup "Strings" $ runBenchMark <$> + [ BenchSuite.Strings.RegexCrossword.benchmarks + , BenchSuite.Strings.SQLInjection.benchmarks + ] + + +existentials :: Benchmark +existentials = bgroup "Existentials" $ runBenchMark <$> + [ BenchSuite.Existentials.CRCPolynomial.benchmarks + , BenchSuite.Existentials.Diophantine.benchmarks + ] + + +transformers :: Benchmark +transformers = bgroup "Transformers" $ runBenchMark <$> + [ BenchSuite.Transformers.SymbolicEval.benchmarks + ] diff --git a/SBVBenchSuite/Utils/SBVBenchFramework.hs b/SBVBenchSuite/Utils/SBVBenchFramework.hs --- a/SBVBenchSuite/Utils/SBVBenchFramework.hs +++ b/SBVBenchSuite/Utils/SBVBenchFramework.hs @@ -13,7 +13,7 @@ module Utils.SBVBenchFramework ( mkExecString , mkFileName - , module Criterion.Main + , module Gauge.Main , module Data.SBV ) where @@ -21,7 +21,7 @@ import System.Process (showCommandForUser) import System.Random -import Criterion.Main (Benchmark, bgroup) +import Gauge.Main (Benchmark, bgroup) import Data.SBV diff --git a/SBVTestSuite/GoldFiles/allSat6.gold b/SBVTestSuite/GoldFiles/allSat6.gold --- a/SBVTestSuite/GoldFiles/allSat6.gold +++ b/SBVTestSuite/GoldFiles/allSat6.gold @@ -2,9 +2,9 @@ x = 0 :: Word8 y = 1 :: Word8 Solution #2: - x = 0 :: Word8 + x = 1 :: Word8 y = 2 :: Word8 Solution #3: - x = 1 :: Word8 + x = 0 :: Word8 y = 2 :: Word8 Found 3 different solutions. (Unique up to prefix existentials.) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int16_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int32_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int64_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Int8_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word16_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word32_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word64_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Left_Word8_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int16_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int32_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int64_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Int8_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word16_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word32_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word64_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word16.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word32.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word64.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold --- a/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold +++ b/SBVTestSuite/GoldFiles/barrelRotate_Right_Word8_Word8.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/boxed1.gold b/SBVTestSuite/GoldFiles/boxed1.gold --- a/SBVTestSuite/GoldFiles/boxed1.gold +++ b/SBVTestSuite/GoldFiles/boxed1.gold @@ -1,20 +1,20 @@ Objective "min_x": Optimal in an extension field: - min_x = 0.0 :: Real - max_x_plus_y = 13.0 :: Real - min_y = epsilon :: Real - max_y = 4.0 :: Real + min_x = 0.0 :: Real + max_x_plus_y = 13.0 :: Real + min_y = 2.0 * epsilon :: Real + max_y = 4.0 :: Real Objective "max_x_plus_y": Optimal in an extension field: - min_x = 0.0 :: Real - max_x_plus_y = 13.0 :: Real - min_y = epsilon :: Real - max_y = 4.0 :: Real + min_x = 0.0 :: Real + max_x_plus_y = 13.0 :: Real + min_y = 2.0 * epsilon :: Real + max_y = 4.0 :: Real Objective "min_y": Optimal in an extension field: - min_x = 0.0 :: Real - max_x_plus_y = 13.0 :: Real - min_y = epsilon :: Real - max_y = 4.0 :: Real + min_x = 0.0 :: Real + max_x_plus_y = 13.0 :: Real + min_y = 2.0 * epsilon :: Real + max_y = 4.0 :: Real Objective "max_y": Optimal in an extension field: - min_x = 0.0 :: Real - max_x_plus_y = 13.0 :: Real - min_y = epsilon :: Real - max_y = 4.0 :: Real + min_x = 0.0 :: Real + max_x_plus_y = 13.0 :: Real + min_y = 2.0 * epsilon :: Real + max_y = 4.0 :: Real diff --git a/SBVTestSuite/GoldFiles/freshVars.gold b/SBVTestSuite/GoldFiles/freshVars.gold --- a/SBVTestSuite/GoldFiles/freshVars.gold +++ b/SBVTestSuite/GoldFiles/freshVars.gold @@ -82,6 +82,7 @@ [GOOD] (define-fun s42 () Bool (= s16 s41)) [GOOD] (assert s42) [GOOD] (declare-fun array_0 () (Array Int Int)) +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (declare-fun s43 () Int) [GOOD] (declare-fun s44 () Bool) [GOOD] (define-fun s46 () Int 2) @@ -95,6 +96,7 @@ [GOOD] (assert s50) [GOOD] (define-fun s51 () Int 42) [GOOD] (define-fun array_1 () (Array Int Int) ((as const (Array Int Int)) 42)) +[GOOD] (define-fun array_1_initializer () Bool true) ; no initializiation needed [GOOD] (declare-fun s52 () Int) [GOOD] (declare-fun s53 () (_ BitVec 8)) [GOOD] (define-fun s54 () Int 96) @@ -167,6 +169,11 @@ [RECV] ((s12 (fp #b0 #x82 #b00100000000000000000000))) [SEND] (get-value (s13)) [RECV] ((s13 (fp #b0 #b10000000010 #x4000000000000))) +[GOOD] (set-option :pp.decimal false) +[SEND] (get-value (s14)) +[RECV] ((s14 11.0)) +[GOOD] (set-option :pp.decimal true) +[GOOD] (set-option :pp.decimal_precision 16) [SEND] (get-value (s14)) [RECV] ((s14 11.0)) [SEND] (get-value (s15)) diff --git a/SBVTestSuite/GoldFiles/optExtField3.gold b/SBVTestSuite/GoldFiles/optExtField3.gold --- a/SBVTestSuite/GoldFiles/optExtField3.gold +++ b/SBVTestSuite/GoldFiles/optExtField3.gold @@ -1,2 +1,2 @@ Optimal in an extension field: - x_plus_y = 9.0 + (-2.0 * epsilon) :: Real + x_plus_y = 9.0 + (-3.0 * epsilon) :: Real diff --git a/SBVTestSuite/GoldFiles/pareto1.gold b/SBVTestSuite/GoldFiles/pareto1.gold --- a/SBVTestSuite/GoldFiles/pareto1.gold +++ b/SBVTestSuite/GoldFiles/pareto1.gold @@ -1,180 +1,180 @@ Pareto front #1: Optimal model: - x = 0 :: Integer - y = 0 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 0 :: Integer - min_y = 0 :: Integer -Pareto front #2: Optimal model: - x = 0 :: Integer - y = 1 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 1 :: Integer - min_y = 1 :: Integer -Pareto front #3: Optimal model: x = 1 :: Integer y = 1 :: Integer min_x = 1 :: Integer max_x_plus_y = 2 :: Integer min_y = 1 :: Integer -Pareto front #4: Optimal model: - x = 1 :: Integer - y = 0 :: Integer - min_x = 1 :: Integer - max_x_plus_y = 1 :: Integer - min_y = 0 :: Integer -Pareto front #5: Optimal model: +Pareto front #2: Optimal model: x = 0 :: Integer - y = 2 :: Integer + y = 3 :: Integer min_x = 0 :: Integer - max_x_plus_y = 2 :: Integer - min_y = 2 :: Integer -Pareto front #6: Optimal model: - x = 1 :: Integer - y = 2 :: Integer - min_x = 1 :: Integer max_x_plus_y = 3 :: Integer - min_y = 2 :: Integer -Pareto front #7: Optimal model: + min_y = 3 :: Integer +Pareto front #3: Optimal model: + x = 0 :: Integer + y = 4 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 4 :: Integer + min_y = 4 :: Integer +Pareto front #4: Optimal model: x = 2 :: Integer - y = 0 :: Integer + y = 4 :: Integer min_x = 2 :: Integer - max_x_plus_y = 2 :: Integer - min_y = 0 :: Integer + max_x_plus_y = 6 :: Integer + min_y = 4 :: Integer +Pareto front #5: Optimal model: + x = 3 :: Integer + y = 4 :: Integer + min_x = 3 :: Integer + max_x_plus_y = 7 :: Integer + min_y = 4 :: Integer +Pareto front #6: Optimal model: + x = 4 :: Integer + y = 4 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 8 :: Integer + min_y = 4 :: Integer +Pareto front #7: Optimal model: + x = 5 :: Integer + y = 4 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 9 :: Integer + min_y = 4 :: Integer Pareto front #8: Optimal model: - x = 2 :: Integer - y = 1 :: Integer - min_x = 2 :: Integer - max_x_plus_y = 3 :: Integer - min_y = 1 :: Integer + x = 1 :: Integer + y = 4 :: Integer + min_x = 1 :: Integer + max_x_plus_y = 5 :: Integer + min_y = 4 :: Integer Pareto front #9: Optimal model: x = 3 :: Integer - y = 0 :: Integer + y = 2 :: Integer min_x = 3 :: Integer - max_x_plus_y = 3 :: Integer - min_y = 0 :: Integer + max_x_plus_y = 5 :: Integer + min_y = 2 :: Integer Pareto front #10: Optimal model: - x = 3 :: Integer + x = 4 :: Integer y = 1 :: Integer - min_x = 3 :: Integer - max_x_plus_y = 4 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 5 :: Integer min_y = 1 :: Integer Pareto front #11: Optimal model: - x = 4 :: Integer - y = 0 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 4 :: Integer - min_y = 0 :: Integer -Pareto front #12: Optimal model: x = 5 :: Integer y = 0 :: Integer min_x = 5 :: Integer max_x_plus_y = 5 :: Integer min_y = 0 :: Integer -Pareto front #13: Optimal model: - x = 4 :: Integer - y = 1 :: Integer - min_x = 4 :: Integer +Pareto front #12: Optimal model: + x = 2 :: Integer + y = 3 :: Integer + min_x = 2 :: Integer max_x_plus_y = 5 :: Integer - min_y = 1 :: Integer -Pareto front #14: Optimal model: + min_y = 3 :: Integer +Pareto front #13: Optimal model: x = 5 :: Integer y = 1 :: Integer min_x = 5 :: Integer max_x_plus_y = 6 :: Integer min_y = 1 :: Integer -Pareto front #15: Optimal model: - x = 2 :: Integer +Pareto front #14: Optimal model: + x = 4 :: Integer y = 2 :: Integer - min_x = 2 :: Integer - max_x_plus_y = 4 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 6 :: Integer min_y = 2 :: Integer -Pareto front #16: Optimal model: - x = 0 :: Integer +Pareto front #15: Optimal model: + x = 4 :: Integer y = 3 :: Integer - min_x = 0 :: Integer - max_x_plus_y = 3 :: Integer + min_x = 4 :: Integer + max_x_plus_y = 7 :: Integer min_y = 3 :: Integer +Pareto front #16: Optimal model: + x = 5 :: Integer + y = 2 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 7 :: Integer + min_y = 2 :: Integer Pareto front #17: Optimal model: - x = 1 :: Integer + x = 3 :: Integer y = 3 :: Integer - min_x = 1 :: Integer - max_x_plus_y = 4 :: Integer + min_x = 3 :: Integer + max_x_plus_y = 6 :: Integer min_y = 3 :: Integer Pareto front #18: Optimal model: + x = 5 :: Integer + y = 3 :: Integer + min_x = 5 :: Integer + max_x_plus_y = 8 :: Integer + min_y = 3 :: Integer +Pareto front #19: Optimal model: x = 0 :: Integer - y = 4 :: Integer + y = 0 :: Integer min_x = 0 :: Integer - max_x_plus_y = 4 :: Integer - min_y = 4 :: Integer -Pareto front #19: Optimal model: + max_x_plus_y = 0 :: Integer + min_y = 0 :: Integer +Pareto front #20: Optimal model: x = 1 :: Integer - y = 4 :: Integer + y = 0 :: Integer min_x = 1 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 4 :: Integer -Pareto front #20: Optimal model: - x = 2 :: Integer - y = 3 :: Integer - min_x = 2 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 3 :: Integer + max_x_plus_y = 1 :: Integer + min_y = 0 :: Integer Pareto front #21: Optimal model: + x = 0 :: Integer + y = 1 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 1 :: Integer + min_y = 1 :: Integer +Pareto front #22: Optimal model: x = 2 :: Integer - y = 4 :: Integer + y = 0 :: Integer min_x = 2 :: Integer - max_x_plus_y = 6 :: Integer - min_y = 4 :: Integer -Pareto front #22: Optimal model: - x = 3 :: Integer - y = 2 :: Integer - min_x = 3 :: Integer - max_x_plus_y = 5 :: Integer - min_y = 2 :: Integer + max_x_plus_y = 2 :: Integer + min_y = 0 :: Integer Pareto front #23: Optimal model: x = 3 :: Integer - y = 3 :: Integer + y = 0 :: Integer min_x = 3 :: Integer - max_x_plus_y = 6 :: Integer - min_y = 3 :: Integer + max_x_plus_y = 3 :: Integer + min_y = 0 :: Integer Pareto front #24: Optimal model: + x = 2 :: Integer + y = 1 :: Integer + min_x = 2 :: Integer + max_x_plus_y = 3 :: Integer + min_y = 1 :: Integer +Pareto front #25: Optimal model: x = 3 :: Integer - y = 4 :: Integer + y = 1 :: Integer min_x = 3 :: Integer - max_x_plus_y = 7 :: Integer - min_y = 4 :: Integer -Pareto front #25: Optimal model: - x = 4 :: Integer - y = 2 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 6 :: Integer - min_y = 2 :: Integer + max_x_plus_y = 4 :: Integer + min_y = 1 :: Integer Pareto front #26: Optimal model: - x = 5 :: Integer + x = 1 :: Integer y = 2 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 7 :: Integer + min_x = 1 :: Integer + max_x_plus_y = 3 :: Integer min_y = 2 :: Integer Pareto front #27: Optimal model: - x = 4 :: Integer + x = 1 :: Integer y = 3 :: Integer - min_x = 4 :: Integer - max_x_plus_y = 7 :: Integer + min_x = 1 :: Integer + max_x_plus_y = 4 :: Integer min_y = 3 :: Integer Pareto front #28: Optimal model: - x = 5 :: Integer - y = 3 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 8 :: Integer - min_y = 3 :: Integer -Pareto front #29: Optimal model: x = 4 :: Integer - y = 4 :: Integer + y = 0 :: Integer min_x = 4 :: Integer - max_x_plus_y = 8 :: Integer - min_y = 4 :: Integer + max_x_plus_y = 4 :: Integer + min_y = 0 :: Integer +Pareto front #29: Optimal model: + x = 2 :: Integer + y = 2 :: Integer + min_x = 2 :: Integer + max_x_plus_y = 4 :: Integer + min_y = 2 :: Integer Pareto front #30: Optimal model: - x = 5 :: Integer - y = 4 :: Integer - min_x = 5 :: Integer - max_x_plus_y = 9 :: Integer - min_y = 4 :: Integer + x = 0 :: Integer + y = 2 :: Integer + min_x = 0 :: Integer + max_x_plus_y = 2 :: Integer + min_y = 2 :: Integer diff --git a/SBVTestSuite/GoldFiles/pareto2.gold b/SBVTestSuite/GoldFiles/pareto2.gold --- a/SBVTestSuite/GoldFiles/pareto2.gold +++ b/SBVTestSuite/GoldFiles/pareto2.gold @@ -1,182 +1,182 @@ Pareto front #1: Optimal model: x = 0 :: Integer - y = 0 :: Integer - min_x = 0 :: Integer - max_y = 0 :: Integer - max_x_plus_y = 0 :: Integer -Pareto front #2: Optimal model: - x = 0 :: Integer y = 1 :: Integer min_x = 0 :: Integer max_y = 1 :: Integer max_x_plus_y = 1 :: Integer -Pareto front #3: Optimal model: +Pareto front #2: Optimal model: x = 0 :: Integer y = 2 :: Integer min_x = 0 :: Integer max_y = 2 :: Integer max_x_plus_y = 2 :: Integer +Pareto front #3: Optimal model: + x = 0 :: Integer + y = 3 :: Integer + min_x = 0 :: Integer + max_y = 3 :: Integer + max_x_plus_y = 3 :: Integer Pareto front #4: Optimal model: - x = 0 :: Integer - y = -1 :: Integer - min_x = 0 :: Integer - max_y = -1 :: Integer - max_x_plus_y = -1 :: Integer + x = 0 :: Integer + y = 4 :: Integer + min_x = 0 :: Integer + max_y = 4 :: Integer + max_x_plus_y = 4 :: Integer Pareto front #5: Optimal model: - x = 0 :: Integer - y = -2 :: Integer - min_x = 0 :: Integer - max_y = -2 :: Integer - max_x_plus_y = -2 :: Integer + x = 0 :: Integer + y = 6 :: Integer + min_x = 0 :: Integer + max_y = 6 :: Integer + max_x_plus_y = 6 :: Integer Pareto front #6: Optimal model: - x = 0 :: Integer - y = -3 :: Integer - min_x = 0 :: Integer - max_y = -3 :: Integer - max_x_plus_y = -3 :: Integer + x = 0 :: Integer + y = 7 :: Integer + min_x = 0 :: Integer + max_y = 7 :: Integer + max_x_plus_y = 7 :: Integer Pareto front #7: Optimal model: x = 0 :: Integer - y = 3 :: Integer + y = 9 :: Integer min_x = 0 :: Integer - max_y = 3 :: Integer - max_x_plus_y = 3 :: Integer + max_y = 9 :: Integer + max_x_plus_y = 9 :: Integer Pareto front #8: Optimal model: x = 0 :: Integer - y = -4 :: Integer + y = 10 :: Integer min_x = 0 :: Integer - max_y = -4 :: Integer - max_x_plus_y = -4 :: Integer + max_y = 10 :: Integer + max_x_plus_y = 10 :: Integer Pareto front #9: Optimal model: x = 0 :: Integer - y = -5 :: Integer + y = 12 :: Integer min_x = 0 :: Integer - max_y = -5 :: Integer - max_x_plus_y = -5 :: Integer + max_y = 12 :: Integer + max_x_plus_y = 12 :: Integer Pareto front #10: Optimal model: x = 0 :: Integer - y = -6 :: Integer + y = 14 :: Integer min_x = 0 :: Integer - max_y = -6 :: Integer - max_x_plus_y = -6 :: Integer + max_y = 14 :: Integer + max_x_plus_y = 14 :: Integer Pareto front #11: Optimal model: x = 0 :: Integer - y = -7 :: Integer + y = 16 :: Integer min_x = 0 :: Integer - max_y = -7 :: Integer - max_x_plus_y = -7 :: Integer + max_y = 16 :: Integer + max_x_plus_y = 16 :: Integer Pareto front #12: Optimal model: x = 0 :: Integer - y = -8 :: Integer + y = 17 :: Integer min_x = 0 :: Integer - max_y = -8 :: Integer - max_x_plus_y = -8 :: Integer + max_y = 17 :: Integer + max_x_plus_y = 17 :: Integer Pareto front #13: Optimal model: x = 0 :: Integer - y = -9 :: Integer + y = 19 :: Integer min_x = 0 :: Integer - max_y = -9 :: Integer - max_x_plus_y = -9 :: Integer + max_y = 19 :: Integer + max_x_plus_y = 19 :: Integer Pareto front #14: Optimal model: - x = 0 :: Integer - y = -10 :: Integer - min_x = 0 :: Integer - max_y = -10 :: Integer - max_x_plus_y = -10 :: Integer + x = 0 :: Integer + y = 21 :: Integer + min_x = 0 :: Integer + max_y = 21 :: Integer + max_x_plus_y = 21 :: Integer Pareto front #15: Optimal model: - x = 0 :: Integer - y = -11 :: Integer - min_x = 0 :: Integer - max_y = -11 :: Integer - max_x_plus_y = -11 :: Integer + x = 0 :: Integer + y = 23 :: Integer + min_x = 0 :: Integer + max_y = 23 :: Integer + max_x_plus_y = 23 :: Integer Pareto front #16: Optimal model: - x = 0 :: Integer - y = -12 :: Integer - min_x = 0 :: Integer - max_y = -12 :: Integer - max_x_plus_y = -12 :: Integer + x = 0 :: Integer + y = 25 :: Integer + min_x = 0 :: Integer + max_y = 25 :: Integer + max_x_plus_y = 25 :: Integer Pareto front #17: Optimal model: - x = 0 :: Integer - y = -13 :: Integer - min_x = 0 :: Integer - max_y = -13 :: Integer - max_x_plus_y = -13 :: Integer + x = 0 :: Integer + y = 26 :: Integer + min_x = 0 :: Integer + max_y = 26 :: Integer + max_x_plus_y = 26 :: Integer Pareto front #18: Optimal model: - x = 0 :: Integer - y = -14 :: Integer - min_x = 0 :: Integer - max_y = -14 :: Integer - max_x_plus_y = -14 :: Integer + x = 0 :: Integer + y = 27 :: Integer + min_x = 0 :: Integer + max_y = 27 :: Integer + max_x_plus_y = 27 :: Integer Pareto front #19: Optimal model: - x = 0 :: Integer - y = 4 :: Integer - min_x = 0 :: Integer - max_y = 4 :: Integer - max_x_plus_y = 4 :: Integer + x = 0 :: Integer + y = 28 :: Integer + min_x = 0 :: Integer + max_y = 28 :: Integer + max_x_plus_y = 28 :: Integer Pareto front #20: Optimal model: - x = 0 :: Integer - y = 5 :: Integer - min_x = 0 :: Integer - max_y = 5 :: Integer - max_x_plus_y = 5 :: Integer + x = 0 :: Integer + y = 30 :: Integer + min_x = 0 :: Integer + max_y = 30 :: Integer + max_x_plus_y = 30 :: Integer Pareto front #21: Optimal model: - x = 0 :: Integer - y = 6 :: Integer - min_x = 0 :: Integer - max_y = 6 :: Integer - max_x_plus_y = 6 :: Integer + x = 0 :: Integer + y = 32 :: Integer + min_x = 0 :: Integer + max_y = 32 :: Integer + max_x_plus_y = 32 :: Integer Pareto front #22: Optimal model: - x = 0 :: Integer - y = -15 :: Integer - min_x = 0 :: Integer - max_y = -15 :: Integer - max_x_plus_y = -15 :: Integer + x = 0 :: Integer + y = 33 :: Integer + min_x = 0 :: Integer + max_y = 33 :: Integer + max_x_plus_y = 33 :: Integer Pareto front #23: Optimal model: - x = 0 :: Integer - y = -16 :: Integer - min_x = 0 :: Integer - max_y = -16 :: Integer - max_x_plus_y = -16 :: Integer + x = 0 :: Integer + y = 34 :: Integer + min_x = 0 :: Integer + max_y = 34 :: Integer + max_x_plus_y = 34 :: Integer Pareto front #24: Optimal model: - x = 0 :: Integer - y = -17 :: Integer - min_x = 0 :: Integer - max_y = -17 :: Integer - max_x_plus_y = -17 :: Integer + x = 0 :: Integer + y = 36 :: Integer + min_x = 0 :: Integer + max_y = 36 :: Integer + max_x_plus_y = 36 :: Integer Pareto front #25: Optimal model: - x = 0 :: Integer - y = -18 :: Integer - min_x = 0 :: Integer - max_y = -18 :: Integer - max_x_plus_y = -18 :: Integer + x = 0 :: Integer + y = 37 :: Integer + min_x = 0 :: Integer + max_y = 37 :: Integer + max_x_plus_y = 37 :: Integer Pareto front #26: Optimal model: - x = 0 :: Integer - y = -19 :: Integer - min_x = 0 :: Integer - max_y = -19 :: Integer - max_x_plus_y = -19 :: Integer + x = 0 :: Integer + y = 38 :: Integer + min_x = 0 :: Integer + max_y = 38 :: Integer + max_x_plus_y = 38 :: Integer Pareto front #27: Optimal model: - x = 0 :: Integer - y = -20 :: Integer - min_x = 0 :: Integer - max_y = -20 :: Integer - max_x_plus_y = -20 :: Integer + x = 0 :: Integer + y = 40 :: Integer + min_x = 0 :: Integer + max_y = 40 :: Integer + max_x_plus_y = 40 :: Integer Pareto front #28: Optimal model: - x = 0 :: Integer - y = -21 :: Integer - min_x = 0 :: Integer - max_y = -21 :: Integer - max_x_plus_y = -21 :: Integer + x = 0 :: Integer + y = 42 :: Integer + min_x = 0 :: Integer + max_y = 42 :: Integer + max_x_plus_y = 42 :: Integer Pareto front #29: Optimal model: - x = 0 :: Integer - y = -22 :: Integer - min_x = 0 :: Integer - max_y = -22 :: Integer - max_x_plus_y = -22 :: Integer + x = 0 :: Integer + y = 43 :: Integer + min_x = 0 :: Integer + max_y = 43 :: Integer + max_x_plus_y = 43 :: Integer Pareto front #30: Optimal model: - x = 0 :: Integer - y = -23 :: Integer - min_x = 0 :: Integer - max_y = -23 :: Integer - max_x_plus_y = -23 :: Integer + x = 0 :: Integer + y = 44 :: Integer + min_x = 0 :: Integer + max_y = 44 :: Integer + max_x_plus_y = 44 :: Integer *** Note: Pareto-front extraction was terminated as requested by the user. *** There might be many other results! diff --git a/SBVTestSuite/GoldFiles/pareto3.gold b/SBVTestSuite/GoldFiles/pareto3.gold --- a/SBVTestSuite/GoldFiles/pareto3.gold +++ b/SBVTestSuite/GoldFiles/pareto3.gold @@ -1,8 +1,8 @@ Pareto front #1: Optimal model: - x = 0 :: Integer - min_x = 0 :: Integer - max_x_plus_x = 0 :: Integer -Pareto front #2: Optimal model: x = 1 :: Integer min_x = 1 :: Integer max_x_plus_x = 2 :: Integer +Pareto front #2: Optimal model: + x = 0 :: Integer + min_x = 0 :: Integer + max_x_plus_x = 0 :: Integer diff --git a/SBVTestSuite/GoldFiles/query1.gold b/SBVTestSuite/GoldFiles/query1.gold --- a/SBVTestSuite/GoldFiles/query1.gold +++ b/SBVTestSuite/GoldFiles/query1.gold @@ -73,7 +73,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "state of the most recent check-sat command is not known") [SEND] (get-info :version) -[RECV] (:version "4.8.8") +[RECV] (:version "4.8.9") [SEND] (get-info :status) [RECV] (:status sat) [GOOD] (define-fun s16 () Int 4) @@ -104,7 +104,7 @@ [SEND] (get-info :reason-unknown) [RECV] (:reason-unknown "unknown") [SEND] (get-info :version) -[RECV] (:version "4.8.8") +[RECV] (:version "4.8.9") [SEND] (get-info :memory) [RECV] unsupported [SEND] (get-info :time) @@ -149,20 +149,19 @@ (declare-fun bey () Bool) (declare-fun hey () Bool) (proof - (let (($x232 (<= s0 6))) - (let (($x233 (not $x232))) - (let (($x240 (or (not bey) $x233))) - (let ((@x238 (monotonicity (rewrite (= (> s0 6) $x233)) (= (=> bey (> s0 6)) (=> bey $x233))))) - (let ((@x244 (trans @x238 (rewrite (= (=> bey $x233) $x240)) (= (=> bey (> s0 6)) $x240)))) - (let ((@x245 (mp (asserted (=> bey (> s0 6))) @x244 $x240))) - (let (($x257 (>= s0 6))) - (let (($x256 (not $x257))) - (let (($x266 (or (not hey) $x256))) - (let ((@x259 (monotonicity (rewrite (= (<= 6 s0) $x257)) (= (not (<= 6 s0)) $x256)))) - (let ((@x261 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) @x259 (= (< s0 6) $x256)))) - (let ((@x270 (trans (monotonicity @x261 (= (=> hey (< s0 6)) (=> hey $x256))) (rewrite (= (=> hey $x256) $x266)) (= (=> hey (< s0 6)) $x266)))) - (let ((@x271 (mp (asserted (=> hey (< s0 6))) @x270 $x266))) - (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x257 $x232)) (unit-resolution @x271 (asserted hey) $x256) (unit-resolution @x245 (asserted bey) $x233) false)))))))))))))))) + (let (($x224 (<= s0 6))) + (let (($x225 (not $x224))) + (let (($x232 (or (not bey) $x225))) + (let ((@x230 (monotonicity (rewrite (= (> s0 6) $x225)) (= (=> bey (> s0 6)) (=> bey $x225))))) + (let ((@x236 (trans @x230 (rewrite (= (=> bey $x225) $x232)) (= (=> bey (> s0 6)) $x232)))) + (let ((@x237 (mp (asserted (=> bey (> s0 6))) @x236 $x232))) + (let (($x249 (>= s0 6))) + (let (($x248 (not $x249))) + (let (($x256 (or (not hey) $x248))) + (let ((@x247 (trans (rewrite (= (< s0 6) (not (<= 6 s0)))) (rewrite (= (not (<= 6 s0)) $x248)) (= (< s0 6) $x248)))) + (let ((@x260 (trans (monotonicity @x247 (= (=> hey (< s0 6)) (=> hey $x248))) (rewrite (= (=> hey $x248) $x256)) (= (=> hey (< s0 6)) $x256)))) + (let ((@x261 (mp (asserted (=> hey (< s0 6))) @x260 $x256))) + (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x249 $x224)) (unit-resolution @x261 (asserted hey) $x248) (unit-resolution @x237 (asserted bey) $x225) false))))))))))))))) [SEND, TimeOut: 90000ms] (get-assertions) [RECV] ((! s7 :named |a > 0|) diff --git a/SBVTestSuite/GoldFiles/queryArrays1.gold b/SBVTestSuite/GoldFiles/queryArrays1.gold --- a/SBVTestSuite/GoldFiles/queryArrays1.gold +++ b/SBVTestSuite/GoldFiles/queryArrays1.gold @@ -22,11 +22,14 @@ [GOOD] ; --- user given axioms --- [GOOD] ; --- formula --- [GOOD] (define-fun s2 () Bool (distinct s0 s1)) +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (assert s2) [GOOD] (declare-fun array_1 () (Array (_ BitVec 8) (_ BitVec 8))) [GOOD] (define-fun s4 () (_ BitVec 8) (select array_1 s0)) [GOOD] (define-fun s5 () Bool (= s3 s4)) -[GOOD] (assert (= array_1 (store array_0 s0 s3))) +[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s3))) +[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0) +[GOOD] (assert array_1_initializer) [GOOD] (assert s5) [SEND] (check-sat) [RECV] sat diff --git a/SBVTestSuite/GoldFiles/queryArrays2.gold b/SBVTestSuite/GoldFiles/queryArrays2.gold --- a/SBVTestSuite/GoldFiles/queryArrays2.gold +++ b/SBVTestSuite/GoldFiles/queryArrays2.gold @@ -275,262 +275,264 @@ [GOOD] (define-fun s255 () (_ BitVec 8) #xfe) [GOOD] (define-fun s256 () (_ BitVec 8) #xff) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8)) -[GOOD] (assert (= (table0 #x00) s1)) -[GOOD] (assert (= (table0 #x01) s2)) -[GOOD] (assert (= (table0 #x02) s3)) -[GOOD] (assert (= (table0 #x03) s4)) -[GOOD] (assert (= (table0 #x04) s5)) -[GOOD] (assert (= (table0 #x05) s6)) -[GOOD] (assert (= (table0 #x06) s7)) -[GOOD] (assert (= (table0 #x07) s8)) -[GOOD] (assert (= (table0 #x08) s9)) -[GOOD] (assert (= (table0 #x09) s10)) -[GOOD] (assert (= (table0 #x0a) s11)) -[GOOD] (assert (= (table0 #x0b) s12)) -[GOOD] (assert (= (table0 #x0c) s13)) -[GOOD] (assert (= (table0 #x0d) s14)) -[GOOD] (assert (= (table0 #x0e) s15)) -[GOOD] (assert (= (table0 #x0f) s16)) -[GOOD] (assert (= (table0 #x10) s17)) -[GOOD] (assert (= (table0 #x11) s18)) -[GOOD] (assert (= (table0 #x12) s19)) -[GOOD] (assert (= (table0 #x13) s20)) -[GOOD] (assert (= (table0 #x14) s21)) -[GOOD] (assert (= (table0 #x15) s22)) -[GOOD] (assert (= (table0 #x16) s23)) -[GOOD] (assert (= (table0 #x17) s24)) -[GOOD] (assert (= (table0 #x18) s25)) -[GOOD] (assert (= (table0 #x19) s26)) -[GOOD] (assert (= (table0 #x1a) s27)) -[GOOD] (assert (= (table0 #x1b) s28)) -[GOOD] (assert (= (table0 #x1c) s29)) -[GOOD] (assert (= (table0 #x1d) s30)) -[GOOD] (assert (= (table0 #x1e) s31)) -[GOOD] (assert (= (table0 #x1f) s32)) -[GOOD] (assert (= (table0 #x20) s33)) -[GOOD] (assert (= (table0 #x21) s34)) -[GOOD] (assert (= (table0 #x22) s35)) -[GOOD] (assert (= (table0 #x23) s36)) -[GOOD] (assert (= (table0 #x24) s37)) -[GOOD] (assert (= (table0 #x25) s38)) -[GOOD] (assert (= (table0 #x26) s39)) -[GOOD] (assert (= (table0 #x27) s40)) -[GOOD] (assert (= (table0 #x28) s41)) -[GOOD] (assert (= (table0 #x29) s42)) -[GOOD] (assert (= (table0 #x2a) s43)) -[GOOD] (assert (= (table0 #x2b) s44)) -[GOOD] (assert (= (table0 #x2c) s45)) -[GOOD] (assert (= (table0 #x2d) s46)) -[GOOD] (assert (= (table0 #x2e) s47)) -[GOOD] (assert (= (table0 #x2f) s48)) -[GOOD] (assert (= (table0 #x30) s49)) -[GOOD] (assert (= (table0 #x31) s50)) -[GOOD] (assert (= (table0 #x32) s51)) -[GOOD] (assert (= (table0 #x33) s52)) -[GOOD] (assert (= (table0 #x34) s53)) -[GOOD] (assert (= (table0 #x35) s54)) -[GOOD] (assert (= (table0 #x36) s55)) -[GOOD] (assert (= (table0 #x37) s56)) -[GOOD] (assert (= (table0 #x38) s57)) -[GOOD] (assert (= (table0 #x39) s58)) -[GOOD] (assert (= (table0 #x3a) s59)) -[GOOD] (assert (= (table0 #x3b) s60)) -[GOOD] (assert (= (table0 #x3c) s61)) -[GOOD] (assert (= (table0 #x3d) s62)) -[GOOD] (assert (= (table0 #x3e) s63)) -[GOOD] (assert (= (table0 #x3f) s64)) -[GOOD] (assert (= (table0 #x40) s65)) -[GOOD] (assert (= (table0 #x41) s66)) -[GOOD] (assert (= (table0 #x42) s67)) -[GOOD] (assert (= (table0 #x43) s68)) -[GOOD] (assert (= (table0 #x44) s69)) -[GOOD] (assert (= (table0 #x45) s70)) -[GOOD] (assert (= (table0 #x46) s71)) -[GOOD] (assert (= (table0 #x47) s72)) -[GOOD] (assert (= (table0 #x48) s73)) -[GOOD] (assert (= (table0 #x49) s74)) -[GOOD] (assert (= (table0 #x4a) s75)) -[GOOD] (assert (= (table0 #x4b) s76)) -[GOOD] (assert (= (table0 #x4c) s77)) -[GOOD] (assert (= (table0 #x4d) s78)) -[GOOD] (assert (= (table0 #x4e) s79)) -[GOOD] (assert (= (table0 #x4f) s80)) -[GOOD] (assert (= (table0 #x50) s81)) -[GOOD] (assert (= (table0 #x51) s82)) -[GOOD] (assert (= (table0 #x52) s83)) -[GOOD] (assert (= (table0 #x53) s84)) -[GOOD] (assert (= (table0 #x54) s85)) -[GOOD] (assert (= (table0 #x55) s86)) -[GOOD] (assert (= (table0 #x56) s87)) -[GOOD] (assert (= (table0 #x57) s88)) -[GOOD] (assert (= (table0 #x58) s89)) -[GOOD] (assert (= (table0 #x59) s90)) -[GOOD] (assert (= (table0 #x5a) s91)) -[GOOD] (assert (= (table0 #x5b) s92)) -[GOOD] (assert (= (table0 #x5c) s93)) -[GOOD] (assert (= (table0 #x5d) s94)) -[GOOD] (assert (= (table0 #x5e) s95)) -[GOOD] (assert (= (table0 #x5f) s96)) -[GOOD] (assert (= (table0 #x60) s97)) -[GOOD] (assert (= (table0 #x61) s98)) -[GOOD] (assert (= (table0 #x62) s99)) -[GOOD] (assert (= (table0 #x63) s100)) -[GOOD] (assert (= (table0 #x64) s101)) -[GOOD] (assert (= (table0 #x65) s102)) -[GOOD] (assert (= (table0 #x66) s103)) -[GOOD] (assert (= (table0 #x67) s104)) -[GOOD] (assert (= (table0 #x68) s105)) -[GOOD] (assert (= (table0 #x69) s106)) -[GOOD] (assert (= (table0 #x6a) s107)) -[GOOD] (assert (= (table0 #x6b) s108)) -[GOOD] (assert (= (table0 #x6c) s109)) -[GOOD] (assert (= (table0 #x6d) s110)) -[GOOD] (assert (= (table0 #x6e) s111)) -[GOOD] (assert (= (table0 #x6f) s112)) -[GOOD] (assert (= (table0 #x70) s113)) -[GOOD] (assert (= (table0 #x71) s114)) -[GOOD] (assert (= (table0 #x72) s115)) -[GOOD] (assert (= (table0 #x73) s116)) -[GOOD] (assert (= (table0 #x74) s117)) -[GOOD] (assert (= (table0 #x75) s118)) -[GOOD] (assert (= (table0 #x76) s119)) -[GOOD] (assert (= (table0 #x77) s120)) -[GOOD] (assert (= (table0 #x78) s121)) -[GOOD] (assert (= (table0 #x79) s122)) -[GOOD] (assert (= (table0 #x7a) s123)) -[GOOD] (assert (= (table0 #x7b) s124)) -[GOOD] (assert (= (table0 #x7c) s125)) -[GOOD] (assert (= (table0 #x7d) s126)) -[GOOD] (assert (= (table0 #x7e) s127)) -[GOOD] (assert (= (table0 #x7f) s128)) -[GOOD] (assert (= (table0 #x80) s129)) -[GOOD] (assert (= (table0 #x81) s130)) -[GOOD] (assert (= (table0 #x82) s131)) -[GOOD] (assert (= (table0 #x83) s132)) -[GOOD] (assert (= (table0 #x84) s133)) -[GOOD] (assert (= (table0 #x85) s134)) -[GOOD] (assert (= (table0 #x86) s135)) -[GOOD] (assert (= (table0 #x87) s136)) -[GOOD] (assert (= (table0 #x88) s137)) -[GOOD] (assert (= (table0 #x89) s138)) -[GOOD] (assert (= (table0 #x8a) s139)) -[GOOD] (assert (= (table0 #x8b) s140)) -[GOOD] (assert (= (table0 #x8c) s141)) -[GOOD] (assert (= (table0 #x8d) s142)) -[GOOD] (assert (= (table0 #x8e) s143)) -[GOOD] (assert (= (table0 #x8f) s144)) -[GOOD] (assert (= (table0 #x90) s145)) -[GOOD] (assert (= (table0 #x91) s146)) -[GOOD] (assert (= (table0 #x92) s147)) -[GOOD] (assert (= (table0 #x93) s148)) -[GOOD] (assert (= (table0 #x94) s149)) -[GOOD] (assert (= (table0 #x95) s150)) -[GOOD] (assert (= (table0 #x96) s151)) -[GOOD] (assert (= (table0 #x97) s152)) -[GOOD] (assert (= (table0 #x98) s153)) -[GOOD] (assert (= (table0 #x99) s154)) -[GOOD] (assert (= (table0 #x9a) s155)) -[GOOD] (assert (= (table0 #x9b) s156)) -[GOOD] (assert (= (table0 #x9c) s157)) -[GOOD] (assert (= (table0 #x9d) s158)) -[GOOD] (assert (= (table0 #x9e) s159)) -[GOOD] (assert (= (table0 #x9f) s160)) -[GOOD] (assert (= (table0 #xa0) s161)) -[GOOD] (assert (= (table0 #xa1) s162)) -[GOOD] (assert (= (table0 #xa2) s163)) -[GOOD] (assert (= (table0 #xa3) s164)) -[GOOD] (assert (= (table0 #xa4) s165)) -[GOOD] (assert (= (table0 #xa5) s166)) -[GOOD] (assert (= (table0 #xa6) s167)) -[GOOD] (assert (= (table0 #xa7) s168)) -[GOOD] (assert (= (table0 #xa8) s169)) -[GOOD] (assert (= (table0 #xa9) s170)) -[GOOD] (assert (= (table0 #xaa) s171)) -[GOOD] (assert (= (table0 #xab) s172)) -[GOOD] (assert (= (table0 #xac) s173)) -[GOOD] (assert (= (table0 #xad) s174)) -[GOOD] (assert (= (table0 #xae) s175)) -[GOOD] (assert (= (table0 #xaf) s176)) -[GOOD] (assert (= (table0 #xb0) s177)) -[GOOD] (assert (= (table0 #xb1) s178)) -[GOOD] (assert (= (table0 #xb2) s179)) -[GOOD] (assert (= (table0 #xb3) s180)) -[GOOD] (assert (= (table0 #xb4) s181)) -[GOOD] (assert (= (table0 #xb5) s182)) -[GOOD] (assert (= (table0 #xb6) s183)) -[GOOD] (assert (= (table0 #xb7) s184)) -[GOOD] (assert (= (table0 #xb8) s185)) -[GOOD] (assert (= (table0 #xb9) s186)) -[GOOD] (assert (= (table0 #xba) s187)) -[GOOD] (assert (= (table0 #xbb) s188)) -[GOOD] (assert (= (table0 #xbc) s189)) -[GOOD] (assert (= (table0 #xbd) s190)) -[GOOD] (assert (= (table0 #xbe) s191)) -[GOOD] (assert (= (table0 #xbf) s192)) -[GOOD] (assert (= (table0 #xc0) s193)) -[GOOD] (assert (= (table0 #xc1) s194)) -[GOOD] (assert (= (table0 #xc2) s195)) -[GOOD] (assert (= (table0 #xc3) s196)) -[GOOD] (assert (= (table0 #xc4) s197)) -[GOOD] (assert (= (table0 #xc5) s198)) -[GOOD] (assert (= (table0 #xc6) s199)) -[GOOD] (assert (= (table0 #xc7) s200)) -[GOOD] (assert (= (table0 #xc8) s201)) -[GOOD] (assert (= (table0 #xc9) s202)) -[GOOD] (assert (= (table0 #xca) s203)) -[GOOD] (assert (= (table0 #xcb) s204)) -[GOOD] (assert (= (table0 #xcc) s205)) -[GOOD] (assert (= (table0 #xcd) s206)) -[GOOD] (assert (= (table0 #xce) s207)) -[GOOD] (assert (= (table0 #xcf) s208)) -[GOOD] (assert (= (table0 #xd0) s209)) -[GOOD] (assert (= (table0 #xd1) s210)) -[GOOD] (assert (= (table0 #xd2) s211)) -[GOOD] (assert (= (table0 #xd3) s212)) -[GOOD] (assert (= (table0 #xd4) s213)) -[GOOD] (assert (= (table0 #xd5) s214)) -[GOOD] (assert (= (table0 #xd6) s215)) -[GOOD] (assert (= (table0 #xd7) s216)) -[GOOD] (assert (= (table0 #xd8) s217)) -[GOOD] (assert (= (table0 #xd9) s218)) -[GOOD] (assert (= (table0 #xda) s219)) -[GOOD] (assert (= (table0 #xdb) s220)) -[GOOD] (assert (= (table0 #xdc) s221)) -[GOOD] (assert (= (table0 #xdd) s222)) -[GOOD] (assert (= (table0 #xde) s223)) -[GOOD] (assert (= (table0 #xdf) s224)) -[GOOD] (assert (= (table0 #xe0) s225)) -[GOOD] (assert (= (table0 #xe1) s226)) -[GOOD] (assert (= (table0 #xe2) s227)) -[GOOD] (assert (= (table0 #xe3) s228)) -[GOOD] (assert (= (table0 #xe4) s229)) -[GOOD] (assert (= (table0 #xe5) s230)) -[GOOD] (assert (= (table0 #xe6) s231)) -[GOOD] (assert (= (table0 #xe7) s232)) -[GOOD] (assert (= (table0 #xe8) s233)) -[GOOD] (assert (= (table0 #xe9) s234)) -[GOOD] (assert (= (table0 #xea) s235)) -[GOOD] (assert (= (table0 #xeb) s236)) -[GOOD] (assert (= (table0 #xec) s237)) -[GOOD] (assert (= (table0 #xed) s238)) -[GOOD] (assert (= (table0 #xee) s239)) -[GOOD] (assert (= (table0 #xef) s240)) -[GOOD] (assert (= (table0 #xf0) s241)) -[GOOD] (assert (= (table0 #xf1) s242)) -[GOOD] (assert (= (table0 #xf2) s243)) -[GOOD] (assert (= (table0 #xf3) s244)) -[GOOD] (assert (= (table0 #xf4) s245)) -[GOOD] (assert (= (table0 #xf5) s246)) -[GOOD] (assert (= (table0 #xf6) s247)) -[GOOD] (assert (= (table0 #xf7) s248)) -[GOOD] (assert (= (table0 #xf8) s249)) -[GOOD] (assert (= (table0 #xf9) s250)) -[GOOD] (assert (= (table0 #xfa) s251)) -[GOOD] (assert (= (table0 #xfb) s252)) -[GOOD] (assert (= (table0 #xfc) s253)) -[GOOD] (assert (= (table0 #xfd) s254)) -[GOOD] (assert (= (table0 #xfe) s255)) -[GOOD] (assert (= (table0 #xff) s256)) +[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s1)) +[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s2)) +[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s3)) +[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s4)) +[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s5)) +[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s6)) +[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s7)) +[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s8)) +[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s9)) +[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s10)) +[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s11)) +[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s12)) +[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s13)) +[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s14)) +[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s15)) +[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s16)) +[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s17)) +[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s18)) +[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s19)) +[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s20)) +[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s21)) +[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s22)) +[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s23)) +[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s24)) +[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s25)) +[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s26)) +[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s27)) +[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s28)) +[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s29)) +[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s30)) +[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s31)) +[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s32)) +[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s33)) +[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s34)) +[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s35)) +[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s36)) +[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s37)) +[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s38)) +[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s39)) +[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s40)) +[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s41)) +[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s42)) +[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s43)) +[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s44)) +[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s45)) +[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s46)) +[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s47)) +[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s48)) +[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s49)) +[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s50)) +[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s51)) +[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s52)) +[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s53)) +[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s54)) +[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s55)) +[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s56)) +[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s57)) +[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s58)) +[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s59)) +[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s60)) +[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s61)) +[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s62)) +[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s63)) +[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s64)) +[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s65)) +[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s66)) +[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s67)) +[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s68)) +[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s69)) +[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s70)) +[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s71)) +[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s72)) +[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s73)) +[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s74)) +[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s75)) +[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s76)) +[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s77)) +[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s78)) +[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s79)) +[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s80)) +[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s81)) +[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s82)) +[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s83)) +[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s84)) +[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s85)) +[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s86)) +[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s87)) +[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s88)) +[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s89)) +[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s90)) +[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s91)) +[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s92)) +[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s93)) +[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s94)) +[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s95)) +[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s96)) +[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s97)) +[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s98)) +[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s99)) +[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s100)) +[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s101)) +[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s102)) +[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s103)) +[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s104)) +[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s105)) +[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s106)) +[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s107)) +[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s108)) +[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s109)) +[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s110)) +[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s111)) +[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s112)) +[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s113)) +[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s114)) +[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s115)) +[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s116)) +[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s117)) +[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s118)) +[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s119)) +[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s120)) +[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s121)) +[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s122)) +[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s123)) +[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s124)) +[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s125)) +[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s126)) +[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s127)) +[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s128)) +[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s129)) +[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s130)) +[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s131)) +[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s132)) +[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s133)) +[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s134)) +[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s135)) +[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s136)) +[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s137)) +[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s138)) +[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s139)) +[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s140)) +[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s141)) +[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s142)) +[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s143)) +[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s144)) +[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s145)) +[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s146)) +[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s147)) +[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s148)) +[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s149)) +[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s150)) +[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s151)) +[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s152)) +[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s153)) +[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s154)) +[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s155)) +[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s156)) +[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s157)) +[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s158)) +[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s159)) +[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s160)) +[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s161)) +[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s162)) +[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s163)) +[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s164)) +[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s165)) +[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s166)) +[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s167)) +[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s168)) +[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s169)) +[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s170)) +[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s171)) +[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s172)) +[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s173)) +[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s174)) +[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s175)) +[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s176)) +[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s177)) +[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s178)) +[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s179)) +[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s180)) +[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s181)) +[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s182)) +[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s183)) +[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s184)) +[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s185)) +[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s186)) +[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s187)) +[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s188)) +[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s189)) +[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s190)) +[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s191)) +[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s192)) +[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s193)) +[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s194)) +[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s195)) +[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s196)) +[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s197)) +[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s198)) +[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s199)) +[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s200)) +[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s201)) +[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s202)) +[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s203)) +[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s204)) +[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s205)) +[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s206)) +[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s207)) +[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s208)) +[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s209)) +[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s210)) +[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s211)) +[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s212)) +[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s213)) +[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s214)) +[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s215)) +[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s216)) +[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s217)) +[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s218)) +[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s219)) +[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s220)) +[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s221)) +[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s222)) +[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s223)) +[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s224)) +[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s225)) +[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s226)) +[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s227)) +[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s228)) +[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s229)) +[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s230)) +[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s231)) +[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s232)) +[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s233)) +[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s234)) +[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s235)) +[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s236)) +[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s237)) +[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s238)) +[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s239)) +[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s240)) +[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s241)) +[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s242)) +[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s243)) +[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s244)) +[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s245)) +[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s246)) +[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s247)) +[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s248)) +[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s249)) +[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s250)) +[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s251)) +[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s252)) +[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s253)) +[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s254)) +[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s255)) +[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s256)) +[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255)) +[GOOD] (assert table0_initializer) [GOOD] (define-fun s257 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s258 () Bool (= s0 s257)) [GOOD] (assert s258) diff --git a/SBVTestSuite/GoldFiles/queryArrays3.gold b/SBVTestSuite/GoldFiles/queryArrays3.gold --- a/SBVTestSuite/GoldFiles/queryArrays3.gold +++ b/SBVTestSuite/GoldFiles/queryArrays3.gold @@ -20,262 +20,264 @@ [GOOD] ; --- formula --- [GOOD] (define-fun s1 () (_ BitVec 8) #x00) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8)) -[GOOD] (assert (= (table0 #x00) s0)) -[GOOD] (assert (= (table0 #x01) s0)) -[GOOD] (assert (= (table0 #x02) s0)) -[GOOD] (assert (= (table0 #x03) s0)) -[GOOD] (assert (= (table0 #x04) s0)) -[GOOD] (assert (= (table0 #x05) s0)) -[GOOD] (assert (= (table0 #x06) s0)) -[GOOD] (assert (= (table0 #x07) s0)) -[GOOD] (assert (= (table0 #x08) s0)) -[GOOD] (assert (= (table0 #x09) s0)) -[GOOD] (assert (= (table0 #x0a) s0)) -[GOOD] (assert (= (table0 #x0b) s0)) -[GOOD] (assert (= (table0 #x0c) s0)) -[GOOD] (assert (= (table0 #x0d) s0)) -[GOOD] (assert (= (table0 #x0e) s0)) -[GOOD] (assert (= (table0 #x0f) s0)) -[GOOD] (assert (= (table0 #x10) s0)) -[GOOD] (assert (= (table0 #x11) s0)) -[GOOD] (assert (= (table0 #x12) s0)) -[GOOD] (assert (= (table0 #x13) s0)) -[GOOD] (assert (= (table0 #x14) s0)) -[GOOD] (assert (= (table0 #x15) s0)) -[GOOD] (assert (= (table0 #x16) s0)) -[GOOD] (assert (= (table0 #x17) s0)) -[GOOD] (assert (= (table0 #x18) s0)) -[GOOD] (assert (= (table0 #x19) s0)) -[GOOD] (assert (= (table0 #x1a) s0)) -[GOOD] (assert (= (table0 #x1b) s0)) -[GOOD] (assert (= (table0 #x1c) s0)) -[GOOD] (assert (= (table0 #x1d) s0)) -[GOOD] (assert (= (table0 #x1e) s0)) -[GOOD] (assert (= (table0 #x1f) s0)) -[GOOD] (assert (= (table0 #x20) s0)) -[GOOD] (assert (= (table0 #x21) s0)) -[GOOD] (assert (= (table0 #x22) s0)) -[GOOD] (assert (= (table0 #x23) s0)) -[GOOD] (assert (= (table0 #x24) s0)) -[GOOD] (assert (= (table0 #x25) s0)) -[GOOD] (assert (= (table0 #x26) s0)) -[GOOD] (assert (= (table0 #x27) s0)) -[GOOD] (assert (= (table0 #x28) s0)) -[GOOD] (assert (= (table0 #x29) s0)) -[GOOD] (assert (= (table0 #x2a) s0)) -[GOOD] (assert (= (table0 #x2b) s0)) -[GOOD] (assert (= (table0 #x2c) s0)) -[GOOD] (assert (= (table0 #x2d) s0)) -[GOOD] (assert (= (table0 #x2e) s0)) -[GOOD] (assert (= (table0 #x2f) s0)) -[GOOD] (assert (= (table0 #x30) s0)) -[GOOD] (assert (= (table0 #x31) s0)) -[GOOD] (assert (= (table0 #x32) s0)) -[GOOD] (assert (= (table0 #x33) s0)) -[GOOD] (assert (= (table0 #x34) s0)) -[GOOD] (assert (= (table0 #x35) s0)) -[GOOD] (assert (= (table0 #x36) s0)) -[GOOD] (assert (= (table0 #x37) s0)) -[GOOD] (assert (= (table0 #x38) s0)) -[GOOD] (assert (= (table0 #x39) s0)) -[GOOD] (assert (= (table0 #x3a) s0)) -[GOOD] (assert (= (table0 #x3b) s0)) -[GOOD] (assert (= (table0 #x3c) s0)) -[GOOD] (assert (= (table0 #x3d) s0)) -[GOOD] (assert (= (table0 #x3e) s0)) -[GOOD] (assert (= (table0 #x3f) s0)) -[GOOD] (assert (= (table0 #x40) s0)) -[GOOD] (assert (= (table0 #x41) s0)) -[GOOD] (assert (= (table0 #x42) s0)) -[GOOD] (assert (= (table0 #x43) s0)) -[GOOD] (assert (= (table0 #x44) s0)) -[GOOD] (assert (= (table0 #x45) s0)) -[GOOD] (assert (= (table0 #x46) s0)) -[GOOD] (assert (= (table0 #x47) s0)) -[GOOD] (assert (= (table0 #x48) s0)) -[GOOD] (assert (= (table0 #x49) s0)) -[GOOD] (assert (= (table0 #x4a) s0)) -[GOOD] (assert (= (table0 #x4b) s0)) -[GOOD] (assert (= (table0 #x4c) s0)) -[GOOD] (assert (= (table0 #x4d) s0)) -[GOOD] (assert (= (table0 #x4e) s0)) -[GOOD] (assert (= (table0 #x4f) s0)) -[GOOD] (assert (= (table0 #x50) s0)) -[GOOD] (assert (= (table0 #x51) s0)) -[GOOD] (assert (= (table0 #x52) s0)) -[GOOD] (assert (= (table0 #x53) s0)) -[GOOD] (assert (= (table0 #x54) s0)) -[GOOD] (assert (= (table0 #x55) s0)) -[GOOD] (assert (= (table0 #x56) s0)) -[GOOD] (assert (= (table0 #x57) s0)) -[GOOD] (assert (= (table0 #x58) s0)) -[GOOD] (assert (= (table0 #x59) s0)) -[GOOD] (assert (= (table0 #x5a) s0)) -[GOOD] (assert (= (table0 #x5b) s0)) -[GOOD] (assert (= (table0 #x5c) s0)) -[GOOD] (assert (= (table0 #x5d) s0)) -[GOOD] (assert (= (table0 #x5e) s0)) -[GOOD] (assert (= (table0 #x5f) s0)) -[GOOD] (assert (= (table0 #x60) s0)) -[GOOD] (assert (= (table0 #x61) s0)) -[GOOD] (assert (= (table0 #x62) s0)) -[GOOD] (assert (= (table0 #x63) s0)) -[GOOD] (assert (= (table0 #x64) s0)) -[GOOD] (assert (= (table0 #x65) s0)) -[GOOD] (assert (= (table0 #x66) s0)) -[GOOD] (assert (= (table0 #x67) s0)) -[GOOD] (assert (= (table0 #x68) s0)) -[GOOD] (assert (= (table0 #x69) s0)) -[GOOD] (assert (= (table0 #x6a) s0)) -[GOOD] (assert (= (table0 #x6b) s0)) -[GOOD] (assert (= (table0 #x6c) s0)) -[GOOD] (assert (= (table0 #x6d) s0)) -[GOOD] (assert (= (table0 #x6e) s0)) -[GOOD] (assert (= (table0 #x6f) s0)) -[GOOD] (assert (= (table0 #x70) s0)) -[GOOD] (assert (= (table0 #x71) s0)) -[GOOD] (assert (= (table0 #x72) s0)) -[GOOD] (assert (= (table0 #x73) s0)) -[GOOD] (assert (= (table0 #x74) s0)) -[GOOD] (assert (= (table0 #x75) s0)) -[GOOD] (assert (= (table0 #x76) s0)) -[GOOD] (assert (= (table0 #x77) s0)) -[GOOD] (assert (= (table0 #x78) s0)) -[GOOD] (assert (= (table0 #x79) s0)) -[GOOD] (assert (= (table0 #x7a) s0)) -[GOOD] (assert (= (table0 #x7b) s0)) -[GOOD] (assert (= (table0 #x7c) s0)) -[GOOD] (assert (= (table0 #x7d) s0)) -[GOOD] (assert (= (table0 #x7e) s0)) -[GOOD] (assert (= (table0 #x7f) s0)) -[GOOD] (assert (= (table0 #x80) s0)) -[GOOD] (assert (= (table0 #x81) s0)) -[GOOD] (assert (= (table0 #x82) s0)) -[GOOD] (assert (= (table0 #x83) s0)) -[GOOD] (assert (= (table0 #x84) s0)) -[GOOD] (assert (= (table0 #x85) s0)) -[GOOD] (assert (= (table0 #x86) s0)) -[GOOD] (assert (= (table0 #x87) s0)) -[GOOD] (assert (= (table0 #x88) s0)) -[GOOD] (assert (= (table0 #x89) s0)) -[GOOD] (assert (= (table0 #x8a) s0)) -[GOOD] (assert (= (table0 #x8b) s0)) -[GOOD] (assert (= (table0 #x8c) s0)) -[GOOD] (assert (= (table0 #x8d) s0)) -[GOOD] (assert (= (table0 #x8e) s0)) -[GOOD] (assert (= (table0 #x8f) s0)) -[GOOD] (assert (= (table0 #x90) s0)) -[GOOD] (assert (= (table0 #x91) s0)) -[GOOD] (assert (= (table0 #x92) s0)) -[GOOD] (assert (= (table0 #x93) s0)) -[GOOD] (assert (= (table0 #x94) s0)) -[GOOD] (assert (= (table0 #x95) s0)) -[GOOD] (assert (= (table0 #x96) s0)) -[GOOD] (assert (= (table0 #x97) s0)) -[GOOD] (assert (= (table0 #x98) s0)) -[GOOD] (assert (= (table0 #x99) s0)) -[GOOD] (assert (= (table0 #x9a) s0)) -[GOOD] (assert (= (table0 #x9b) s0)) -[GOOD] (assert (= (table0 #x9c) s0)) -[GOOD] (assert (= (table0 #x9d) s0)) -[GOOD] (assert (= (table0 #x9e) s0)) -[GOOD] (assert (= (table0 #x9f) s0)) -[GOOD] (assert (= (table0 #xa0) s0)) -[GOOD] (assert (= (table0 #xa1) s0)) -[GOOD] (assert (= (table0 #xa2) s0)) -[GOOD] (assert (= (table0 #xa3) s0)) -[GOOD] (assert (= (table0 #xa4) s0)) -[GOOD] (assert (= (table0 #xa5) s0)) -[GOOD] (assert (= (table0 #xa6) s0)) -[GOOD] (assert (= (table0 #xa7) s0)) -[GOOD] (assert (= (table0 #xa8) s0)) -[GOOD] (assert (= (table0 #xa9) s0)) -[GOOD] (assert (= (table0 #xaa) s0)) -[GOOD] (assert (= (table0 #xab) s0)) -[GOOD] (assert (= (table0 #xac) s0)) -[GOOD] (assert (= (table0 #xad) s0)) -[GOOD] (assert (= (table0 #xae) s0)) -[GOOD] (assert (= (table0 #xaf) s0)) -[GOOD] (assert (= (table0 #xb0) s0)) -[GOOD] (assert (= (table0 #xb1) s0)) -[GOOD] (assert (= (table0 #xb2) s0)) -[GOOD] (assert (= (table0 #xb3) s0)) -[GOOD] (assert (= (table0 #xb4) s0)) -[GOOD] (assert (= (table0 #xb5) s0)) -[GOOD] (assert (= (table0 #xb6) s0)) -[GOOD] (assert (= (table0 #xb7) s0)) -[GOOD] (assert (= (table0 #xb8) s0)) -[GOOD] (assert (= (table0 #xb9) s0)) -[GOOD] (assert (= (table0 #xba) s0)) -[GOOD] (assert (= (table0 #xbb) s0)) -[GOOD] (assert (= (table0 #xbc) s0)) -[GOOD] (assert (= (table0 #xbd) s0)) -[GOOD] (assert (= (table0 #xbe) s0)) -[GOOD] (assert (= (table0 #xbf) s0)) -[GOOD] (assert (= (table0 #xc0) s0)) -[GOOD] (assert (= (table0 #xc1) s0)) -[GOOD] (assert (= (table0 #xc2) s0)) -[GOOD] (assert (= (table0 #xc3) s0)) -[GOOD] (assert (= (table0 #xc4) s0)) -[GOOD] (assert (= (table0 #xc5) s0)) -[GOOD] (assert (= (table0 #xc6) s0)) -[GOOD] (assert (= (table0 #xc7) s0)) -[GOOD] (assert (= (table0 #xc8) s0)) -[GOOD] (assert (= (table0 #xc9) s0)) -[GOOD] (assert (= (table0 #xca) s0)) -[GOOD] (assert (= (table0 #xcb) s0)) -[GOOD] (assert (= (table0 #xcc) s0)) -[GOOD] (assert (= (table0 #xcd) s0)) -[GOOD] (assert (= (table0 #xce) s0)) -[GOOD] (assert (= (table0 #xcf) s0)) -[GOOD] (assert (= (table0 #xd0) s0)) -[GOOD] (assert (= (table0 #xd1) s0)) -[GOOD] (assert (= (table0 #xd2) s0)) -[GOOD] (assert (= (table0 #xd3) s0)) -[GOOD] (assert (= (table0 #xd4) s0)) -[GOOD] (assert (= (table0 #xd5) s0)) -[GOOD] (assert (= (table0 #xd6) s0)) -[GOOD] (assert (= (table0 #xd7) s0)) -[GOOD] (assert (= (table0 #xd8) s0)) -[GOOD] (assert (= (table0 #xd9) s0)) -[GOOD] (assert (= (table0 #xda) s0)) -[GOOD] (assert (= (table0 #xdb) s0)) -[GOOD] (assert (= (table0 #xdc) s0)) -[GOOD] (assert (= (table0 #xdd) s0)) -[GOOD] (assert (= (table0 #xde) s0)) -[GOOD] (assert (= (table0 #xdf) s0)) -[GOOD] (assert (= (table0 #xe0) s0)) -[GOOD] (assert (= (table0 #xe1) s0)) -[GOOD] (assert (= (table0 #xe2) s0)) -[GOOD] (assert (= (table0 #xe3) s0)) -[GOOD] (assert (= (table0 #xe4) s0)) -[GOOD] (assert (= (table0 #xe5) s0)) -[GOOD] (assert (= (table0 #xe6) s0)) -[GOOD] (assert (= (table0 #xe7) s0)) -[GOOD] (assert (= (table0 #xe8) s0)) -[GOOD] (assert (= (table0 #xe9) s0)) -[GOOD] (assert (= (table0 #xea) s0)) -[GOOD] (assert (= (table0 #xeb) s0)) -[GOOD] (assert (= (table0 #xec) s0)) -[GOOD] (assert (= (table0 #xed) s0)) -[GOOD] (assert (= (table0 #xee) s0)) -[GOOD] (assert (= (table0 #xef) s0)) -[GOOD] (assert (= (table0 #xf0) s0)) -[GOOD] (assert (= (table0 #xf1) s0)) -[GOOD] (assert (= (table0 #xf2) s0)) -[GOOD] (assert (= (table0 #xf3) s0)) -[GOOD] (assert (= (table0 #xf4) s0)) -[GOOD] (assert (= (table0 #xf5) s0)) -[GOOD] (assert (= (table0 #xf6) s0)) -[GOOD] (assert (= (table0 #xf7) s0)) -[GOOD] (assert (= (table0 #xf8) s0)) -[GOOD] (assert (= (table0 #xf9) s0)) -[GOOD] (assert (= (table0 #xfa) s0)) -[GOOD] (assert (= (table0 #xfb) s0)) -[GOOD] (assert (= (table0 #xfc) s0)) -[GOOD] (assert (= (table0 #xfd) s0)) -[GOOD] (assert (= (table0 #xfe) s0)) -[GOOD] (assert (= (table0 #xff) s0)) +[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s0)) +[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s0)) +[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s0)) +[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s0)) +[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s0)) +[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s0)) +[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s0)) +[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s0)) +[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s0)) +[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s0)) +[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s0)) +[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s0)) +[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s0)) +[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s0)) +[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s0)) +[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s0)) +[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s0)) +[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s0)) +[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s0)) +[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s0)) +[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s0)) +[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s0)) +[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s0)) +[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s0)) +[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s0)) +[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s0)) +[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s0)) +[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s0)) +[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s0)) +[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s0)) +[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s0)) +[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s0)) +[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s0)) +[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s0)) +[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s0)) +[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s0)) +[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s0)) +[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s0)) +[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s0)) +[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s0)) +[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s0)) +[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s0)) +[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s0)) +[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s0)) +[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s0)) +[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s0)) +[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s0)) +[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s0)) +[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s0)) +[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s0)) +[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s0)) +[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s0)) +[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s0)) +[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s0)) +[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s0)) +[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s0)) +[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s0)) +[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s0)) +[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s0)) +[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s0)) +[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s0)) +[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s0)) +[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s0)) +[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s0)) +[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s0)) +[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s0)) +[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s0)) +[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s0)) +[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s0)) +[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s0)) +[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s0)) +[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s0)) +[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s0)) +[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s0)) +[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s0)) +[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s0)) +[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s0)) +[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s0)) +[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s0)) +[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s0)) +[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s0)) +[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s0)) +[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s0)) +[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s0)) +[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s0)) +[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s0)) +[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s0)) +[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s0)) +[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s0)) +[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s0)) +[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s0)) +[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s0)) +[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s0)) +[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s0)) +[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s0)) +[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s0)) +[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s0)) +[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s0)) +[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s0)) +[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s0)) +[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s0)) +[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s0)) +[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s0)) +[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s0)) +[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s0)) +[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s0)) +[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s0)) +[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s0)) +[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s0)) +[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s0)) +[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s0)) +[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s0)) +[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s0)) +[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s0)) +[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s0)) +[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s0)) +[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s0)) +[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s0)) +[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s0)) +[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s0)) +[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s0)) +[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s0)) +[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s0)) +[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s0)) +[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s0)) +[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s0)) +[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s0)) +[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s0)) +[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s0)) +[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s0)) +[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s0)) +[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s0)) +[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s0)) +[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s0)) +[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s0)) +[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s0)) +[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s0)) +[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s0)) +[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s0)) +[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s0)) +[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s0)) +[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s0)) +[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s0)) +[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s0)) +[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s0)) +[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s0)) +[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s0)) +[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s0)) +[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s0)) +[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s0)) +[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s0)) +[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s0)) +[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s0)) +[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s0)) +[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s0)) +[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s0)) +[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s0)) +[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s0)) +[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s0)) +[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s0)) +[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s0)) +[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s0)) +[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s0)) +[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s0)) +[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s0)) +[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s0)) +[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s0)) +[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s0)) +[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s0)) +[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s0)) +[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s0)) +[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s0)) +[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s0)) +[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s0)) +[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s0)) +[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s0)) +[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s0)) +[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s0)) +[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s0)) +[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s0)) +[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s0)) +[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s0)) +[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s0)) +[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s0)) +[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s0)) +[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s0)) +[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s0)) +[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s0)) +[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s0)) +[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s0)) +[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s0)) +[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s0)) +[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s0)) +[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s0)) +[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s0)) +[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s0)) +[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s0)) +[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s0)) +[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s0)) +[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s0)) +[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s0)) +[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s0)) +[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s0)) +[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s0)) +[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s0)) +[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s0)) +[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s0)) +[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s0)) +[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s0)) +[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s0)) +[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s0)) +[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s0)) +[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s0)) +[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s0)) +[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s0)) +[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s0)) +[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s0)) +[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s0)) +[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s0)) +[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s0)) +[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s0)) +[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s0)) +[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s0)) +[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s0)) +[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s0)) +[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s0)) +[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s0)) +[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s0)) +[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s0)) +[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s0)) +[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s0)) +[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s0)) +[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s0)) +[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s0)) +[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s0)) +[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s0)) +[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s0)) +[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s0)) +[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s0)) +[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s0)) +[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s0)) +[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s0)) +[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s0)) +[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s0)) +[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s0)) +[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s0)) +[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s0)) +[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s0)) +[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s0)) +[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s0)) +[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s0)) +[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s0)) +[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s0)) +[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s0)) +[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s0)) +[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s0)) +[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255)) +[GOOD] (assert table0_initializer) [GOOD] (define-fun s2 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s3 () Bool (= s0 s2)) [GOOD] (assert s3) diff --git a/SBVTestSuite/GoldFiles/queryArrays4.gold b/SBVTestSuite/GoldFiles/queryArrays4.gold --- a/SBVTestSuite/GoldFiles/queryArrays4.gold +++ b/SBVTestSuite/GoldFiles/queryArrays4.gold @@ -276,262 +276,264 @@ [GOOD] (define-fun s256 () (_ BitVec 8) #xfe) [GOOD] (define-fun s257 () (_ BitVec 8) #xff) [GOOD] (declare-fun table0 ((_ BitVec 8)) (_ BitVec 8)) -[GOOD] (assert (= (table0 #x00) s2)) -[GOOD] (assert (= (table0 #x01) s3)) -[GOOD] (assert (= (table0 #x02) s4)) -[GOOD] (assert (= (table0 #x03) s5)) -[GOOD] (assert (= (table0 #x04) s6)) -[GOOD] (assert (= (table0 #x05) s7)) -[GOOD] (assert (= (table0 #x06) s8)) -[GOOD] (assert (= (table0 #x07) s9)) -[GOOD] (assert (= (table0 #x08) s10)) -[GOOD] (assert (= (table0 #x09) s11)) -[GOOD] (assert (= (table0 #x0a) s12)) -[GOOD] (assert (= (table0 #x0b) s13)) -[GOOD] (assert (= (table0 #x0c) s14)) -[GOOD] (assert (= (table0 #x0d) s15)) -[GOOD] (assert (= (table0 #x0e) s16)) -[GOOD] (assert (= (table0 #x0f) s17)) -[GOOD] (assert (= (table0 #x10) s18)) -[GOOD] (assert (= (table0 #x11) s19)) -[GOOD] (assert (= (table0 #x12) s20)) -[GOOD] (assert (= (table0 #x13) s21)) -[GOOD] (assert (= (table0 #x14) s22)) -[GOOD] (assert (= (table0 #x15) s23)) -[GOOD] (assert (= (table0 #x16) s24)) -[GOOD] (assert (= (table0 #x17) s25)) -[GOOD] (assert (= (table0 #x18) s26)) -[GOOD] (assert (= (table0 #x19) s27)) -[GOOD] (assert (= (table0 #x1a) s28)) -[GOOD] (assert (= (table0 #x1b) s29)) -[GOOD] (assert (= (table0 #x1c) s30)) -[GOOD] (assert (= (table0 #x1d) s31)) -[GOOD] (assert (= (table0 #x1e) s32)) -[GOOD] (assert (= (table0 #x1f) s33)) -[GOOD] (assert (= (table0 #x20) s34)) -[GOOD] (assert (= (table0 #x21) s35)) -[GOOD] (assert (= (table0 #x22) s36)) -[GOOD] (assert (= (table0 #x23) s37)) -[GOOD] (assert (= (table0 #x24) s38)) -[GOOD] (assert (= (table0 #x25) s39)) -[GOOD] (assert (= (table0 #x26) s40)) -[GOOD] (assert (= (table0 #x27) s41)) -[GOOD] (assert (= (table0 #x28) s42)) -[GOOD] (assert (= (table0 #x29) s43)) -[GOOD] (assert (= (table0 #x2a) s44)) -[GOOD] (assert (= (table0 #x2b) s45)) -[GOOD] (assert (= (table0 #x2c) s46)) -[GOOD] (assert (= (table0 #x2d) s47)) -[GOOD] (assert (= (table0 #x2e) s48)) -[GOOD] (assert (= (table0 #x2f) s49)) -[GOOD] (assert (= (table0 #x30) s50)) -[GOOD] (assert (= (table0 #x31) s51)) -[GOOD] (assert (= (table0 #x32) s52)) -[GOOD] (assert (= (table0 #x33) s53)) -[GOOD] (assert (= (table0 #x34) s54)) -[GOOD] (assert (= (table0 #x35) s55)) -[GOOD] (assert (= (table0 #x36) s56)) -[GOOD] (assert (= (table0 #x37) s57)) -[GOOD] (assert (= (table0 #x38) s58)) -[GOOD] (assert (= (table0 #x39) s59)) -[GOOD] (assert (= (table0 #x3a) s60)) -[GOOD] (assert (= (table0 #x3b) s61)) -[GOOD] (assert (= (table0 #x3c) s62)) -[GOOD] (assert (= (table0 #x3d) s63)) -[GOOD] (assert (= (table0 #x3e) s64)) -[GOOD] (assert (= (table0 #x3f) s65)) -[GOOD] (assert (= (table0 #x40) s66)) -[GOOD] (assert (= (table0 #x41) s67)) -[GOOD] (assert (= (table0 #x42) s68)) -[GOOD] (assert (= (table0 #x43) s69)) -[GOOD] (assert (= (table0 #x44) s70)) -[GOOD] (assert (= (table0 #x45) s71)) -[GOOD] (assert (= (table0 #x46) s72)) -[GOOD] (assert (= (table0 #x47) s73)) -[GOOD] (assert (= (table0 #x48) s74)) -[GOOD] (assert (= (table0 #x49) s75)) -[GOOD] (assert (= (table0 #x4a) s76)) -[GOOD] (assert (= (table0 #x4b) s77)) -[GOOD] (assert (= (table0 #x4c) s78)) -[GOOD] (assert (= (table0 #x4d) s79)) -[GOOD] (assert (= (table0 #x4e) s80)) -[GOOD] (assert (= (table0 #x4f) s81)) -[GOOD] (assert (= (table0 #x50) s82)) -[GOOD] (assert (= (table0 #x51) s83)) -[GOOD] (assert (= (table0 #x52) s84)) -[GOOD] (assert (= (table0 #x53) s85)) -[GOOD] (assert (= (table0 #x54) s86)) -[GOOD] (assert (= (table0 #x55) s87)) -[GOOD] (assert (= (table0 #x56) s88)) -[GOOD] (assert (= (table0 #x57) s89)) -[GOOD] (assert (= (table0 #x58) s90)) -[GOOD] (assert (= (table0 #x59) s91)) -[GOOD] (assert (= (table0 #x5a) s92)) -[GOOD] (assert (= (table0 #x5b) s93)) -[GOOD] (assert (= (table0 #x5c) s94)) -[GOOD] (assert (= (table0 #x5d) s95)) -[GOOD] (assert (= (table0 #x5e) s96)) -[GOOD] (assert (= (table0 #x5f) s97)) -[GOOD] (assert (= (table0 #x60) s98)) -[GOOD] (assert (= (table0 #x61) s99)) -[GOOD] (assert (= (table0 #x62) s100)) -[GOOD] (assert (= (table0 #x63) s101)) -[GOOD] (assert (= (table0 #x64) s102)) -[GOOD] (assert (= (table0 #x65) s103)) -[GOOD] (assert (= (table0 #x66) s104)) -[GOOD] (assert (= (table0 #x67) s105)) -[GOOD] (assert (= (table0 #x68) s106)) -[GOOD] (assert (= (table0 #x69) s107)) -[GOOD] (assert (= (table0 #x6a) s108)) -[GOOD] (assert (= (table0 #x6b) s109)) -[GOOD] (assert (= (table0 #x6c) s110)) -[GOOD] (assert (= (table0 #x6d) s111)) -[GOOD] (assert (= (table0 #x6e) s112)) -[GOOD] (assert (= (table0 #x6f) s113)) -[GOOD] (assert (= (table0 #x70) s114)) -[GOOD] (assert (= (table0 #x71) s115)) -[GOOD] (assert (= (table0 #x72) s116)) -[GOOD] (assert (= (table0 #x73) s117)) -[GOOD] (assert (= (table0 #x74) s118)) -[GOOD] (assert (= (table0 #x75) s119)) -[GOOD] (assert (= (table0 #x76) s120)) -[GOOD] (assert (= (table0 #x77) s121)) -[GOOD] (assert (= (table0 #x78) s122)) -[GOOD] (assert (= (table0 #x79) s123)) -[GOOD] (assert (= (table0 #x7a) s124)) -[GOOD] (assert (= (table0 #x7b) s125)) -[GOOD] (assert (= (table0 #x7c) s126)) -[GOOD] (assert (= (table0 #x7d) s127)) -[GOOD] (assert (= (table0 #x7e) s128)) -[GOOD] (assert (= (table0 #x7f) s129)) -[GOOD] (assert (= (table0 #x80) s130)) -[GOOD] (assert (= (table0 #x81) s131)) -[GOOD] (assert (= (table0 #x82) s132)) -[GOOD] (assert (= (table0 #x83) s133)) -[GOOD] (assert (= (table0 #x84) s134)) -[GOOD] (assert (= (table0 #x85) s135)) -[GOOD] (assert (= (table0 #x86) s136)) -[GOOD] (assert (= (table0 #x87) s137)) -[GOOD] (assert (= (table0 #x88) s138)) -[GOOD] (assert (= (table0 #x89) s139)) -[GOOD] (assert (= (table0 #x8a) s140)) -[GOOD] (assert (= (table0 #x8b) s141)) -[GOOD] (assert (= (table0 #x8c) s142)) -[GOOD] (assert (= (table0 #x8d) s143)) -[GOOD] (assert (= (table0 #x8e) s144)) -[GOOD] (assert (= (table0 #x8f) s145)) -[GOOD] (assert (= (table0 #x90) s146)) -[GOOD] (assert (= (table0 #x91) s147)) -[GOOD] (assert (= (table0 #x92) s148)) -[GOOD] (assert (= (table0 #x93) s149)) -[GOOD] (assert (= (table0 #x94) s150)) -[GOOD] (assert (= (table0 #x95) s151)) -[GOOD] (assert (= (table0 #x96) s152)) -[GOOD] (assert (= (table0 #x97) s153)) -[GOOD] (assert (= (table0 #x98) s154)) -[GOOD] (assert (= (table0 #x99) s155)) -[GOOD] (assert (= (table0 #x9a) s156)) -[GOOD] (assert (= (table0 #x9b) s157)) -[GOOD] (assert (= (table0 #x9c) s158)) -[GOOD] (assert (= (table0 #x9d) s159)) -[GOOD] (assert (= (table0 #x9e) s160)) -[GOOD] (assert (= (table0 #x9f) s161)) -[GOOD] (assert (= (table0 #xa0) s162)) -[GOOD] (assert (= (table0 #xa1) s163)) -[GOOD] (assert (= (table0 #xa2) s164)) -[GOOD] (assert (= (table0 #xa3) s165)) -[GOOD] (assert (= (table0 #xa4) s166)) -[GOOD] (assert (= (table0 #xa5) s167)) -[GOOD] (assert (= (table0 #xa6) s168)) -[GOOD] (assert (= (table0 #xa7) s169)) -[GOOD] (assert (= (table0 #xa8) s170)) -[GOOD] (assert (= (table0 #xa9) s171)) -[GOOD] (assert (= (table0 #xaa) s172)) -[GOOD] (assert (= (table0 #xab) s173)) -[GOOD] (assert (= (table0 #xac) s174)) -[GOOD] (assert (= (table0 #xad) s175)) -[GOOD] (assert (= (table0 #xae) s176)) -[GOOD] (assert (= (table0 #xaf) s177)) -[GOOD] (assert (= (table0 #xb0) s178)) -[GOOD] (assert (= (table0 #xb1) s179)) -[GOOD] (assert (= (table0 #xb2) s180)) -[GOOD] (assert (= (table0 #xb3) s181)) -[GOOD] (assert (= (table0 #xb4) s182)) -[GOOD] (assert (= (table0 #xb5) s183)) -[GOOD] (assert (= (table0 #xb6) s184)) -[GOOD] (assert (= (table0 #xb7) s185)) -[GOOD] (assert (= (table0 #xb8) s186)) -[GOOD] (assert (= (table0 #xb9) s187)) -[GOOD] (assert (= (table0 #xba) s188)) -[GOOD] (assert (= (table0 #xbb) s189)) -[GOOD] (assert (= (table0 #xbc) s190)) -[GOOD] (assert (= (table0 #xbd) s191)) -[GOOD] (assert (= (table0 #xbe) s192)) -[GOOD] (assert (= (table0 #xbf) s193)) -[GOOD] (assert (= (table0 #xc0) s194)) -[GOOD] (assert (= (table0 #xc1) s195)) -[GOOD] (assert (= (table0 #xc2) s196)) -[GOOD] (assert (= (table0 #xc3) s197)) -[GOOD] (assert (= (table0 #xc4) s198)) -[GOOD] (assert (= (table0 #xc5) s199)) -[GOOD] (assert (= (table0 #xc6) s200)) -[GOOD] (assert (= (table0 #xc7) s201)) -[GOOD] (assert (= (table0 #xc8) s202)) -[GOOD] (assert (= (table0 #xc9) s203)) -[GOOD] (assert (= (table0 #xca) s204)) -[GOOD] (assert (= (table0 #xcb) s205)) -[GOOD] (assert (= (table0 #xcc) s206)) -[GOOD] (assert (= (table0 #xcd) s207)) -[GOOD] (assert (= (table0 #xce) s208)) -[GOOD] (assert (= (table0 #xcf) s209)) -[GOOD] (assert (= (table0 #xd0) s210)) -[GOOD] (assert (= (table0 #xd1) s211)) -[GOOD] (assert (= (table0 #xd2) s212)) -[GOOD] (assert (= (table0 #xd3) s213)) -[GOOD] (assert (= (table0 #xd4) s214)) -[GOOD] (assert (= (table0 #xd5) s215)) -[GOOD] (assert (= (table0 #xd6) s216)) -[GOOD] (assert (= (table0 #xd7) s217)) -[GOOD] (assert (= (table0 #xd8) s218)) -[GOOD] (assert (= (table0 #xd9) s219)) -[GOOD] (assert (= (table0 #xda) s220)) -[GOOD] (assert (= (table0 #xdb) s221)) -[GOOD] (assert (= (table0 #xdc) s222)) -[GOOD] (assert (= (table0 #xdd) s223)) -[GOOD] (assert (= (table0 #xde) s224)) -[GOOD] (assert (= (table0 #xdf) s225)) -[GOOD] (assert (= (table0 #xe0) s226)) -[GOOD] (assert (= (table0 #xe1) s227)) -[GOOD] (assert (= (table0 #xe2) s228)) -[GOOD] (assert (= (table0 #xe3) s229)) -[GOOD] (assert (= (table0 #xe4) s230)) -[GOOD] (assert (= (table0 #xe5) s231)) -[GOOD] (assert (= (table0 #xe6) s232)) -[GOOD] (assert (= (table0 #xe7) s233)) -[GOOD] (assert (= (table0 #xe8) s234)) -[GOOD] (assert (= (table0 #xe9) s235)) -[GOOD] (assert (= (table0 #xea) s236)) -[GOOD] (assert (= (table0 #xeb) s237)) -[GOOD] (assert (= (table0 #xec) s238)) -[GOOD] (assert (= (table0 #xed) s239)) -[GOOD] (assert (= (table0 #xee) s240)) -[GOOD] (assert (= (table0 #xef) s241)) -[GOOD] (assert (= (table0 #xf0) s242)) -[GOOD] (assert (= (table0 #xf1) s243)) -[GOOD] (assert (= (table0 #xf2) s244)) -[GOOD] (assert (= (table0 #xf3) s245)) -[GOOD] (assert (= (table0 #xf4) s246)) -[GOOD] (assert (= (table0 #xf5) s247)) -[GOOD] (assert (= (table0 #xf6) s248)) -[GOOD] (assert (= (table0 #xf7) s249)) -[GOOD] (assert (= (table0 #xf8) s250)) -[GOOD] (assert (= (table0 #xf9) s251)) -[GOOD] (assert (= (table0 #xfa) s252)) -[GOOD] (assert (= (table0 #xfb) s253)) -[GOOD] (assert (= (table0 #xfc) s254)) -[GOOD] (assert (= (table0 #xfd) s255)) -[GOOD] (assert (= (table0 #xfe) s256)) -[GOOD] (assert (= (table0 #xff) s257)) +[GOOD] (define-fun table0_initializer_0 () Bool (= (table0 #x00) s2)) +[GOOD] (define-fun table0_initializer_1 () Bool (= (table0 #x01) s3)) +[GOOD] (define-fun table0_initializer_2 () Bool (= (table0 #x02) s4)) +[GOOD] (define-fun table0_initializer_3 () Bool (= (table0 #x03) s5)) +[GOOD] (define-fun table0_initializer_4 () Bool (= (table0 #x04) s6)) +[GOOD] (define-fun table0_initializer_5 () Bool (= (table0 #x05) s7)) +[GOOD] (define-fun table0_initializer_6 () Bool (= (table0 #x06) s8)) +[GOOD] (define-fun table0_initializer_7 () Bool (= (table0 #x07) s9)) +[GOOD] (define-fun table0_initializer_8 () Bool (= (table0 #x08) s10)) +[GOOD] (define-fun table0_initializer_9 () Bool (= (table0 #x09) s11)) +[GOOD] (define-fun table0_initializer_10 () Bool (= (table0 #x0a) s12)) +[GOOD] (define-fun table0_initializer_11 () Bool (= (table0 #x0b) s13)) +[GOOD] (define-fun table0_initializer_12 () Bool (= (table0 #x0c) s14)) +[GOOD] (define-fun table0_initializer_13 () Bool (= (table0 #x0d) s15)) +[GOOD] (define-fun table0_initializer_14 () Bool (= (table0 #x0e) s16)) +[GOOD] (define-fun table0_initializer_15 () Bool (= (table0 #x0f) s17)) +[GOOD] (define-fun table0_initializer_16 () Bool (= (table0 #x10) s18)) +[GOOD] (define-fun table0_initializer_17 () Bool (= (table0 #x11) s19)) +[GOOD] (define-fun table0_initializer_18 () Bool (= (table0 #x12) s20)) +[GOOD] (define-fun table0_initializer_19 () Bool (= (table0 #x13) s21)) +[GOOD] (define-fun table0_initializer_20 () Bool (= (table0 #x14) s22)) +[GOOD] (define-fun table0_initializer_21 () Bool (= (table0 #x15) s23)) +[GOOD] (define-fun table0_initializer_22 () Bool (= (table0 #x16) s24)) +[GOOD] (define-fun table0_initializer_23 () Bool (= (table0 #x17) s25)) +[GOOD] (define-fun table0_initializer_24 () Bool (= (table0 #x18) s26)) +[GOOD] (define-fun table0_initializer_25 () Bool (= (table0 #x19) s27)) +[GOOD] (define-fun table0_initializer_26 () Bool (= (table0 #x1a) s28)) +[GOOD] (define-fun table0_initializer_27 () Bool (= (table0 #x1b) s29)) +[GOOD] (define-fun table0_initializer_28 () Bool (= (table0 #x1c) s30)) +[GOOD] (define-fun table0_initializer_29 () Bool (= (table0 #x1d) s31)) +[GOOD] (define-fun table0_initializer_30 () Bool (= (table0 #x1e) s32)) +[GOOD] (define-fun table0_initializer_31 () Bool (= (table0 #x1f) s33)) +[GOOD] (define-fun table0_initializer_32 () Bool (= (table0 #x20) s34)) +[GOOD] (define-fun table0_initializer_33 () Bool (= (table0 #x21) s35)) +[GOOD] (define-fun table0_initializer_34 () Bool (= (table0 #x22) s36)) +[GOOD] (define-fun table0_initializer_35 () Bool (= (table0 #x23) s37)) +[GOOD] (define-fun table0_initializer_36 () Bool (= (table0 #x24) s38)) +[GOOD] (define-fun table0_initializer_37 () Bool (= (table0 #x25) s39)) +[GOOD] (define-fun table0_initializer_38 () Bool (= (table0 #x26) s40)) +[GOOD] (define-fun table0_initializer_39 () Bool (= (table0 #x27) s41)) +[GOOD] (define-fun table0_initializer_40 () Bool (= (table0 #x28) s42)) +[GOOD] (define-fun table0_initializer_41 () Bool (= (table0 #x29) s43)) +[GOOD] (define-fun table0_initializer_42 () Bool (= (table0 #x2a) s44)) +[GOOD] (define-fun table0_initializer_43 () Bool (= (table0 #x2b) s45)) +[GOOD] (define-fun table0_initializer_44 () Bool (= (table0 #x2c) s46)) +[GOOD] (define-fun table0_initializer_45 () Bool (= (table0 #x2d) s47)) +[GOOD] (define-fun table0_initializer_46 () Bool (= (table0 #x2e) s48)) +[GOOD] (define-fun table0_initializer_47 () Bool (= (table0 #x2f) s49)) +[GOOD] (define-fun table0_initializer_48 () Bool (= (table0 #x30) s50)) +[GOOD] (define-fun table0_initializer_49 () Bool (= (table0 #x31) s51)) +[GOOD] (define-fun table0_initializer_50 () Bool (= (table0 #x32) s52)) +[GOOD] (define-fun table0_initializer_51 () Bool (= (table0 #x33) s53)) +[GOOD] (define-fun table0_initializer_52 () Bool (= (table0 #x34) s54)) +[GOOD] (define-fun table0_initializer_53 () Bool (= (table0 #x35) s55)) +[GOOD] (define-fun table0_initializer_54 () Bool (= (table0 #x36) s56)) +[GOOD] (define-fun table0_initializer_55 () Bool (= (table0 #x37) s57)) +[GOOD] (define-fun table0_initializer_56 () Bool (= (table0 #x38) s58)) +[GOOD] (define-fun table0_initializer_57 () Bool (= (table0 #x39) s59)) +[GOOD] (define-fun table0_initializer_58 () Bool (= (table0 #x3a) s60)) +[GOOD] (define-fun table0_initializer_59 () Bool (= (table0 #x3b) s61)) +[GOOD] (define-fun table0_initializer_60 () Bool (= (table0 #x3c) s62)) +[GOOD] (define-fun table0_initializer_61 () Bool (= (table0 #x3d) s63)) +[GOOD] (define-fun table0_initializer_62 () Bool (= (table0 #x3e) s64)) +[GOOD] (define-fun table0_initializer_63 () Bool (= (table0 #x3f) s65)) +[GOOD] (define-fun table0_initializer_64 () Bool (= (table0 #x40) s66)) +[GOOD] (define-fun table0_initializer_65 () Bool (= (table0 #x41) s67)) +[GOOD] (define-fun table0_initializer_66 () Bool (= (table0 #x42) s68)) +[GOOD] (define-fun table0_initializer_67 () Bool (= (table0 #x43) s69)) +[GOOD] (define-fun table0_initializer_68 () Bool (= (table0 #x44) s70)) +[GOOD] (define-fun table0_initializer_69 () Bool (= (table0 #x45) s71)) +[GOOD] (define-fun table0_initializer_70 () Bool (= (table0 #x46) s72)) +[GOOD] (define-fun table0_initializer_71 () Bool (= (table0 #x47) s73)) +[GOOD] (define-fun table0_initializer_72 () Bool (= (table0 #x48) s74)) +[GOOD] (define-fun table0_initializer_73 () Bool (= (table0 #x49) s75)) +[GOOD] (define-fun table0_initializer_74 () Bool (= (table0 #x4a) s76)) +[GOOD] (define-fun table0_initializer_75 () Bool (= (table0 #x4b) s77)) +[GOOD] (define-fun table0_initializer_76 () Bool (= (table0 #x4c) s78)) +[GOOD] (define-fun table0_initializer_77 () Bool (= (table0 #x4d) s79)) +[GOOD] (define-fun table0_initializer_78 () Bool (= (table0 #x4e) s80)) +[GOOD] (define-fun table0_initializer_79 () Bool (= (table0 #x4f) s81)) +[GOOD] (define-fun table0_initializer_80 () Bool (= (table0 #x50) s82)) +[GOOD] (define-fun table0_initializer_81 () Bool (= (table0 #x51) s83)) +[GOOD] (define-fun table0_initializer_82 () Bool (= (table0 #x52) s84)) +[GOOD] (define-fun table0_initializer_83 () Bool (= (table0 #x53) s85)) +[GOOD] (define-fun table0_initializer_84 () Bool (= (table0 #x54) s86)) +[GOOD] (define-fun table0_initializer_85 () Bool (= (table0 #x55) s87)) +[GOOD] (define-fun table0_initializer_86 () Bool (= (table0 #x56) s88)) +[GOOD] (define-fun table0_initializer_87 () Bool (= (table0 #x57) s89)) +[GOOD] (define-fun table0_initializer_88 () Bool (= (table0 #x58) s90)) +[GOOD] (define-fun table0_initializer_89 () Bool (= (table0 #x59) s91)) +[GOOD] (define-fun table0_initializer_90 () Bool (= (table0 #x5a) s92)) +[GOOD] (define-fun table0_initializer_91 () Bool (= (table0 #x5b) s93)) +[GOOD] (define-fun table0_initializer_92 () Bool (= (table0 #x5c) s94)) +[GOOD] (define-fun table0_initializer_93 () Bool (= (table0 #x5d) s95)) +[GOOD] (define-fun table0_initializer_94 () Bool (= (table0 #x5e) s96)) +[GOOD] (define-fun table0_initializer_95 () Bool (= (table0 #x5f) s97)) +[GOOD] (define-fun table0_initializer_96 () Bool (= (table0 #x60) s98)) +[GOOD] (define-fun table0_initializer_97 () Bool (= (table0 #x61) s99)) +[GOOD] (define-fun table0_initializer_98 () Bool (= (table0 #x62) s100)) +[GOOD] (define-fun table0_initializer_99 () Bool (= (table0 #x63) s101)) +[GOOD] (define-fun table0_initializer_100 () Bool (= (table0 #x64) s102)) +[GOOD] (define-fun table0_initializer_101 () Bool (= (table0 #x65) s103)) +[GOOD] (define-fun table0_initializer_102 () Bool (= (table0 #x66) s104)) +[GOOD] (define-fun table0_initializer_103 () Bool (= (table0 #x67) s105)) +[GOOD] (define-fun table0_initializer_104 () Bool (= (table0 #x68) s106)) +[GOOD] (define-fun table0_initializer_105 () Bool (= (table0 #x69) s107)) +[GOOD] (define-fun table0_initializer_106 () Bool (= (table0 #x6a) s108)) +[GOOD] (define-fun table0_initializer_107 () Bool (= (table0 #x6b) s109)) +[GOOD] (define-fun table0_initializer_108 () Bool (= (table0 #x6c) s110)) +[GOOD] (define-fun table0_initializer_109 () Bool (= (table0 #x6d) s111)) +[GOOD] (define-fun table0_initializer_110 () Bool (= (table0 #x6e) s112)) +[GOOD] (define-fun table0_initializer_111 () Bool (= (table0 #x6f) s113)) +[GOOD] (define-fun table0_initializer_112 () Bool (= (table0 #x70) s114)) +[GOOD] (define-fun table0_initializer_113 () Bool (= (table0 #x71) s115)) +[GOOD] (define-fun table0_initializer_114 () Bool (= (table0 #x72) s116)) +[GOOD] (define-fun table0_initializer_115 () Bool (= (table0 #x73) s117)) +[GOOD] (define-fun table0_initializer_116 () Bool (= (table0 #x74) s118)) +[GOOD] (define-fun table0_initializer_117 () Bool (= (table0 #x75) s119)) +[GOOD] (define-fun table0_initializer_118 () Bool (= (table0 #x76) s120)) +[GOOD] (define-fun table0_initializer_119 () Bool (= (table0 #x77) s121)) +[GOOD] (define-fun table0_initializer_120 () Bool (= (table0 #x78) s122)) +[GOOD] (define-fun table0_initializer_121 () Bool (= (table0 #x79) s123)) +[GOOD] (define-fun table0_initializer_122 () Bool (= (table0 #x7a) s124)) +[GOOD] (define-fun table0_initializer_123 () Bool (= (table0 #x7b) s125)) +[GOOD] (define-fun table0_initializer_124 () Bool (= (table0 #x7c) s126)) +[GOOD] (define-fun table0_initializer_125 () Bool (= (table0 #x7d) s127)) +[GOOD] (define-fun table0_initializer_126 () Bool (= (table0 #x7e) s128)) +[GOOD] (define-fun table0_initializer_127 () Bool (= (table0 #x7f) s129)) +[GOOD] (define-fun table0_initializer_128 () Bool (= (table0 #x80) s130)) +[GOOD] (define-fun table0_initializer_129 () Bool (= (table0 #x81) s131)) +[GOOD] (define-fun table0_initializer_130 () Bool (= (table0 #x82) s132)) +[GOOD] (define-fun table0_initializer_131 () Bool (= (table0 #x83) s133)) +[GOOD] (define-fun table0_initializer_132 () Bool (= (table0 #x84) s134)) +[GOOD] (define-fun table0_initializer_133 () Bool (= (table0 #x85) s135)) +[GOOD] (define-fun table0_initializer_134 () Bool (= (table0 #x86) s136)) +[GOOD] (define-fun table0_initializer_135 () Bool (= (table0 #x87) s137)) +[GOOD] (define-fun table0_initializer_136 () Bool (= (table0 #x88) s138)) +[GOOD] (define-fun table0_initializer_137 () Bool (= (table0 #x89) s139)) +[GOOD] (define-fun table0_initializer_138 () Bool (= (table0 #x8a) s140)) +[GOOD] (define-fun table0_initializer_139 () Bool (= (table0 #x8b) s141)) +[GOOD] (define-fun table0_initializer_140 () Bool (= (table0 #x8c) s142)) +[GOOD] (define-fun table0_initializer_141 () Bool (= (table0 #x8d) s143)) +[GOOD] (define-fun table0_initializer_142 () Bool (= (table0 #x8e) s144)) +[GOOD] (define-fun table0_initializer_143 () Bool (= (table0 #x8f) s145)) +[GOOD] (define-fun table0_initializer_144 () Bool (= (table0 #x90) s146)) +[GOOD] (define-fun table0_initializer_145 () Bool (= (table0 #x91) s147)) +[GOOD] (define-fun table0_initializer_146 () Bool (= (table0 #x92) s148)) +[GOOD] (define-fun table0_initializer_147 () Bool (= (table0 #x93) s149)) +[GOOD] (define-fun table0_initializer_148 () Bool (= (table0 #x94) s150)) +[GOOD] (define-fun table0_initializer_149 () Bool (= (table0 #x95) s151)) +[GOOD] (define-fun table0_initializer_150 () Bool (= (table0 #x96) s152)) +[GOOD] (define-fun table0_initializer_151 () Bool (= (table0 #x97) s153)) +[GOOD] (define-fun table0_initializer_152 () Bool (= (table0 #x98) s154)) +[GOOD] (define-fun table0_initializer_153 () Bool (= (table0 #x99) s155)) +[GOOD] (define-fun table0_initializer_154 () Bool (= (table0 #x9a) s156)) +[GOOD] (define-fun table0_initializer_155 () Bool (= (table0 #x9b) s157)) +[GOOD] (define-fun table0_initializer_156 () Bool (= (table0 #x9c) s158)) +[GOOD] (define-fun table0_initializer_157 () Bool (= (table0 #x9d) s159)) +[GOOD] (define-fun table0_initializer_158 () Bool (= (table0 #x9e) s160)) +[GOOD] (define-fun table0_initializer_159 () Bool (= (table0 #x9f) s161)) +[GOOD] (define-fun table0_initializer_160 () Bool (= (table0 #xa0) s162)) +[GOOD] (define-fun table0_initializer_161 () Bool (= (table0 #xa1) s163)) +[GOOD] (define-fun table0_initializer_162 () Bool (= (table0 #xa2) s164)) +[GOOD] (define-fun table0_initializer_163 () Bool (= (table0 #xa3) s165)) +[GOOD] (define-fun table0_initializer_164 () Bool (= (table0 #xa4) s166)) +[GOOD] (define-fun table0_initializer_165 () Bool (= (table0 #xa5) s167)) +[GOOD] (define-fun table0_initializer_166 () Bool (= (table0 #xa6) s168)) +[GOOD] (define-fun table0_initializer_167 () Bool (= (table0 #xa7) s169)) +[GOOD] (define-fun table0_initializer_168 () Bool (= (table0 #xa8) s170)) +[GOOD] (define-fun table0_initializer_169 () Bool (= (table0 #xa9) s171)) +[GOOD] (define-fun table0_initializer_170 () Bool (= (table0 #xaa) s172)) +[GOOD] (define-fun table0_initializer_171 () Bool (= (table0 #xab) s173)) +[GOOD] (define-fun table0_initializer_172 () Bool (= (table0 #xac) s174)) +[GOOD] (define-fun table0_initializer_173 () Bool (= (table0 #xad) s175)) +[GOOD] (define-fun table0_initializer_174 () Bool (= (table0 #xae) s176)) +[GOOD] (define-fun table0_initializer_175 () Bool (= (table0 #xaf) s177)) +[GOOD] (define-fun table0_initializer_176 () Bool (= (table0 #xb0) s178)) +[GOOD] (define-fun table0_initializer_177 () Bool (= (table0 #xb1) s179)) +[GOOD] (define-fun table0_initializer_178 () Bool (= (table0 #xb2) s180)) +[GOOD] (define-fun table0_initializer_179 () Bool (= (table0 #xb3) s181)) +[GOOD] (define-fun table0_initializer_180 () Bool (= (table0 #xb4) s182)) +[GOOD] (define-fun table0_initializer_181 () Bool (= (table0 #xb5) s183)) +[GOOD] (define-fun table0_initializer_182 () Bool (= (table0 #xb6) s184)) +[GOOD] (define-fun table0_initializer_183 () Bool (= (table0 #xb7) s185)) +[GOOD] (define-fun table0_initializer_184 () Bool (= (table0 #xb8) s186)) +[GOOD] (define-fun table0_initializer_185 () Bool (= (table0 #xb9) s187)) +[GOOD] (define-fun table0_initializer_186 () Bool (= (table0 #xba) s188)) +[GOOD] (define-fun table0_initializer_187 () Bool (= (table0 #xbb) s189)) +[GOOD] (define-fun table0_initializer_188 () Bool (= (table0 #xbc) s190)) +[GOOD] (define-fun table0_initializer_189 () Bool (= (table0 #xbd) s191)) +[GOOD] (define-fun table0_initializer_190 () Bool (= (table0 #xbe) s192)) +[GOOD] (define-fun table0_initializer_191 () Bool (= (table0 #xbf) s193)) +[GOOD] (define-fun table0_initializer_192 () Bool (= (table0 #xc0) s194)) +[GOOD] (define-fun table0_initializer_193 () Bool (= (table0 #xc1) s195)) +[GOOD] (define-fun table0_initializer_194 () Bool (= (table0 #xc2) s196)) +[GOOD] (define-fun table0_initializer_195 () Bool (= (table0 #xc3) s197)) +[GOOD] (define-fun table0_initializer_196 () Bool (= (table0 #xc4) s198)) +[GOOD] (define-fun table0_initializer_197 () Bool (= (table0 #xc5) s199)) +[GOOD] (define-fun table0_initializer_198 () Bool (= (table0 #xc6) s200)) +[GOOD] (define-fun table0_initializer_199 () Bool (= (table0 #xc7) s201)) +[GOOD] (define-fun table0_initializer_200 () Bool (= (table0 #xc8) s202)) +[GOOD] (define-fun table0_initializer_201 () Bool (= (table0 #xc9) s203)) +[GOOD] (define-fun table0_initializer_202 () Bool (= (table0 #xca) s204)) +[GOOD] (define-fun table0_initializer_203 () Bool (= (table0 #xcb) s205)) +[GOOD] (define-fun table0_initializer_204 () Bool (= (table0 #xcc) s206)) +[GOOD] (define-fun table0_initializer_205 () Bool (= (table0 #xcd) s207)) +[GOOD] (define-fun table0_initializer_206 () Bool (= (table0 #xce) s208)) +[GOOD] (define-fun table0_initializer_207 () Bool (= (table0 #xcf) s209)) +[GOOD] (define-fun table0_initializer_208 () Bool (= (table0 #xd0) s210)) +[GOOD] (define-fun table0_initializer_209 () Bool (= (table0 #xd1) s211)) +[GOOD] (define-fun table0_initializer_210 () Bool (= (table0 #xd2) s212)) +[GOOD] (define-fun table0_initializer_211 () Bool (= (table0 #xd3) s213)) +[GOOD] (define-fun table0_initializer_212 () Bool (= (table0 #xd4) s214)) +[GOOD] (define-fun table0_initializer_213 () Bool (= (table0 #xd5) s215)) +[GOOD] (define-fun table0_initializer_214 () Bool (= (table0 #xd6) s216)) +[GOOD] (define-fun table0_initializer_215 () Bool (= (table0 #xd7) s217)) +[GOOD] (define-fun table0_initializer_216 () Bool (= (table0 #xd8) s218)) +[GOOD] (define-fun table0_initializer_217 () Bool (= (table0 #xd9) s219)) +[GOOD] (define-fun table0_initializer_218 () Bool (= (table0 #xda) s220)) +[GOOD] (define-fun table0_initializer_219 () Bool (= (table0 #xdb) s221)) +[GOOD] (define-fun table0_initializer_220 () Bool (= (table0 #xdc) s222)) +[GOOD] (define-fun table0_initializer_221 () Bool (= (table0 #xdd) s223)) +[GOOD] (define-fun table0_initializer_222 () Bool (= (table0 #xde) s224)) +[GOOD] (define-fun table0_initializer_223 () Bool (= (table0 #xdf) s225)) +[GOOD] (define-fun table0_initializer_224 () Bool (= (table0 #xe0) s226)) +[GOOD] (define-fun table0_initializer_225 () Bool (= (table0 #xe1) s227)) +[GOOD] (define-fun table0_initializer_226 () Bool (= (table0 #xe2) s228)) +[GOOD] (define-fun table0_initializer_227 () Bool (= (table0 #xe3) s229)) +[GOOD] (define-fun table0_initializer_228 () Bool (= (table0 #xe4) s230)) +[GOOD] (define-fun table0_initializer_229 () Bool (= (table0 #xe5) s231)) +[GOOD] (define-fun table0_initializer_230 () Bool (= (table0 #xe6) s232)) +[GOOD] (define-fun table0_initializer_231 () Bool (= (table0 #xe7) s233)) +[GOOD] (define-fun table0_initializer_232 () Bool (= (table0 #xe8) s234)) +[GOOD] (define-fun table0_initializer_233 () Bool (= (table0 #xe9) s235)) +[GOOD] (define-fun table0_initializer_234 () Bool (= (table0 #xea) s236)) +[GOOD] (define-fun table0_initializer_235 () Bool (= (table0 #xeb) s237)) +[GOOD] (define-fun table0_initializer_236 () Bool (= (table0 #xec) s238)) +[GOOD] (define-fun table0_initializer_237 () Bool (= (table0 #xed) s239)) +[GOOD] (define-fun table0_initializer_238 () Bool (= (table0 #xee) s240)) +[GOOD] (define-fun table0_initializer_239 () Bool (= (table0 #xef) s241)) +[GOOD] (define-fun table0_initializer_240 () Bool (= (table0 #xf0) s242)) +[GOOD] (define-fun table0_initializer_241 () Bool (= (table0 #xf1) s243)) +[GOOD] (define-fun table0_initializer_242 () Bool (= (table0 #xf2) s244)) +[GOOD] (define-fun table0_initializer_243 () Bool (= (table0 #xf3) s245)) +[GOOD] (define-fun table0_initializer_244 () Bool (= (table0 #xf4) s246)) +[GOOD] (define-fun table0_initializer_245 () Bool (= (table0 #xf5) s247)) +[GOOD] (define-fun table0_initializer_246 () Bool (= (table0 #xf6) s248)) +[GOOD] (define-fun table0_initializer_247 () Bool (= (table0 #xf7) s249)) +[GOOD] (define-fun table0_initializer_248 () Bool (= (table0 #xf8) s250)) +[GOOD] (define-fun table0_initializer_249 () Bool (= (table0 #xf9) s251)) +[GOOD] (define-fun table0_initializer_250 () Bool (= (table0 #xfa) s252)) +[GOOD] (define-fun table0_initializer_251 () Bool (= (table0 #xfb) s253)) +[GOOD] (define-fun table0_initializer_252 () Bool (= (table0 #xfc) s254)) +[GOOD] (define-fun table0_initializer_253 () Bool (= (table0 #xfd) s255)) +[GOOD] (define-fun table0_initializer_254 () Bool (= (table0 #xfe) s256)) +[GOOD] (define-fun table0_initializer_255 () Bool (= (table0 #xff) s257)) +[GOOD] (define-fun table0_initializer () Bool (and table0_initializer_0 table0_initializer_1 table0_initializer_2 table0_initializer_3 table0_initializer_4 table0_initializer_5 table0_initializer_6 table0_initializer_7 table0_initializer_8 table0_initializer_9 table0_initializer_10 table0_initializer_11 table0_initializer_12 table0_initializer_13 table0_initializer_14 table0_initializer_15 table0_initializer_16 table0_initializer_17 table0_initializer_18 table0_initializer_19 table0_initializer_20 table0_initializer_21 table0_initializer_22 table0_initializer_23 table0_initializer_24 table0_initializer_25 table0_initializer_26 table0_initializer_27 table0_initializer_28 table0_initializer_29 table0_initializer_30 table0_initializer_31 table0_initializer_32 table0_initializer_33 table0_initializer_34 table0_initializer_35 table0_initializer_36 table0_initializer_37 table0_initializer_38 table0_initializer_39 table0_initializer_40 table0_initializer_41 table0_initializer_42 table0_initializer_43 table0_initializer_44 table0_initializer_45 table0_initializer_46 table0_initializer_47 table0_initializer_48 table0_initializer_49 table0_initializer_50 table0_initializer_51 table0_initializer_52 table0_initializer_53 table0_initializer_54 table0_initializer_55 table0_initializer_56 table0_initializer_57 table0_initializer_58 table0_initializer_59 table0_initializer_60 table0_initializer_61 table0_initializer_62 table0_initializer_63 table0_initializer_64 table0_initializer_65 table0_initializer_66 table0_initializer_67 table0_initializer_68 table0_initializer_69 table0_initializer_70 table0_initializer_71 table0_initializer_72 table0_initializer_73 table0_initializer_74 table0_initializer_75 table0_initializer_76 table0_initializer_77 table0_initializer_78 table0_initializer_79 table0_initializer_80 table0_initializer_81 table0_initializer_82 table0_initializer_83 table0_initializer_84 table0_initializer_85 table0_initializer_86 table0_initializer_87 table0_initializer_88 table0_initializer_89 table0_initializer_90 table0_initializer_91 table0_initializer_92 table0_initializer_93 table0_initializer_94 table0_initializer_95 table0_initializer_96 table0_initializer_97 table0_initializer_98 table0_initializer_99 table0_initializer_100 table0_initializer_101 table0_initializer_102 table0_initializer_103 table0_initializer_104 table0_initializer_105 table0_initializer_106 table0_initializer_107 table0_initializer_108 table0_initializer_109 table0_initializer_110 table0_initializer_111 table0_initializer_112 table0_initializer_113 table0_initializer_114 table0_initializer_115 table0_initializer_116 table0_initializer_117 table0_initializer_118 table0_initializer_119 table0_initializer_120 table0_initializer_121 table0_initializer_122 table0_initializer_123 table0_initializer_124 table0_initializer_125 table0_initializer_126 table0_initializer_127 table0_initializer_128 table0_initializer_129 table0_initializer_130 table0_initializer_131 table0_initializer_132 table0_initializer_133 table0_initializer_134 table0_initializer_135 table0_initializer_136 table0_initializer_137 table0_initializer_138 table0_initializer_139 table0_initializer_140 table0_initializer_141 table0_initializer_142 table0_initializer_143 table0_initializer_144 table0_initializer_145 table0_initializer_146 table0_initializer_147 table0_initializer_148 table0_initializer_149 table0_initializer_150 table0_initializer_151 table0_initializer_152 table0_initializer_153 table0_initializer_154 table0_initializer_155 table0_initializer_156 table0_initializer_157 table0_initializer_158 table0_initializer_159 table0_initializer_160 table0_initializer_161 table0_initializer_162 table0_initializer_163 table0_initializer_164 table0_initializer_165 table0_initializer_166 table0_initializer_167 table0_initializer_168 table0_initializer_169 table0_initializer_170 table0_initializer_171 table0_initializer_172 table0_initializer_173 table0_initializer_174 table0_initializer_175 table0_initializer_176 table0_initializer_177 table0_initializer_178 table0_initializer_179 table0_initializer_180 table0_initializer_181 table0_initializer_182 table0_initializer_183 table0_initializer_184 table0_initializer_185 table0_initializer_186 table0_initializer_187 table0_initializer_188 table0_initializer_189 table0_initializer_190 table0_initializer_191 table0_initializer_192 table0_initializer_193 table0_initializer_194 table0_initializer_195 table0_initializer_196 table0_initializer_197 table0_initializer_198 table0_initializer_199 table0_initializer_200 table0_initializer_201 table0_initializer_202 table0_initializer_203 table0_initializer_204 table0_initializer_205 table0_initializer_206 table0_initializer_207 table0_initializer_208 table0_initializer_209 table0_initializer_210 table0_initializer_211 table0_initializer_212 table0_initializer_213 table0_initializer_214 table0_initializer_215 table0_initializer_216 table0_initializer_217 table0_initializer_218 table0_initializer_219 table0_initializer_220 table0_initializer_221 table0_initializer_222 table0_initializer_223 table0_initializer_224 table0_initializer_225 table0_initializer_226 table0_initializer_227 table0_initializer_228 table0_initializer_229 table0_initializer_230 table0_initializer_231 table0_initializer_232 table0_initializer_233 table0_initializer_234 table0_initializer_235 table0_initializer_236 table0_initializer_237 table0_initializer_238 table0_initializer_239 table0_initializer_240 table0_initializer_241 table0_initializer_242 table0_initializer_243 table0_initializer_244 table0_initializer_245 table0_initializer_246 table0_initializer_247 table0_initializer_248 table0_initializer_249 table0_initializer_250 table0_initializer_251 table0_initializer_252 table0_initializer_253 table0_initializer_254 table0_initializer_255)) +[GOOD] (assert table0_initializer) [GOOD] (define-fun s258 () (_ BitVec 8) (table0 s0)) [GOOD] (define-fun s259 () Bool (= s0 s258)) [GOOD] (assert s259) diff --git a/SBVTestSuite/GoldFiles/queryArrays5.gold b/SBVTestSuite/GoldFiles/queryArrays5.gold --- a/SBVTestSuite/GoldFiles/queryArrays5.gold +++ b/SBVTestSuite/GoldFiles/queryArrays5.gold @@ -20,6 +20,7 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user given axioms --- [GOOD] ; --- formula --- +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (define-fun s2 () (_ BitVec 8) #x01) [GOOD] (define-fun s4 () (_ BitVec 8) #x01) [GOOD] (declare-fun array_1 () (Array (_ BitVec 8) (_ BitVec 8))) @@ -28,8 +29,12 @@ [GOOD] (define-fun s5 () (_ BitVec 8) (bvadd s0 s4)) [GOOD] (define-fun s6 () (_ BitVec 8) (select array_2 s5)) [GOOD] (define-fun s7 () Bool (distinct s3 s6)) -[GOOD] (assert (= array_1 (store array_0 s0 s1))) -[GOOD] (assert (= array_2 (store array_1 s5 s3))) +[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1))) +[GOOD] (define-fun array_2_initializer_0 () Bool (= array_2 (store array_1 s5 s3))) +[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0) +[GOOD] (assert array_1_initializer) +[GOOD] (define-fun array_2_initializer () Bool array_2_initializer_0) +[GOOD] (assert array_2_initializer) [GOOD] (assert s7) [SEND] (check-sat) [RECV] unsat diff --git a/SBVTestSuite/GoldFiles/queryArrays6.gold b/SBVTestSuite/GoldFiles/queryArrays6.gold --- a/SBVTestSuite/GoldFiles/queryArrays6.gold +++ b/SBVTestSuite/GoldFiles/queryArrays6.gold @@ -18,6 +18,7 @@ [GOOD] ; --- uninterpreted constants --- [GOOD] ; --- user given axioms --- [GOOD] ; --- formula --- +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed [GOOD] (push 1) [GOOD] (define-fun s0 () Int 1) [GOOD] (define-fun s2 () Int 5) @@ -31,7 +32,7 @@ [SEND] (check-sat) [RECV] unsat [GOOD] (pop 1) -[GOOD] (assert array_1_initializer) +[GOOD] (assert (and array_0_initializer array_1_initializer)) [GOOD] (declare-fun s4 () Int) [GOOD] (define-fun s6 () Int 3) [GOOD] (define-fun s5 () Bool (>= s4 s0)) @@ -50,7 +51,7 @@ [SEND] (check-sat) [RECV] unsat [GOOD] (pop 1) -[GOOD] (assert (and array_1_initializer array_2_initializer)) +[GOOD] (assert (and array_0_initializer array_1_initializer array_2_initializer)) [GOOD] (declare-fun s12 () Int) [GOOD] (define-fun s13 () Bool (>= s12 s0)) [GOOD] (define-fun s14 () Bool (< s12 s6)) diff --git a/SBVTestSuite/GoldFiles/queryArrays7.gold b/SBVTestSuite/GoldFiles/queryArrays7.gold new file mode 100644 --- /dev/null +++ b/SBVTestSuite/GoldFiles/queryArrays7.gold @@ -0,0 +1,43 @@ +** Calling: z3 -nw -in -smt2 +[GOOD] ; Automatically generated by SBV. Do not edit. +[GOOD] (set-option :print-success true) +[GOOD] (set-option :global-declarations true) +[GOOD] (set-option :smtlib2_compliant true) +[GOOD] (set-option :diagnostic-output-channel "stdout") +[GOOD] (set-option :produce-models true) +[GOOD] (set-logic ALL) ; has unbounded values, using catch-all. +[GOOD] ; --- uninterpreted sorts --- +[GOOD] ; --- tuples --- +[GOOD] ; --- sums --- +[GOOD] ; --- literal constants --- +[GOOD] ; --- skolem constants --- +[GOOD] ; --- constant tables --- +[GOOD] ; --- skolemized tables --- +[GOOD] ; --- arrays --- +[GOOD] (declare-fun array_0 () (Array Int Int)) +[GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- user given axioms --- +[GOOD] ; --- formula --- +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed +[GOOD] (define-fun s0 () Int 0) +[GOOD] (define-fun s1 () Int 1) +[GOOD] (define-fun s3 () Int 2) +[GOOD] (declare-fun array_1 () (Array Int Int)) +[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1))) +[GOOD] (define-fun s2 () Int (select array_1 s0)) +[GOOD] (define-fun s4 () Bool (= s2 s3)) +[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0) +[GOOD] (assert array_1_initializer) +[GOOD] (assert s4) +[SEND] (check-sat) +[RECV] unsat +[GOOD] (reset-assertions) +[GOOD] (assert (and array_0_initializer array_1_initializer)) +[GOOD] (assert s4) +[SEND] (check-sat) +[RECV] unsat +*** Solver : Z3 +*** Exit code: ExitSuccess + + FINAL:(Unsat,Unsat) +DONE! diff --git a/SBVTestSuite/GoldFiles/queryArrays8.gold b/SBVTestSuite/GoldFiles/queryArrays8.gold new file mode 100644 --- /dev/null +++ b/SBVTestSuite/GoldFiles/queryArrays8.gold @@ -0,0 +1,43 @@ +** Calling: z3 -nw -in -smt2 +[GOOD] ; Automatically generated by SBV. Do not edit. +[GOOD] (set-option :print-success true) +[GOOD] (set-option :global-declarations true) +[GOOD] (set-option :smtlib2_compliant true) +[GOOD] (set-option :diagnostic-output-channel "stdout") +[GOOD] (set-option :produce-models true) +[GOOD] (set-logic ALL) ; external query, using all logics. +[GOOD] ; --- uninterpreted sorts --- +[GOOD] ; --- tuples --- +[GOOD] ; --- sums --- +[GOOD] ; --- literal constants --- +[GOOD] ; --- skolem constants --- +[GOOD] ; --- constant tables --- +[GOOD] ; --- skolemized tables --- +[GOOD] ; --- arrays --- +[GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- user given axioms --- +[GOOD] ; --- formula --- +[GOOD] (declare-fun array_0 () (Array Int Int)) +[GOOD] (define-fun array_0_initializer () Bool true) ; no initializiation needed +[GOOD] (define-fun s0 () Int 0) +[GOOD] (define-fun s1 () Int 1) +[GOOD] (define-fun s3 () Int 2) +[GOOD] (declare-fun array_1 () (Array Int Int)) +[GOOD] (define-fun array_1_initializer_0 () Bool (= array_1 (store array_0 s0 s1))) +[GOOD] (define-fun s2 () Int (select array_1 s0)) +[GOOD] (define-fun s4 () Bool (= s2 s3)) +[GOOD] (define-fun array_1_initializer () Bool array_1_initializer_0) +[GOOD] (assert array_1_initializer) +[GOOD] (assert s4) +[SEND] (check-sat) +[RECV] unsat +[GOOD] (reset-assertions) +[GOOD] (assert (and array_0_initializer array_1_initializer)) +[GOOD] (assert s4) +[SEND] (check-sat) +[RECV] unsat +*** Solver : Z3 +*** Exit code: ExitSuccess + + FINAL:(Unsat,Unsat) +DONE! diff --git a/SBVTestSuite/GoldFiles/query_Interpolant1.gold b/SBVTestSuite/GoldFiles/query_Interpolant1.gold --- a/SBVTestSuite/GoldFiles/query_Interpolant1.gold +++ b/SBVTestSuite/GoldFiles/query_Interpolant1.gold @@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) -** Backend solver MathSAT does not support global decls. -** Some incremental calls, such as pop, will be limited. +[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-interpolants true) [GOOD] (set-option :produce-models true) diff --git a/SBVTestSuite/GoldFiles/query_Interpolant2.gold b/SBVTestSuite/GoldFiles/query_Interpolant2.gold --- a/SBVTestSuite/GoldFiles/query_Interpolant2.gold +++ b/SBVTestSuite/GoldFiles/query_Interpolant2.gold @@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) -** Backend solver MathSAT does not support global decls. -** Some incremental calls, such as pop, will be limited. +[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-interpolants true) [GOOD] (set-option :produce-models true) diff --git a/SBVTestSuite/GoldFiles/query_cvc4.gold b/SBVTestSuite/GoldFiles/query_cvc4.gold --- a/SBVTestSuite/GoldFiles/query_cvc4.gold +++ b/SBVTestSuite/GoldFiles/query_cvc4.gold @@ -1,4 +1,4 @@ -** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt +** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt --model-witness-value [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) [GOOD] (set-option :global-declarations true) diff --git a/SBVTestSuite/GoldFiles/query_mathsat.gold b/SBVTestSuite/GoldFiles/query_mathsat.gold --- a/SBVTestSuite/GoldFiles/query_mathsat.gold +++ b/SBVTestSuite/GoldFiles/query_mathsat.gold @@ -1,8 +1,7 @@ ** Calling: mathsat -input=smt2 -theory.fp.minmax_zero_mode=4 [GOOD] ; Automatically generated by SBV. Do not edit. [GOOD] (set-option :print-success true) -** Backend solver MathSAT does not support global decls. -** Some incremental calls, such as pop, will be limited. +[GOOD] (set-option :global-declarations true) [GOOD] (set-option :diagnostic-output-channel "stdout") [GOOD] (set-option :produce-models true) [GOOD] (set-logic ALL) ; external query, using all logics. diff --git a/SBVTestSuite/GoldFiles/query_uiSat_test2.gold b/SBVTestSuite/GoldFiles/query_uiSat_test2.gold --- a/SBVTestSuite/GoldFiles/query_uiSat_test2.gold +++ b/SBVTestSuite/GoldFiles/query_uiSat_test2.gold @@ -31,7 +31,7 @@ [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1)))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) diff --git a/SBVTestSuite/GoldFiles/set_tupleSet.gold b/SBVTestSuite/GoldFiles/set_tupleSet.gold --- a/SBVTestSuite/GoldFiles/set_tupleSet.gold +++ b/SBVTestSuite/GoldFiles/set_tupleSet.gold @@ -30,11 +30,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (mkSBVTuple2 (lambda ((x!1 Bool)) (not x!1)) (lambda ((x!1 Bool)) x!1)))) +[RECV] ((s0 (mkSBVTuple2 (lambda ((x!1 Bool)) x!1) (lambda ((x!1 Bool)) (not x!1))))) *** Solver : Z3 *** Exit code: ExitSuccess FINAL: Satisfiable. Model: - s0 = (U - {True},{True}) :: ({Bool}, {Bool}) + s0 = ({True},U - {True}) :: ({Bool}, {Bool}) DONE! diff --git a/SBVTestSuite/GoldFiles/set_uninterp1.gold b/SBVTestSuite/GoldFiles/set_uninterp1.gold --- a/SBVTestSuite/GoldFiles/set_uninterp1.gold +++ b/SBVTestSuite/GoldFiles/set_uninterp1.gold @@ -75,8 +75,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B)))) -[GOOD] (define-fun s16 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) +[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true))) +[GOOD] (define-fun s16 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) [GOOD] (define-fun s17 () Bool (= s0 s16)) [GOOD] (define-fun s18 () Bool (not s17)) [GOOD] (assert s18) @@ -93,8 +93,8 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (store (store ((as const (Array E Bool)) false) C true) B true))) -[GOOD] (define-fun s22 () (Array E Bool) (store (store ((as const (Array E Bool)) false) C true) B true)) +[RECV] ((s0 (lambda ((x!1 E)) (= x!1 B)))) +[GOOD] (define-fun s22 () (Array E Bool) (store ((as const (Array E Bool)) false) B true)) [GOOD] (define-fun s23 () Bool (= s0 s22)) [GOOD] (define-fun s24 () Bool (not s23)) [GOOD] (assert s24) @@ -116,10 +116,10 @@ Solution #5: s0 = {A,C} :: {E} Solution #6: - s0 = {B} :: {E} + s0 = {B,C} :: {E} Solution #7: s0 = {C} :: {E} Solution #8: - s0 = {B,C} :: {E} + s0 = {B} :: {E} Found 8 different solutions. DONE! diff --git a/SBVTestSuite/GoldFiles/tuple_swap.gold b/SBVTestSuite/GoldFiles/tuple_swap.gold --- a/SBVTestSuite/GoldFiles/tuple_swap.gold +++ b/SBVTestSuite/GoldFiles/tuple_swap.gold @@ -17,6 +17,10 @@ (proj_3_SBVTuple3 T3)))))) [GOOD] ; --- sums --- [GOOD] ; --- literal constants --- +[GOOD] (define-fun s8 () Int 1) +[GOOD] (define-fun s10 () Int 2) +[GOOD] (define-fun s13 () Int 3) +[GOOD] (define-fun s16 () Int 4) [GOOD] ; --- skolem constants --- [GOOD] (declare-fun s0 () (SBVTuple3 Int Int Int)) ; tracks user variable "abx" [GOOD] (declare-fun s1 () (SBVTuple3 Int Int Int)) ; tracks user variable "bay" @@ -32,16 +36,26 @@ [GOOD] (define-fun s5 () Int (proj_2_SBVTuple3 s0)) [GOOD] (define-fun s6 () Int (proj_1_SBVTuple3 s1)) [GOOD] (define-fun s7 () Bool (= s5 s6)) +[GOOD] (define-fun s9 () Bool (= s2 s8)) +[GOOD] (define-fun s11 () Bool (= s5 s10)) +[GOOD] (define-fun s12 () Int (proj_3_SBVTuple3 s0)) +[GOOD] (define-fun s14 () Bool (= s12 s13)) +[GOOD] (define-fun s15 () Int (proj_3_SBVTuple3 s1)) +[GOOD] (define-fun s17 () Bool (= s15 s16)) [GOOD] (assert s4) [GOOD] (assert s7) +[GOOD] (assert s9) +[GOOD] (assert s11) +[GOOD] (assert s14) +[GOOD] (assert s17) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (mkSBVTuple3 0 7719 1))) +[RECV] ((s0 (mkSBVTuple3 1 2 3))) [SEND] (get-value (s1)) -[RECV] ((s1 (mkSBVTuple3 7719 0 2))) +[RECV] ((s1 (mkSBVTuple3 2 1 4))) *** Solver : Z3 *** Exit code: ExitSuccess - FINAL: ((0,7719,1),(7719,0,2)) + FINAL: ((1,2,3),(2,1,4)) DONE! diff --git a/SBVTestSuite/GoldFiles/uiSat_test2.gold b/SBVTestSuite/GoldFiles/uiSat_test2.gold --- a/SBVTestSuite/GoldFiles/uiSat_test2.gold +++ b/SBVTestSuite/GoldFiles/uiSat_test2.gold @@ -70,7 +70,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1)))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -93,7 +93,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1)))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -116,7 +116,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1)))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -140,7 +140,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -163,7 +163,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!2) x!1) (and x!2 (not x!1)))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -187,7 +187,7 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) x!2))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) false)) [SEND] (get-value ((q2 false true))) @@ -211,18 +211,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) +[RECV] ((q2 (store ((as const Array) true) false true false))) [GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - false) + (ite (and (= x!0 false) (= x!1 true)) false + true) ) [GOOD] (define-fun q2_model10_reject () Bool (exists ((x!0 Bool) (x!1 Bool)) @@ -234,10 +226,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false true false))) +[RECV] ((q2 (store (store ((as const Array) true) false true false) true true false))) [GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false (ite (and (= x!0 false) (= x!1 true)) false - true) + true)) ) [GOOD] (define-fun q2_model11_reject () Bool (exists ((x!0 Bool) (x!1 Bool)) @@ -249,11 +242,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) [GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - (ite (and (= x!0 false) (= x!1 true)) false - true)) + (ite (and (= x!0 false) (= x!1 false)) true + false) ) [GOOD] (define-fun q2_model12_reject () Bool (exists ((x!0 Bool) (x!1 Bool)) @@ -265,19 +265,18 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) - (or (and (not x!2) (not x!1)) (and x!2 (not x!1)))))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2)))))) [SEND] (get-value ((q2 false false))) [RECV] (((q2 false false) true)) [SEND] (get-value ((q2 false true))) [RECV] (((q2 false true) false)) [SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) +[RECV] (((q2 true false) false)) [SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) +[RECV] (((q2 true true) true)) [GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true false)) ) [GOOD] (define-fun q2_model13_reject () Bool @@ -290,10 +289,20 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true false false))) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) + (or (and (not x!1) (not x!2)) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) [GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - true) + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 false) (= x!1 true)) true + false)) ) [GOOD] (define-fun q2_model14_reject () Bool (exists ((x!0 Bool) (x!1 Bool)) @@ -305,11 +314,10 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true false false) true true false))) +[RECV] ((q2 (store ((as const Array) true) true true false))) [GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool (ite (and (= x!0 true) (= x!1 true)) false - (ite (and (= x!0 true) (= x!1 false)) false - true)) + true) ) [GOOD] (define-fun q2_model15_reject () Bool (exists ((x!0 Bool) (x!1 Bool)) @@ -321,9 +329,9 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true true false))) +[RECV] ((q2 (store ((as const Array) true) true false false))) [GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false + (ite (and (= x!0 true) (= x!1 false)) false true) ) [GOOD] (define-fun q2_model16_reject () Bool @@ -377,33 +385,33 @@ q2 _ _ = False Solution #10: q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 _ _ = False + q2 False True = False + q2 _ _ = True Solution #11: q2 :: Bool -> Bool -> Bool + q2 True True = False q2 False True = False q2 _ _ = True Solution #12: q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 False True = False - q2 _ _ = True + q2 False False = True + q2 _ _ = False Solution #13: q2 :: Bool -> Bool -> Bool q2 False False = True - q2 True False = True + q2 True True = True q2 _ _ = False Solution #14: q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 _ _ = True + q2 False False = True + q2 False True = True + q2 _ _ = False Solution #15: q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 True False = False - q2 _ _ = True -Solution #16: - q2 :: Bool -> Bool -> Bool q2 True True = False q2 _ _ = True +Solution #16: + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 _ _ = True Found 16 different solutions. diff --git a/SBVTestSuite/GoldFiles/uiSat_test3.gold b/SBVTestSuite/GoldFiles/uiSat_test3.gold --- a/SBVTestSuite/GoldFiles/uiSat_test3.gold +++ b/SBVTestSuite/GoldFiles/uiSat_test3.gold @@ -164,2378 +164,2387 @@ [SEND] (get-value (q1)) [RECV] ((q1 (lambda ((x!1 Bool)) x!1))) [SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model6 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model6_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model6 x!0)))) -[GOOD] (define-fun q2_model6 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model6_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model6 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_6 () Bool - (or q1_model6_reject - q2_model6_reject - )) -[GOOD] (assert uiFunRejector_model_6) -Looking for solution 7 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model7 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model7_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model7 x!0)))) -[GOOD] (define-fun q2_model7 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model7_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model7 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_7 () Bool - (or q1_model7_reject - q2_model7_reject - )) -[GOOD] (assert uiFunRejector_model_7) -Looking for solution 8 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model8 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model8_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model8 x!0)))) -[GOOD] (define-fun q2_model8 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model8_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model8 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_8 () Bool - (or q1_model8_reject - q2_model8_reject - )) -[GOOD] (assert uiFunRejector_model_8) -Looking for solution 9 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model9_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model9 x!0)))) -[GOOD] (define-fun q2_model9 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model9_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model9 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_9 () Bool - (or q1_model9_reject - q2_model9_reject - )) -[GOOD] (assert uiFunRejector_model_9) -Looking for solution 10 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false true false))) -[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model10_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model10 x!0)))) -[GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model10_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model10 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_10 () Bool - (or q1_model10_reject - q2_model10_reject - )) -[GOOD] (assert uiFunRejector_model_10) -Looking for solution 11 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false true false))) -[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model11_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model11 x!0)))) -[GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model11_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model11 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_11 () Bool - (or q1_model11_reject - q2_model11_reject - )) -[GOOD] (assert uiFunRejector_model_11) -Looking for solution 12 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false true false))) -[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model12_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model12 x!0)))) -[GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model12_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model12 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_12 () Bool - (or q1_model12_reject - q2_model12_reject - )) -[GOOD] (assert uiFunRejector_model_12) -Looking for solution 13 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false))) -[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model13_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model13 x!0)))) -[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - (ite (and (= x!0 false) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model13_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model13 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_13 () Bool - (or q1_model13_reject - q2_model13_reject - )) -[GOOD] (assert uiFunRejector_model_13) -Looking for solution 14 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false true false))) -[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model14_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model14 x!0)))) -[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model14_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model14 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_14 () Bool - (or q1_model14_reject - q2_model14_reject - )) -[GOOD] (assert uiFunRejector_model_14) -Looking for solution 15 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false true false) true true false))) -[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model15_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model15 x!0)))) -[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - (ite (and (= x!0 false) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model15_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model15 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_15 () Bool - (or q1_model15_reject - q2_model15_reject - )) -[GOOD] (assert uiFunRejector_model_15) -Looking for solution 16 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model16_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model16 x!0)))) -[GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model16_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model16 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_16 () Bool - (or q1_model16_reject - q2_model16_reject - )) -[GOOD] (assert uiFunRejector_model_16) -Looking for solution 17 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model17_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model17 x!0)))) -[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model17_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model17 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_17 () Bool - (or q1_model17_reject - q2_model17_reject - )) -[GOOD] (assert uiFunRejector_model_17) -Looking for solution 18 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) - (or (and (not x!2) (not x!1)) (and x!2 (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model18_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model18 x!0)))) -[GOOD] (define-fun q2_model18 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 false)) true - false)) - ) -[GOOD] (define-fun q2_model18_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model18 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_18 () Bool - (or q1_model18_reject - q2_model18_reject - )) -[GOOD] (assert uiFunRejector_model_18) -Looking for solution 19 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) - (or (and (not x!2) (not x!1)) (and x!2 (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model19_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model19 x!0)))) -[GOOD] (define-fun q2_model19 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 false)) true - false)) - ) -[GOOD] (define-fun q2_model19_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model19 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_19 () Bool - (or q1_model19_reject - q2_model19_reject - )) -[GOOD] (assert uiFunRejector_model_19) -Looking for solution 20 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true true false))) -[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model20_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model20 x!0)))) -[GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model20_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model20 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_20 () Bool - (or q1_model20_reject - q2_model20_reject - )) -[GOOD] (assert uiFunRejector_model_20) -Looking for solution 21 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true true false))) -[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model21_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model21 x!0)))) -[GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model21_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model21 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_21 () Bool - (or q1_model21_reject - q2_model21_reject - )) -[GOOD] (assert uiFunRejector_model_21) -Looking for solution 22 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 ((as const Array) true))) -[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model22_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model22 x!0)))) -[GOOD] (define-fun q2_model22 ((x!0 Bool) (x!1 Bool)) Bool - true - ) -[GOOD] (define-fun q2_model22_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model22 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_22 () Bool - (or q1_model22_reject - q2_model22_reject - )) -[GOOD] (assert uiFunRejector_model_22) -Looking for solution 23 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 ((as const Array) true))) -[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model23_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model23 x!0)))) -[GOOD] (define-fun q2_model23 ((x!0 Bool) (x!1 Bool)) Bool - true - ) -[GOOD] (define-fun q2_model23_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model23 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_23 () Bool - (or q1_model23_reject - q2_model23_reject - )) -[GOOD] (assert uiFunRejector_model_23) -Looking for solution 24 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true true false))) -[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model24_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model24 x!0)))) -[GOOD] (define-fun q2_model24 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model24_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model24 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_24 () Bool - (or q1_model24_reject - q2_model24_reject - )) -[GOOD] (assert uiFunRejector_model_24) -Looking for solution 25 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true true false))) -[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model25_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model25 x!0)))) -[GOOD] (define-fun q2_model25 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - true) - ) -[GOOD] (define-fun q2_model25_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model25 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_25 () Bool - (or q1_model25_reject - q2_model25_reject - )) -[GOOD] (assert uiFunRejector_model_25) -Looking for solution 26 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) -[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model26_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model26 x!0)))) -[GOOD] (define-fun q2_model26 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model26_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model26 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_26 () Bool - (or q1_model26_reject - q2_model26_reject - )) -[GOOD] (assert uiFunRejector_model_26) -Looking for solution 27 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 ((as const Array) false))) -[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model27_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model27 x!0)))) -[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool - false - ) -[GOOD] (define-fun q2_model27_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model27 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_27 () Bool - (or q1_model27_reject - q2_model27_reject - )) -[GOOD] (assert uiFunRejector_model_27) -Looking for solution 28 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model28_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model28 x!0)))) -[GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model28_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model28 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_28 () Bool - (or q1_model28_reject - q2_model28_reject - )) -[GOOD] (assert uiFunRejector_model_28) -Looking for solution 29 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model29_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model29 x!0)))) -[GOOD] (define-fun q2_model29 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model29_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model29 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_29 () Bool - (or q1_model29_reject - q2_model29_reject - )) -[GOOD] (assert uiFunRejector_model_29) -Looking for solution 30 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false false false))) -[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model30_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model30 x!0)))) -[GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model30_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model30 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_30 () Bool - (or q1_model30_reject - q2_model30_reject - )) -[GOOD] (assert uiFunRejector_model_30) -Looking for solution 31 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model31_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model31 x!0)))) -[GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model31_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model31 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_31 () Bool - (or q1_model31_reject - q2_model31_reject - )) -[GOOD] (assert uiFunRejector_model_31) -Looking for solution 32 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model32_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model32 x!0)))) -[GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model32_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model32 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_32 () Bool - (or q1_model32_reject - q2_model32_reject - )) -[GOOD] (assert uiFunRejector_model_32) -Looking for solution 33 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model33_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model33 x!0)))) -[GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model33_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model33 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_33 () Bool - (or q1_model33_reject - q2_model33_reject - )) -[GOOD] (assert uiFunRejector_model_33) -Looking for solution 34 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model34_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model34 x!0)))) -[GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model34_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model34 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_34 () Bool - (or q1_model34_reject - q2_model34_reject - )) -[GOOD] (assert uiFunRejector_model_34) -Looking for solution 35 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model35_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model35 x!0)))) -[GOOD] (define-fun q2_model35 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model35_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model35 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_35 () Bool - (or q1_model35_reject - q2_model35_reject - )) -[GOOD] (assert uiFunRejector_model_35) -Looking for solution 36 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model36_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model36 x!0)))) -[GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model36_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model36 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_36 () Bool - (or q1_model36_reject - q2_model36_reject - )) -[GOOD] (assert uiFunRejector_model_36) -Looking for solution 37 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model37_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model37 x!0)))) -[GOOD] (define-fun q2_model37 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model37_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model37 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_37 () Bool - (or q1_model37_reject - q2_model37_reject - )) -[GOOD] (assert uiFunRejector_model_37) -Looking for solution 38 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false false false))) -[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model38_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model38 x!0)))) -[GOOD] (define-fun q2_model38 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model38_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model38 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_38 () Bool - (or q1_model38_reject - q2_model38_reject - )) -[GOOD] (assert uiFunRejector_model_38) -Looking for solution 39 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false false false))) -[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model39_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model39 x!0)))) -[GOOD] (define-fun q2_model39 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model39_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model39 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_39 () Bool - (or q1_model39_reject - q2_model39_reject - )) -[GOOD] (assert uiFunRejector_model_39) -Looking for solution 40 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false))) -[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model40_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model40 x!0)))) -[GOOD] (define-fun q2_model40 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) false - (ite (and (= x!0 false) (= x!1 false)) false - true)) - ) -[GOOD] (define-fun q2_model40_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model40 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_40 () Bool - (or q1_model40_reject - q2_model40_reject - )) -[GOOD] (assert uiFunRejector_model_40) -Looking for solution 41 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!2) x!1) (and x!2 (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model41_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model41 x!0)))) -[GOOD] (define-fun q2_model41 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - (ite (and (= x!0 true) (= x!1 false)) true - false)) - ) -[GOOD] (define-fun q2_model41_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model41 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_41 () Bool - (or q1_model41_reject - q2_model41_reject - )) -[GOOD] (assert uiFunRejector_model_41) -Looking for solution 42 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) false false false))) -[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model42_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model42 x!0)))) -[GOOD] (define-fun q2_model42 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model42_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model42 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_42 () Bool - (or q1_model42_reject - q2_model42_reject - )) -[GOOD] (assert uiFunRejector_model_42) -Looking for solution 43 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false))) -[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model43_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model43 x!0)))) -[GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - (ite (and (= x!0 false) (= x!1 false)) false - true)) - ) -[GOOD] (define-fun q2_model43_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model43 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_43 () Bool - (or q1_model43_reject - q2_model43_reject - )) -[GOOD] (assert uiFunRejector_model_43) -Looking for solution 44 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model44_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model44 x!0)))) -[GOOD] (define-fun q2_model44 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model44_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model44 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_44 () Bool - (or q1_model44_reject - q2_model44_reject - )) -[GOOD] (assert uiFunRejector_model_44) -Looking for solution 45 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model45_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model45 x!0)))) -[GOOD] (define-fun q2_model45 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model45_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model45 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_45 () Bool - (or q1_model45_reject - q2_model45_reject - )) -[GOOD] (assert uiFunRejector_model_45) -Looking for solution 46 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and x!2 (not x!1)))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) true)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model46_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model46 x!0)))) -[GOOD] (define-fun q2_model46 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model46_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model46 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_46 () Bool - (or q1_model46_reject - q2_model46_reject - )) -[GOOD] (assert uiFunRejector_model_46) -Looking for solution 47 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model47_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model47 x!0)))) -[GOOD] (define-fun q2_model47 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model47_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model47 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_47 () Bool - (or q1_model47_reject - q2_model47_reject - )) -[GOOD] (assert uiFunRejector_model_47) -Looking for solution 48 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!2 x!1) (and (not x!2) x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model48_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model48 x!0)))) -[GOOD] (define-fun q2_model48 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - (ite (and (= x!0 true) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model48_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model48 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_48 () Bool - (or q1_model48_reject - q2_model48_reject - )) -[GOOD] (assert uiFunRejector_model_48) -Looking for solution 49 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model49_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model49 x!0)))) -[GOOD] (define-fun q2_model49 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model49_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model49 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_49 () Bool - (or q1_model49_reject - q2_model49_reject - )) -[GOOD] (assert uiFunRejector_model_49) -Looking for solution 50 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) -[SEND] (get-value (q2)) -[RECV] ((q2 ((as const Array) false))) -[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model50_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model50 x!0)))) -[GOOD] (define-fun q2_model50 ((x!0 Bool) (x!1 Bool)) Bool - false - ) -[GOOD] (define-fun q2_model50_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model50 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_50 () Bool - (or q1_model50_reject - q2_model50_reject - )) -[GOOD] (assert uiFunRejector_model_50) -Looking for solution 51 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) (not x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model51_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model51 x!0)))) -[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - false) - ) -[GOOD] (define-fun q2_model51_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model51 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_51 () Bool - (or q1_model51_reject - q2_model51_reject - )) -[GOOD] (assert uiFunRejector_model_51) -Looking for solution 52 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) - (or (and (not x!2) (not x!1)) (and (not x!2) x!1))))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) true)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model52_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model52 x!0)))) -[GOOD] (define-fun q2_model52 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) true - (ite (and (= x!0 false) (= x!1 true)) true - false)) - ) -[GOOD] (define-fun q2_model52_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model52 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_52 () Bool - (or q1_model52_reject - q2_model52_reject - )) -[GOOD] (assert uiFunRejector_model_52) -Looking for solution 53 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) false false false))) -[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model53_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model53 x!0)))) -[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model53_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model53 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_53 () Bool - (or q1_model53_reject - q2_model53_reject - )) -[GOOD] (assert uiFunRejector_model_53) -Looking for solution 54 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) false false false))) -[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model54_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model54 x!0)))) -[GOOD] (define-fun q2_model54 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 false)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model54_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model54 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_54 () Bool - (or q1_model54_reject - q2_model54_reject - )) -[GOOD] (assert uiFunRejector_model_54) -Looking for solution 55 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model55_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model55 x!0)))) -[GOOD] (define-fun q2_model55 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model55_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model55 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_55 () Bool - (or q1_model55_reject - q2_model55_reject - )) -[GOOD] (assert uiFunRejector_model_55) -Looking for solution 56 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false))) -[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model56_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model56 x!0)))) -[GOOD] (define-fun q2_model56 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) false - (ite (and (= x!0 false) (= x!1 false)) false - true)) - ) -[GOOD] (define-fun q2_model56_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model56 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_56 () Bool - (or q1_model56_reject - q2_model56_reject - )) -[GOOD] (assert uiFunRejector_model_56) -Looking for solution 57 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!2 x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) false)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) true)) -[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model57_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model57 x!0)))) -[GOOD] (define-fun q2_model57 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model57_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model57 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_57 () Bool - (or q1_model57_reject - q2_model57_reject - )) -[GOOD] (assert uiFunRejector_model_57) -Looking for solution 58 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!2) x!1)))) -[SEND] (get-value ((q2 false false))) -[RECV] (((q2 false false) false)) -[SEND] (get-value ((q2 false true))) -[RECV] (((q2 false true) true)) -[SEND] (get-value ((q2 true false))) -[RECV] (((q2 true false) false)) -[SEND] (get-value ((q2 true true))) -[RECV] (((q2 true true) false)) -[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model58_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model58 x!0)))) -[GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 false) (= x!1 true)) true - false) - ) -[GOOD] (define-fun q2_model58_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model58 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_58 () Bool - (or q1_model58_reject - q2_model58_reject - )) -[GOOD] (assert uiFunRejector_model_58) -Looking for solution 59 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 ((as const Array) true))) -[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model59_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model59 x!0)))) -[GOOD] (define-fun q2_model59 ((x!0 Bool) (x!1 Bool)) Bool - true - ) -[GOOD] (define-fun q2_model59_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model59 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_59 () Bool - (or q1_model59_reject - q2_model59_reject - )) -[GOOD] (assert uiFunRejector_model_59) -Looking for solution 60 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false))) -[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool - false - ) -[GOOD] (define-fun q1_model60_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model60 x!0)))) -[GOOD] (define-fun q2_model60 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model60_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model60 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_60 () Bool - (or q1_model60_reject - q2_model60_reject - )) -[GOOD] (assert uiFunRejector_model_60) -Looking for solution 61 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false))) -[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) true - false) - ) -[GOOD] (define-fun q1_model61_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model61 x!0)))) -[GOOD] (define-fun q2_model61 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model61_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model61 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_61 () Bool - (or q1_model61_reject - q2_model61_reject - )) -[GOOD] (assert uiFunRejector_model_61) -Looking for solution 62 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store (store ((as const Array) true) true true false) true false false))) -[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model62_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model62 x!0)))) -[GOOD] (define-fun q2_model62 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - (ite (and (= x!0 true) (= x!1 true)) false - true)) - ) -[GOOD] (define-fun q2_model62_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model62 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_62 () Bool - (or q1_model62_reject - q2_model62_reject - )) -[GOOD] (assert uiFunRejector_model_62) -Looking for solution 63 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 (store ((as const Array) true) true false))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true false false))) -[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool - (ite (and (= x!0 true)) false - true) - ) -[GOOD] (define-fun q1_model63_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model63 x!0)))) -[GOOD] (define-fun q2_model63 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model63_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model63 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_63 () Bool - (or q1_model63_reject - q2_model63_reject - )) -[GOOD] (assert uiFunRejector_model_63) -Looking for solution 64 -[SEND] (check-sat) -[RECV] sat -[SEND] (get-value (q1)) -[RECV] ((q1 ((as const Array) true))) -[SEND] (get-value (q2)) -[RECV] ((q2 (store ((as const Array) true) true false false))) -[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool - true - ) -[GOOD] (define-fun q1_model64_reject () Bool - (exists ((x!0 Bool)) - (distinct (q1 x!0) - (q1_model64 x!0)))) -[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool - (ite (and (= x!0 true) (= x!1 false)) false - true) - ) -[GOOD] (define-fun q2_model64_reject () Bool - (exists ((x!0 Bool) (x!1 Bool)) - (distinct (q2 x!0 x!1) - (q2_model64 x!0 x!1)))) -[GOOD] (define-fun uiFunRejector_model_64 () Bool - (or q1_model64_reject - q2_model64_reject - )) -[GOOD] (assert uiFunRejector_model_64) -Looking for solution 65 -[SEND] (check-sat) -[RECV] unsat -*** Solver : Z3 -*** Exit code: ExitSuccess - -RESULT: Solution #1: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 _ _ = False -Solution #2: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 _ _ = False -Solution #3: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 _ _ = True -Solution #4: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 _ _ = True -Solution #5: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 _ _ = True -Solution #6: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 _ _ = False -Solution #7: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 True True = True - q2 _ _ = False -Solution #8: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 True True = True - q2 _ _ = False -Solution #9: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 True True = True - q2 _ _ = False -Solution #10: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 _ _ = True -Solution #11: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 _ _ = True -Solution #12: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 _ _ = True -Solution #13: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 False True = False - q2 _ _ = True -Solution #14: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 _ _ = True -Solution #15: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 False True = False - q2 _ _ = True -Solution #16: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 _ _ = False -Solution #17: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 _ _ = False -Solution #18: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 True False = True - q2 _ _ = False -Solution #19: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 True False = True - q2 _ _ = False -Solution #20: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 _ _ = True -Solution #21: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 _ _ = True -Solution #22: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 _ _ = True -Solution #23: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 _ _ = True -Solution #24: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 _ _ = True -Solution #25: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 _ _ = True -Solution #26: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 True True = False - q2 _ _ = True -Solution #27: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 _ _ = False -Solution #28: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 _ _ = False -Solution #29: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 _ _ = False -Solution #30: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 _ _ = True -Solution #31: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True True = True - q2 _ _ = False -Solution #32: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 _ _ = False -Solution #33: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 _ _ = False -Solution #34: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 True True = True - q2 _ _ = False -Solution #35: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 True True = True - q2 _ _ = False -Solution #36: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 True True = True - q2 _ _ = False -Solution #37: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True True = True - q2 _ _ = False -Solution #38: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 _ _ = True -Solution #39: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 _ _ = True -Solution #40: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True True = False - q2 False False = False - q2 _ _ = True -Solution #41: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 True False = True - q2 _ _ = False -Solution #42: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 _ _ = True -Solution #43: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 False False = False - q2 _ _ = True -Solution #44: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 _ _ = False -Solution #45: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 _ _ = False -Solution #46: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = True - q2 True True = True - q2 _ _ = False -Solution #47: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 True True = True - q2 _ _ = False -Solution #48: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 True True = True - q2 _ _ = False -Solution #49: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True True = True - q2 _ _ = False -Solution #50: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 _ _ = False -Solution #51: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 _ _ = False -Solution #52: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False False = True - q2 False True = True - q2 _ _ = False -Solution #53: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 True True = False - q2 _ _ = True -Solution #54: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False False = False - q2 True True = False - q2 _ _ = True -Solution #55: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 _ _ = False -Solution #56: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 False True = False - q2 False False = False - q2 _ _ = True -Solution #57: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True True = True - q2 _ _ = False -Solution #58: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 False True = True - q2 _ _ = False -Solution #59: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 _ _ = True -Solution #60: - q1 :: Bool -> Bool - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 True True = False - q2 _ _ = True -Solution #61: - q1 :: Bool -> Bool - q1 True = True - q1 _ = False - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 True True = False - q2 _ _ = True -Solution #62: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 True True = False - q2 _ _ = True -Solution #63: - q1 :: Bool -> Bool - q1 True = False - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 _ _ = True -Solution #64: - q1 :: Bool -> Bool - q1 _ = True - - q2 :: Bool -> Bool -> Bool - q2 True False = False - q2 _ _ = True +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model6 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model6_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model6 x!0)))) +[GOOD] (define-fun q2_model6 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model6_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model6 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_6 () Bool + (or q1_model6_reject + q2_model6_reject + )) +[GOOD] (assert uiFunRejector_model_6) +Looking for solution 7 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model7 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model7_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model7 x!0)))) +[GOOD] (define-fun q2_model7 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model7_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model7 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_7 () Bool + (or q1_model7_reject + q2_model7_reject + )) +[GOOD] (assert uiFunRejector_model_7) +Looking for solution 8 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model8 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model8_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model8 x!0)))) +[GOOD] (define-fun q2_model8 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model8_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model8 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_8 () Bool + (or q1_model8_reject + q2_model8_reject + )) +[GOOD] (assert uiFunRejector_model_8) +Looking for solution 9 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model9 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model9_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model9 x!0)))) +[GOOD] (define-fun q2_model9 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model9_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model9 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_9 () Bool + (or q1_model9_reject + q2_model9_reject + )) +[GOOD] (assert uiFunRejector_model_9) +Looking for solution 10 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false true false))) +[GOOD] (define-fun q1_model10 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model10_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model10 x!0)))) +[GOOD] (define-fun q2_model10 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model10_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model10 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_10 () Bool + (or q1_model10_reject + q2_model10_reject + )) +[GOOD] (assert uiFunRejector_model_10) +Looking for solution 11 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false true false))) +[GOOD] (define-fun q1_model11 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model11_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model11 x!0)))) +[GOOD] (define-fun q2_model11 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model11_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model11 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_11 () Bool + (or q1_model11_reject + q2_model11_reject + )) +[GOOD] (assert uiFunRejector_model_11) +Looking for solution 12 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false true false) true false false))) +[GOOD] (define-fun q1_model12 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model12_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model12 x!0)))) +[GOOD] (define-fun q2_model12 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) false + (ite (and (= x!0 false) (= x!1 true)) false + true)) + ) +[GOOD] (define-fun q2_model12_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model12 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_12 () Bool + (or q1_model12_reject + q2_model12_reject + )) +[GOOD] (assert uiFunRejector_model_12) +Looking for solution 13 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false true false))) +[GOOD] (define-fun q1_model13 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model13_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model13 x!0)))) +[GOOD] (define-fun q2_model13 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model13_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model13 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_13 () Bool + (or q1_model13_reject + q2_model13_reject + )) +[GOOD] (assert uiFunRejector_model_13) +Looking for solution 14 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false true false))) +[GOOD] (define-fun q1_model14 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model14_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model14 x!0)))) +[GOOD] (define-fun q2_model14 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model14_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model14 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_14 () Bool + (or q1_model14_reject + q2_model14_reject + )) +[GOOD] (assert uiFunRejector_model_14) +Looking for solution 15 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 ((as const Array) true))) +[GOOD] (define-fun q1_model15 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model15_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model15 x!0)))) +[GOOD] (define-fun q2_model15 ((x!0 Bool) (x!1 Bool)) Bool + true + ) +[GOOD] (define-fun q2_model15_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model15 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_15 () Bool + (or q1_model15_reject + q2_model15_reject + )) +[GOOD] (assert uiFunRejector_model_15) +Looking for solution 16 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 ((as const Array) true))) +[GOOD] (define-fun q1_model16 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model16_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model16 x!0)))) +[GOOD] (define-fun q2_model16 ((x!0 Bool) (x!1 Bool)) Bool + true + ) +[GOOD] (define-fun q2_model16_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model16 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_16 () Bool + (or q1_model16_reject + q2_model16_reject + )) +[GOOD] (assert uiFunRejector_model_16) +Looking for solution 17 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true false false))) +[GOOD] (define-fun q1_model17 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model17_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model17 x!0)))) +[GOOD] (define-fun q2_model17 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model17_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model17 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_17 () Bool + (or q1_model17_reject + q2_model17_reject + )) +[GOOD] (assert uiFunRejector_model_17) +Looking for solution 18 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true false false))) +[GOOD] (define-fun q1_model18 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model18_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model18 x!0)))) +[GOOD] (define-fun q2_model18 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model18_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model18 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_18 () Bool + (or q1_model18_reject + q2_model18_reject + )) +[GOOD] (assert uiFunRejector_model_18) +Looking for solution 19 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 ((as const Array) true))) +[GOOD] (define-fun q1_model19 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model19_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model19 x!0)))) +[GOOD] (define-fun q2_model19 ((x!0 Bool) (x!1 Bool)) Bool + true + ) +[GOOD] (define-fun q2_model19_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model19 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_19 () Bool + (or q1_model19_reject + q2_model19_reject + )) +[GOOD] (assert uiFunRejector_model_19) +Looking for solution 20 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 ((as const Array) false))) +[GOOD] (define-fun q1_model20 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model20_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model20 x!0)))) +[GOOD] (define-fun q2_model20 ((x!0 Bool) (x!1 Bool)) Bool + false + ) +[GOOD] (define-fun q2_model20_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model20 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_20 () Bool + (or q1_model20_reject + q2_model20_reject + )) +[GOOD] (assert uiFunRejector_model_20) +Looking for solution 21 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model21 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model21_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model21 x!0)))) +[GOOD] (define-fun q2_model21 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model21_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model21 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_21 () Bool + (or q1_model21_reject + q2_model21_reject + )) +[GOOD] (assert uiFunRejector_model_21) +Looking for solution 22 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model22 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model22_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model22 x!0)))) +[GOOD] (define-fun q2_model22 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model22_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model22 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_22 () Bool + (or q1_model22_reject + q2_model22_reject + )) +[GOOD] (assert uiFunRejector_model_22) +Looking for solution 23 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false false false))) +[GOOD] (define-fun q1_model23 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model23_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model23 x!0)))) +[GOOD] (define-fun q2_model23 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model23_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model23 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_23 () Bool + (or q1_model23_reject + q2_model23_reject + )) +[GOOD] (assert uiFunRejector_model_23) +Looking for solution 24 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false))) +[GOOD] (define-fun q1_model24 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model24_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model24 x!0)))) +[GOOD] (define-fun q2_model24 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + (ite (and (= x!0 false) (= x!1 false)) false + true)) + ) +[GOOD] (define-fun q2_model24_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model24 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_24 () Bool + (or q1_model24_reject + q2_model24_reject + )) +[GOOD] (assert uiFunRejector_model_24) +Looking for solution 25 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false false false) true false false))) +[GOOD] (define-fun q1_model25 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model25_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model25 x!0)))) +[GOOD] (define-fun q2_model25 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) false + (ite (and (= x!0 false) (= x!1 false)) false + true)) + ) +[GOOD] (define-fun q2_model25_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model25 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_25 () Bool + (or q1_model25_reject + q2_model25_reject + )) +[GOOD] (assert uiFunRejector_model_25) +Looking for solution 26 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model26 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model26_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model26 x!0)))) +[GOOD] (define-fun q2_model26 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model26_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model26 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_26 () Bool + (or q1_model26_reject + q2_model26_reject + )) +[GOOD] (assert uiFunRejector_model_26) +Looking for solution 27 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model27 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model27_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model27 x!0)))) +[GOOD] (define-fun q2_model27 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model27_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model27 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_27 () Bool + (or q1_model27_reject + q2_model27_reject + )) +[GOOD] (assert uiFunRejector_model_27) +Looking for solution 28 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model28 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model28_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model28 x!0)))) +[GOOD] (define-fun q2_model28 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model28_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model28 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_28 () Bool + (or q1_model28_reject + q2_model28_reject + )) +[GOOD] (assert uiFunRejector_model_28) +Looking for solution 29 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model29 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model29_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model29 x!0)))) +[GOOD] (define-fun q2_model29 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model29_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model29 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_29 () Bool + (or q1_model29_reject + q2_model29_reject + )) +[GOOD] (assert uiFunRejector_model_29) +Looking for solution 30 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model30 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model30_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model30 x!0)))) +[GOOD] (define-fun q2_model30 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model30_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model30 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_30 () Bool + (or q1_model30_reject + q2_model30_reject + )) +[GOOD] (assert uiFunRejector_model_30) +Looking for solution 31 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false false false))) +[GOOD] (define-fun q1_model31 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model31_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model31 x!0)))) +[GOOD] (define-fun q2_model31 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model31_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model31 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_31 () Bool + (or q1_model31_reject + q2_model31_reject + )) +[GOOD] (assert uiFunRejector_model_31) +Looking for solution 32 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false false false) true true false))) +[GOOD] (define-fun q1_model32 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model32_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model32 x!0)))) +[GOOD] (define-fun q2_model32 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + (ite (and (= x!0 false) (= x!1 false)) false + true)) + ) +[GOOD] (define-fun q2_model32_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model32 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_32 () Bool + (or q1_model32_reject + q2_model32_reject + )) +[GOOD] (assert uiFunRejector_model_32) +Looking for solution 33 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model33 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model33_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model33 x!0)))) +[GOOD] (define-fun q2_model33 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model33_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model33 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_33 () Bool + (or q1_model33_reject + q2_model33_reject + )) +[GOOD] (assert uiFunRejector_model_33) +Looking for solution 34 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model34 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model34_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model34 x!0)))) +[GOOD] (define-fun q2_model34 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + (ite (and (= x!0 true) (= x!1 false)) true + false)) + ) +[GOOD] (define-fun q2_model34_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model34 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_34 () Bool + (or q1_model34_reject + q2_model34_reject + )) +[GOOD] (assert uiFunRejector_model_34) +Looking for solution 35 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false false false) false true false))) +[GOOD] (define-fun q1_model35 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model35_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model35 x!0)))) +[GOOD] (define-fun q2_model35 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + (ite (and (= x!0 false) (= x!1 false)) false + true)) + ) +[GOOD] (define-fun q2_model35_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model35 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_35 () Bool + (or q1_model35_reject + q2_model35_reject + )) +[GOOD] (assert uiFunRejector_model_35) +Looking for solution 36 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false false false))) +[GOOD] (define-fun q1_model36 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model36_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model36 x!0)))) +[GOOD] (define-fun q2_model36 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model36_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model36 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_36 () Bool + (or q1_model36_reject + q2_model36_reject + )) +[GOOD] (assert uiFunRejector_model_36) +Looking for solution 37 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true true false))) +[GOOD] (define-fun q1_model37 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model37_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model37 x!0)))) +[GOOD] (define-fun q2_model37 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model37_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model37 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_37 () Bool + (or q1_model37_reject + q2_model37_reject + )) +[GOOD] (assert uiFunRejector_model_37) +Looking for solution 38 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) +[GOOD] (define-fun q1_model38 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model38_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model38 x!0)))) +[GOOD] (define-fun q2_model38 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + (ite (and (= x!0 true) (= x!1 true)) false + true)) + ) +[GOOD] (define-fun q2_model38_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model38 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_38 () Bool + (or q1_model38_reject + q2_model38_reject + )) +[GOOD] (assert uiFunRejector_model_38) +Looking for solution 39 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) +[GOOD] (define-fun q1_model39 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model39_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model39 x!0)))) +[GOOD] (define-fun q2_model39 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + (ite (and (= x!0 true) (= x!1 true)) false + true)) + ) +[GOOD] (define-fun q2_model39_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model39 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_39 () Bool + (or q1_model39_reject + q2_model39_reject + )) +[GOOD] (assert uiFunRejector_model_39) +Looking for solution 40 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model40 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model40_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model40 x!0)))) +[GOOD] (define-fun q2_model40 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model40_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model40 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_40 () Bool + (or q1_model40_reject + q2_model40_reject + )) +[GOOD] (assert uiFunRejector_model_40) +Looking for solution 41 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model41 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model41_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model41 x!0)))) +[GOOD] (define-fun q2_model41 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model41_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model41 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_41 () Bool + (or q1_model41_reject + q2_model41_reject + )) +[GOOD] (assert uiFunRejector_model_41) +Looking for solution 42 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model42 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model42_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model42 x!0)))) +[GOOD] (define-fun q2_model42 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model42_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model42 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_42 () Bool + (or q1_model42_reject + q2_model42_reject + )) +[GOOD] (assert uiFunRejector_model_42) +Looking for solution 43 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model43 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model43_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model43 x!0)))) +[GOOD] (define-fun q2_model43 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model43_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model43 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_43 () Bool + (or q1_model43_reject + q2_model43_reject + )) +[GOOD] (assert uiFunRejector_model_43) +Looking for solution 44 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model44 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model44_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model44 x!0)))) +[GOOD] (define-fun q2_model44 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model44_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model44 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_44 () Bool + (or q1_model44_reject + q2_model44_reject + )) +[GOOD] (assert uiFunRejector_model_44) +Looking for solution 45 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model45 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model45_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model45 x!0)))) +[GOOD] (define-fun q2_model45 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model45_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model45 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_45 () Bool + (or q1_model45_reject + q2_model45_reject + )) +[GOOD] (assert uiFunRejector_model_45) +Looking for solution 46 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 ((as const Array) false))) +[GOOD] (define-fun q1_model46 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model46_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model46 x!0)))) +[GOOD] (define-fun q2_model46 ((x!0 Bool) (x!1 Bool)) Bool + false + ) +[GOOD] (define-fun q2_model46_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model46 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_46 () Bool + (or q1_model46_reject + q2_model46_reject + )) +[GOOD] (assert uiFunRejector_model_46) +Looking for solution 47 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and x!1 x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model47 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model47_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model47 x!0)))) +[GOOD] (define-fun q2_model47 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model47_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model47 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_47 () Bool + (or q1_model47_reject + q2_model47_reject + )) +[GOOD] (assert uiFunRejector_model_47) +Looking for solution 48 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and x!1 (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model48 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model48_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model48 x!0)))) +[GOOD] (define-fun q2_model48 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model48_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model48 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_48 () Bool + (or q1_model48_reject + q2_model48_reject + )) +[GOOD] (assert uiFunRejector_model_48) +Looking for solution 49 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model49 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model49_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model49 x!0)))) +[GOOD] (define-fun q2_model49 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model49_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model49 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_49 () Bool + (or q1_model49_reject + q2_model49_reject + )) +[GOOD] (assert uiFunRejector_model_49) +Looking for solution 50 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) x!2)))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model50 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model50_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model50 x!0)))) +[GOOD] (define-fun q2_model50 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + false) + ) +[GOOD] (define-fun q2_model50_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model50 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_50 () Bool + (or q1_model50_reject + q2_model50_reject + )) +[GOOD] (assert uiFunRejector_model_50) +Looking for solution 51 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and x!1 x!2) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) true)) +[GOOD] (define-fun q1_model51 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model51_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model51 x!0)))) +[GOOD] (define-fun q2_model51 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + (ite (and (= x!0 true) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model51_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model51 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_51 () Bool + (or q1_model51_reject + q2_model51_reject + )) +[GOOD] (assert uiFunRejector_model_51) +Looking for solution 52 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (or (and (not x!1) x!2) (and x!1 (not x!2)))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) false)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) true)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model52 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model52_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model52 x!0)))) +[GOOD] (define-fun q2_model52 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) true + (ite (and (= x!0 true) (= x!1 false)) true + false)) + ) +[GOOD] (define-fun q2_model52_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model52 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_52 () Bool + (or q1_model52_reject + q2_model52_reject + )) +[GOOD] (assert uiFunRejector_model_52) +Looking for solution 53 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) false false false))) +[GOOD] (define-fun q1_model53 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model53_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model53 x!0)))) +[GOOD] (define-fun q2_model53 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) false + true) + ) +[GOOD] (define-fun q2_model53_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model53 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_53 () Bool + (or q1_model53_reject + q2_model53_reject + )) +[GOOD] (assert uiFunRejector_model_53) +Looking for solution 54 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) false false false) true false false))) +[GOOD] (define-fun q1_model54 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model54_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model54 x!0)))) +[GOOD] (define-fun q2_model54 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 false)) false + (ite (and (= x!0 false) (= x!1 false)) false + true)) + ) +[GOOD] (define-fun q2_model54_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model54 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_54 () Bool + (or q1_model54_reject + q2_model54_reject + )) +[GOOD] (assert uiFunRejector_model_54) +Looking for solution 55 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) x!1))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) + (or (and (not x!1) (not x!2)) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model55 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) true + false) + ) +[GOOD] (define-fun q1_model55_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model55 x!0)))) +[GOOD] (define-fun q2_model55 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 false) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model55_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model55 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_55 () Bool + (or q1_model55_reject + q2_model55_reject + )) +[GOOD] (assert uiFunRejector_model_55) +Looking for solution 56 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true true false))) +[GOOD] (define-fun q1_model56 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model56_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model56 x!0)))) +[GOOD] (define-fun q2_model56 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model56_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model56 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_56 () Bool + (or q1_model56_reject + q2_model56_reject + )) +[GOOD] (assert uiFunRejector_model_56) +Looking for solution 57 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) true))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) + (or (and (not x!1) (not x!2)) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model57 ((x!0 Bool)) Bool + true + ) +[GOOD] (define-fun q1_model57_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model57 x!0)))) +[GOOD] (define-fun q2_model57 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 false) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model57_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model57 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_57 () Bool + (or q1_model57_reject + q2_model57_reject + )) +[GOOD] (assert uiFunRejector_model_57) +Looking for solution 58 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true true false))) +[GOOD] (define-fun q1_model58 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model58_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model58 x!0)))) +[GOOD] (define-fun q2_model58 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model58_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model58 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_58 () Bool + (or q1_model58_reject + q2_model58_reject + )) +[GOOD] (assert uiFunRejector_model_58) +Looking for solution 59 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (lambda ((x!1 Bool)) (not x!1)))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store ((as const Array) true) true true false))) +[GOOD] (define-fun q1_model59 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model59_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model59 x!0)))) +[GOOD] (define-fun q2_model59 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 true) (= x!1 true)) false + true) + ) +[GOOD] (define-fun q2_model59_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model59 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_59 () Bool + (or q1_model59_reject + q2_model59_reject + )) +[GOOD] (assert uiFunRejector_model_59) +Looking for solution 60 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) +[GOOD] (define-fun q1_model60 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model60_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model60 x!0)))) +[GOOD] (define-fun q2_model60 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + (ite (and (= x!0 true) (= x!1 true)) false + true)) + ) +[GOOD] (define-fun q2_model60_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model60 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_60 () Bool + (or q1_model60_reject + q2_model60_reject + )) +[GOOD] (assert uiFunRejector_model_60) +Looking for solution 61 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 (store ((as const Array) true) true false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) + (or (and (not x!1) (not x!2)) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model61 ((x!0 Bool)) Bool + (ite (and (= x!0 true)) false + true) + ) +[GOOD] (define-fun q1_model61_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model61 x!0)))) +[GOOD] (define-fun q2_model61 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 false) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model61_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model61 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_61 () Bool + (or q1_model61_reject + q2_model61_reject + )) +[GOOD] (assert uiFunRejector_model_61) +Looking for solution 62 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) (and (not x!1) (not x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) false)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model62 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model62_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model62 x!0)))) +[GOOD] (define-fun q2_model62 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + false) + ) +[GOOD] (define-fun q2_model62_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model62 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_62 () Bool + (or q1_model62_reject + q2_model62_reject + )) +[GOOD] (assert uiFunRejector_model_62) +Looking for solution 63 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (store (store ((as const Array) true) true true false) false true false))) +[GOOD] (define-fun q1_model63 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model63_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model63 x!0)))) +[GOOD] (define-fun q2_model63 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 true)) false + (ite (and (= x!0 true) (= x!1 true)) false + true)) + ) +[GOOD] (define-fun q2_model63_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model63 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_63 () Bool + (or q1_model63_reject + q2_model63_reject + )) +[GOOD] (assert uiFunRejector_model_63) +Looking for solution 64 +[SEND] (check-sat) +[RECV] sat +[SEND] (get-value (q1)) +[RECV] ((q1 ((as const Array) false))) +[SEND] (get-value (q2)) +[RECV] ((q2 (lambda ((x!1 Bool) (x!2 Bool)) + (or (and (not x!1) (not x!2)) (and (not x!1) x!2))))) +[SEND] (get-value ((q2 false false))) +[RECV] (((q2 false false) true)) +[SEND] (get-value ((q2 false true))) +[RECV] (((q2 false true) true)) +[SEND] (get-value ((q2 true false))) +[RECV] (((q2 true false) false)) +[SEND] (get-value ((q2 true true))) +[RECV] (((q2 true true) false)) +[GOOD] (define-fun q1_model64 ((x!0 Bool)) Bool + false + ) +[GOOD] (define-fun q1_model64_reject () Bool + (exists ((x!0 Bool)) + (distinct (q1 x!0) + (q1_model64 x!0)))) +[GOOD] (define-fun q2_model64 ((x!0 Bool) (x!1 Bool)) Bool + (ite (and (= x!0 false) (= x!1 false)) true + (ite (and (= x!0 false) (= x!1 true)) true + false)) + ) +[GOOD] (define-fun q2_model64_reject () Bool + (exists ((x!0 Bool) (x!1 Bool)) + (distinct (q2 x!0 x!1) + (q2_model64 x!0 x!1)))) +[GOOD] (define-fun uiFunRejector_model_64 () Bool + (or q1_model64_reject + q2_model64_reject + )) +[GOOD] (assert uiFunRejector_model_64) +Looking for solution 65 +[SEND] (check-sat) +[RECV] unsat +*** Solver : Z3 +*** Exit code: ExitSuccess + +RESULT: Solution #1: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 _ _ = False +Solution #2: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 _ _ = False +Solution #3: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 _ _ = True +Solution #4: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 _ _ = True +Solution #5: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 _ _ = True +Solution #6: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 _ _ = False +Solution #7: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 True True = True + q2 _ _ = False +Solution #8: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 True True = True + q2 _ _ = False +Solution #9: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 True True = True + q2 _ _ = False +Solution #10: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 _ _ = True +Solution #11: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 _ _ = True +Solution #12: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 False True = False + q2 _ _ = True +Solution #13: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 _ _ = True +Solution #14: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 _ _ = True +Solution #15: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 _ _ = True +Solution #16: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 _ _ = True +Solution #17: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 _ _ = True +Solution #18: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 _ _ = True +Solution #19: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 _ _ = True +Solution #20: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 _ _ = False +Solution #21: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 _ _ = False +Solution #22: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 _ _ = False +Solution #23: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = False + q2 _ _ = True +Solution #24: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 False False = False + q2 _ _ = True +Solution #25: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 False False = False + q2 _ _ = True +Solution #26: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = True + q2 _ _ = False +Solution #27: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = True + q2 _ _ = False +Solution #28: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 _ _ = False +Solution #29: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 True True = True + q2 _ _ = False +Solution #30: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 True True = True + q2 _ _ = False +Solution #31: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = False + q2 _ _ = True +Solution #32: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 False False = False + q2 _ _ = True +Solution #33: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 _ _ = False +Solution #34: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 True False = True + q2 _ _ = False +Solution #35: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 False False = False + q2 _ _ = True +Solution #36: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = False + q2 _ _ = True +Solution #37: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 _ _ = True +Solution #38: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 True True = False + q2 _ _ = True +Solution #39: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 True True = False + q2 _ _ = True +Solution #40: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 _ _ = False +Solution #41: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 _ _ = False +Solution #42: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 _ _ = False +Solution #43: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True True = True + q2 _ _ = False +Solution #44: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 _ _ = False +Solution #45: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 _ _ = False +Solution #46: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 _ _ = False +Solution #47: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True True = True + q2 _ _ = False +Solution #48: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True False = True + q2 True True = True + q2 _ _ = False +Solution #49: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 True True = True + q2 _ _ = False +Solution #50: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 _ _ = False +Solution #51: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 True True = True + q2 _ _ = False +Solution #52: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = True + q2 True False = True + q2 _ _ = False +Solution #53: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = False + q2 _ _ = True +Solution #54: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True False = False + q2 False False = False + q2 _ _ = True +Solution #55: + q1 :: Bool -> Bool + q1 True = True + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 False True = True + q2 _ _ = False +Solution #56: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 _ _ = True +Solution #57: + q1 :: Bool -> Bool + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 False True = True + q2 _ _ = False +Solution #58: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 _ _ = True +Solution #59: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 True True = False + q2 _ _ = True +Solution #60: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 True True = False + q2 _ _ = True +Solution #61: + q1 :: Bool -> Bool + q1 True = False + q1 _ = True + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 False True = True + q2 _ _ = False +Solution #62: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 _ _ = False +Solution #63: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False True = False + q2 True True = False + q2 _ _ = True +Solution #64: + q1 :: Bool -> Bool + q1 _ = False + + q2 :: Bool -> Bool -> Bool + q2 False False = True + q2 False True = True + q2 _ _ = False Found 64 different solutions. diff --git a/SBVTestSuite/GoldFiles/unint-axioms-query.gold b/SBVTestSuite/GoldFiles/unint-axioms-query.gold new file mode 100644 --- /dev/null +++ b/SBVTestSuite/GoldFiles/unint-axioms-query.gold @@ -0,0 +1,54 @@ +** Calling: z3 -nw -in -smt2 +[GOOD] ; Automatically generated by SBV. Do not edit. +[GOOD] (set-option :print-success true) +[GOOD] (set-option :global-declarations true) +[GOOD] (set-option :smtlib2_compliant true) +[GOOD] (set-option :diagnostic-output-channel "stdout") +[GOOD] (set-option :produce-models true) +[GOOD] (set-logic ALL) ; has user-defined sorts, using catch-all. +[GOOD] ; --- uninterpreted sorts --- +[GOOD] (declare-sort B 0) ; N.B. Uninterpreted: B.B: not a nullary constructor +[GOOD] ; --- tuples --- +[GOOD] ; --- sums --- +[GOOD] ; --- literal constants --- +[GOOD] ; --- skolem constants --- +[GOOD] (declare-fun s0 () B) ; tracks user variable "p" +[GOOD] (declare-fun s1 () B) ; tracks user variable "q" +[GOOD] (declare-fun s2 () B) ; tracks user variable "r" +[GOOD] ; --- constant tables --- +[GOOD] ; --- skolemized tables --- +[GOOD] ; --- arrays --- +[GOOD] ; --- uninterpreted constants --- +[GOOD] ; --- user given axioms --- +[GOOD] ; --- formula --- +[GOOD] (declare-fun AND (B B) B) +[GOOD] (declare-fun NOT (B) B) +[GOOD] (declare-fun OR (B B) B) +[GOOD] (define-fun s3 () B (AND s1 s2)) +[GOOD] (define-fun s4 () B (OR s0 s3)) +[GOOD] (define-fun s5 () B (NOT s4)) +[GOOD] (define-fun s6 () B (NOT s0)) +[GOOD] (define-fun s7 () B (NOT s1)) +[GOOD] (define-fun s8 () B (AND s6 s7)) +[GOOD] (define-fun s9 () B (NOT s2)) +[GOOD] (define-fun s10 () B (AND s6 s9)) +[GOOD] (define-fun s11 () B (OR s8 s10)) +[GOOD] (define-fun s12 () Bool (distinct s5 s11)) +[GOOD] (assert s12) +[GOOD] ; -- user given axiom: OR distributes over AND +[GOOD] (assert (forall ((p B) (q B) (r B)) + (= (AND (OR p q) (OR p r)) + (OR p (AND q r))))) +[GOOD] ; -- user given axiom: de Morgan +[GOOD] (assert (forall ((p B) (q B)) + (= (NOT (OR p q)) + (AND (NOT p) (NOT q))))) +[GOOD] ; -- user given axiom: double negation +[GOOD] (assert (forall ((p B)) (= (NOT (NOT p)) p))) +[SEND] (check-sat) +[RECV] unsat +*** Solver : Z3 +*** Exit code: ExitSuccess + + FINAL:Unsat +DONE! diff --git a/SBVTestSuite/GoldFiles/validate_1.gold b/SBVTestSuite/GoldFiles/validate_1.gold --- a/SBVTestSuite/GoldFiles/validate_1.gold +++ b/SBVTestSuite/GoldFiles/validate_1.gold @@ -25,11 +25,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (fp #b0 #xfe #b11111111111111111111111))) +[RECV] ((s0 (fp #b1 #xfe #b11111111111111111111111))) *** Solver : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment: -[VALIDATE] x = 3.4028235e38 :: Float +[VALIDATE] x = -3.4028235e38 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -38,7 +38,7 @@ *** *** Assignment: *** -*** x = 3.4028235e38 :: Float +*** x = -3.4028235e38 :: Float *** *** Not all floating point operations are supported concretely. *** @@ -48,4 +48,4 @@ *** Alleged model: *** *** Satisfiable. Model: -*** x = 3.4028235e38 :: Float +*** x = -3.4028235e38 :: Float diff --git a/SBVTestSuite/GoldFiles/validate_2.gold b/SBVTestSuite/GoldFiles/validate_2.gold --- a/SBVTestSuite/GoldFiles/validate_2.gold +++ b/SBVTestSuite/GoldFiles/validate_2.gold @@ -25,11 +25,11 @@ [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) -[RECV] ((s0 (fp #b1 #x01 #b00000000000000000000000))) +[RECV] ((s0 (fp #b0 #x03 #b11011110110000010001000))) *** Solver : Z3 *** Exit code: ExitSuccess [VALIDATE] Validating the model. Assignment: -[VALIDATE] x = -1.1754944e-38 :: Float +[VALIDATE] x = 8.793325e-38 :: Float [VALIDATE] There are no constraints to check. [VALIDATE] Validating outputs. @@ -38,7 +38,7 @@ *** *** Assignment: *** -*** x = -1.1754944e-38 :: Float +*** x = 8.793325e-38 :: Float *** *** Floating point FMA operation is not supported concretely. *** @@ -48,4 +48,4 @@ *** Alleged model: *** *** Satisfiable. Model: -*** x = -1.1754944e-38 :: Float +*** x = 8.793325e-38 :: Float diff --git a/SBVTestSuite/TestSuite/Arrays/Query.hs b/SBVTestSuite/TestSuite/Arrays/Query.hs --- a/SBVTestSuite/TestSuite/Arrays/Query.hs +++ b/SBVTestSuite/TestSuite/Arrays/Query.hs @@ -29,6 +29,8 @@ , goldenCapturedIO "queryArrays4" $ t q4 , goldenCapturedIO "queryArrays5" $ t q5 , goldenCapturedIO "queryArrays6" $ t q6 + , goldenCapturedIO "queryArrays7" $ t q7 + , goldenCapturedIO "queryArrays8" $ t q8 ] where t tc goldFile = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just goldFile} tc appendFile goldFile ("\n FINAL:" ++ show r ++ "\nDONE!\n") @@ -118,5 +120,34 @@ constrain $ d .>= 1 .&& d .< 3 loop (writeArray a 1 (readArray a 1 + d)) (sofar ++ [d]) Sat -> mapM getValue sofar + + +q7 :: Symbolic (CheckSatResult, CheckSatResult) +q7 = do x :: SArray Integer Integer <- newArray "x" Nothing + let y = writeArray x 0 1 + + query $ do constrain $ readArray y 0 .== 2 + r1 <- checkSat + + resetAssertions + + constrain $ readArray y 0 .== 2 + r2 <- checkSat + + pure (r1, r2) + +q8 :: Symbolic (CheckSatResult, CheckSatResult) +q8 = query $ do x :: SArray Integer Integer <- freshArray "x" Nothing + let y = writeArray x 0 1 + + constrain $ readArray y 0 .== 2 + r1 <- checkSat + + resetAssertions + + constrain $ readArray y 0 .== 2 + r2 <- checkSat + + pure (r1, r2) {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} diff --git a/SBVTestSuite/TestSuite/Basics/Tuple.hs b/SBVTestSuite/TestSuite/Basics/Tuple.hs --- a/SBVTestSuite/TestSuite/Basics/Tuple.hs +++ b/SBVTestSuite/TestSuite/Basics/Tuple.hs @@ -52,6 +52,10 @@ [abx, bay] <- sTuples @(Integer, Integer, Integer) ["abx", "bay"] constrain $ abx^._1 .== bay^._2 constrain $ abx^._2 .== bay^._1 + constrain $ abx^._1 .== 1 + constrain $ abx^._2 .== 2 + constrain $ abx^._3 .== 3 + constrain $ bay^._3 .== 4 query $ do _ <- checkSat (,) <$> getValue abx <*> getValue bay @@ -138,4 +142,5 @@ Unsat -> return () _ -> error "did not expect this!" -{-# ANN module ("HLint: ignore Use ." :: String) #-} +{-# ANN module ("HLint: ignore Use ." :: String) #-} +{-# ANN module ("HLint: ignore Redundant ^." :: String) #-} diff --git a/SBVTestSuite/TestSuite/Queries/Tuples.hs b/SBVTestSuite/TestSuite/Queries/Tuples.hs --- a/SBVTestSuite/TestSuite/Queries/Tuples.hs +++ b/SBVTestSuite/TestSuite/Queries/Tuples.hs @@ -64,4 +64,5 @@ then return av else error $ "Didn't expect this: " ++ show av -{-# ANN module ("HLint: ignore Use ." :: String) #-} +{-# ANN module ("HLint: ignore Use ." :: String) #-} +{-# ANN module ("HLint: ignore Redundant ^." :: String) #-} diff --git a/SBVTestSuite/TestSuite/Queries/Uninterpreted.hs b/SBVTestSuite/TestSuite/Queries/Uninterpreted.hs --- a/SBVTestSuite/TestSuite/Queries/Uninterpreted.hs +++ b/SBVTestSuite/TestSuite/Queries/Uninterpreted.hs @@ -38,7 +38,6 @@ instance SymVal L instance HasKind L -instance SMTValue L unint1 :: Symbolic String unint1 = do (x :: SBV L) <- free_ diff --git a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs --- a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs +++ b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs @@ -19,10 +19,14 @@ import Utils.SBVTestFramework import Data.Generics +import Data.SBV.Control + tests :: TestTree tests = testGroup "Uninterpreted.Axioms" - [ testCase "unint-axioms" (assertIsThm p0) ] + [ testCase "unint-axioms" (assertIsThm p0) + , goldenCapturedIO "unint-axioms-query" testQuery + ] -- Example provided by Thomas DuBuisson: newtype Bitstring = Bitstring () deriving (Eq, Ord, Show, Read, Data, SymVal, HasKind) @@ -47,3 +51,29 @@ constrain $ a p constrain $ a k return $ a (e k p) + +newtype B = B () deriving (Eq, Ord, Show, Read, Data, SymVal, HasKind) +type SB = SBV B + +testQuery :: FilePath -> IO () +testQuery rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} t + appendFile rf ("\n FINAL:" ++ show r ++ "\nDONE!\n") + where t = do p <- free "p" + q <- free "q" + r <- free "r" + query $ do let oR, aND :: SB -> SB -> SB + oR = uninterpret "OR" + aND = uninterpret "AND" + nOT :: SB -> SB + nOT = uninterpret "NOT" + constrain $ nOT (p `oR` (q `aND` r)) ./= (nOT p `aND` nOT q) `oR` (nOT p `aND` nOT r) + addAxiom "OR distributes over AND" [ "(assert (forall ((p B) (q B) (r B))" + , " (= (AND (OR p q) (OR p r))" + , " (OR p (AND q r)))))" + ] + addAxiom "de Morgan" [ "(assert (forall ((p B) (q B))" + , " (= (NOT (OR p q))" + , " (AND (NOT p) (NOT q)))))" + ] + addAxiom "double negation" ["(assert (forall ((p B)) (= (NOT (NOT p)) p)))"] + checkSat diff --git a/SBVTestSuite/Utils/SBVTestFramework.hs b/SBVTestSuite/Utils/SBVTestFramework.hs --- a/SBVTestSuite/Utils/SBVTestFramework.hs +++ b/SBVTestSuite/Utils/SBVTestFramework.hs @@ -36,7 +36,6 @@ import Control.Monad.Trans (liftIO) import qualified Data.ByteString.Lazy.Char8 as LBC -import qualified Data.ByteString as BS import System.Directory (removeFile) import System.Environment (lookupEnv) @@ -44,8 +43,7 @@ import Test.Tasty (testGroup, TestTree, TestName) import Test.Tasty.HUnit ((@?), Assertion, testCase, AssertionPredicable) -import Test.Tasty.Golden (goldenVsString) -import Test.Tasty.Golden.Advanced (goldenTest) +import Test.Tasty.Golden (goldenVsString, goldenVsFileDiff) import qualified Test.Tasty.QuickCheck as QC import qualified Test.QuickCheck.Monadic as QC @@ -56,7 +54,7 @@ import Data.SBV import Data.SBV.Control -import Data.Char (chr, ord, isDigit) +import Data.Char (isDigit) import Data.Maybe (fromMaybe, catMaybes) import System.FilePath ((), (<.>)) @@ -114,53 +112,12 @@ goldenVsStringShow n res = goldenVsString n (goldFile n) (fmap (LBC.pack . show) res) goldenCapturedIO :: TestName -> (FilePath -> IO ()) -> TestTree -goldenCapturedIO n res = doTheDiff n gf gfTmp (rm gfTmp >> res gfTmp) +goldenCapturedIO n res = goldenVsFileDiff n diff gf gfTmp (rm gfTmp >> res gfTmp) where gf = goldFile n gfTmp = gf ++ "_temp" - - rm f = removeFile f `C.catch` (\(_ :: C.SomeException) -> return ()) - --- | When comparing ignore \r's for windows's sake -doTheDiff :: TestName -> FilePath -> FilePath -> IO () -> TestTree -doTheDiff nm ref new act = goldenTest nm (BS.readFile ref) (act >> BS.readFile new) cmp upd - where upd = BS.writeFile ref - - cmp :: BS.ByteString -> BS.ByteString -> IO (Maybe String) - cmp x y - | cleanUp x == cleanUp y = return Nothing - | True = return $ Just $ unlines $ [ "Discrepancy found. Expected: " ++ ref - , "============================================" - ] - ++ lxs - ++ [ "Got: " ++ new - , "============================================" - ] - ++ lys - ++ [ "Diff: " - , "============================================" - ] - ++ diff - where xs = map (chr . fromIntegral) $ BS.unpack x - ys = map (chr . fromIntegral) $ BS.unpack y - - lxs = lines xs - lys = lines ys - - diffLen = length lxs `max` length lys - diff = concatMap pick $ zip3 [1..diffLen] (lxs ++ repeat "") (lys ++ repeat "") - - pick (i, expected, got) - | filter (/= '\r') expected == filter (/= '\r') got - = [] - | True - = [ "== Line " ++ show i ++ " ==" - , " Expected: " ++ show expected - , " Got : " ++ show got - ] + rm f = removeFile f `C.catch` (\(_ :: C.SomeException) -> return ()) - -- deal with insane Windows \r stuff - cleanUp = BS.filter (/= slashr) - slashr = fromIntegral (ord '\r') + diff ref new = ["diff", "-u", ref, new] -- | Count the number of models. It's not kosher to -- call this function if you provided a max-model count @@ -195,7 +152,7 @@ assertIsntSat p = assert (fmap not (isSatisfiable p)) -- | Quick-check a unary function, creating one version for constant folding, and another for solver -qc1 :: (Eq a, SymVal a, SymVal b, Show a, QC.Arbitrary a, Eq b, SMTValue b) => String -> (a -> b) -> (SBV a -> SBV b) -> [TestTree] +qc1 :: (Eq a, SymVal a, SymVal b, Show a, QC.Arbitrary a, Eq b) => String -> (a -> b) -> (SBV a -> SBV b) -> [TestTree] qc1 nm opC opS = [cf, sm] where cf = QC.testProperty (nm ++ ".constantFold") $ do i <- free "i" @@ -247,7 +204,7 @@ -- | Quick-check a binary function, creating one version for constant folding, and another for solver -qc2 :: (Eq a, Eq b, SymVal a, SymVal b, SymVal c, Show a, Show b, QC.Arbitrary a, QC.Arbitrary b, Eq c, SMTValue c) => String -> (a -> b -> c) -> (SBV a -> SBV b -> SBV c) -> [TestTree] +qc2 :: (Eq a, Eq b, SymVal a, SymVal b, SymVal c, Show a, Show b, QC.Arbitrary a, QC.Arbitrary b, Eq c) => String -> (a -> b -> c) -> (SBV a -> SBV b -> SBV c) -> [TestTree] qc2 nm opC opS = [cf, sm] where cf = QC.testProperty (nm ++ ".constantFold") $ do i1 <- free "i1" diff --git a/sbv.cabal b/sbv.cabal --- a/sbv.cabal +++ b/sbv.cabal @@ -1,5 +1,5 @@ Name: sbv -Version: 8.6 +Version: 8.7 Category: Formal Methods, Theorem Provers, Bit vectors, Symbolic Computation, Math, SMT Synopsis: SMT Based Verification: Symbolic Haskell theorem prover using SMT solving. Description: Express properties about Haskell programs and automatically prove them using SMT @@ -72,7 +72,7 @@ ViewPatterns Build-Depends : base >= 4.11 && < 5 , crackNum >= 2.3 - , ghc, QuickCheck, template-haskell + , QuickCheck, template-haskell , array, async, containers, deepseq, directory, filepath, time , pretty, process, mtl, random, syb, transformers , generic-deriving @@ -126,6 +126,7 @@ , Documentation.SBV.Examples.Misc.ModelExtract , Documentation.SBV.Examples.Misc.Auxiliary , Documentation.SBV.Examples.Misc.NoDiv0 + , Documentation.SBV.Examples.Misc.Newtypes , Documentation.SBV.Examples.Misc.Polynomials , Documentation.SBV.Examples.Misc.SetAlgebra , Documentation.SBV.Examples.Misc.SoftConstrain @@ -140,6 +141,7 @@ , Documentation.SBV.Examples.ProofTools.Strengthen , Documentation.SBV.Examples.ProofTools.Sum , Documentation.SBV.Examples.WeakestPreconditions.Append + , Documentation.SBV.Examples.WeakestPreconditions.Basics , Documentation.SBV.Examples.WeakestPreconditions.Fib , Documentation.SBV.Examples.WeakestPreconditions.GCD , Documentation.SBV.Examples.WeakestPreconditions.IntDiv @@ -167,6 +169,7 @@ , Documentation.SBV.Examples.Queries.CaseSplit , Documentation.SBV.Examples.Queries.Enums , Documentation.SBV.Examples.Queries.Interpolants + , Documentation.SBV.Examples.Queries.Concurrency , Documentation.SBV.Examples.Strings.RegexCrossword , Documentation.SBV.Examples.Strings.SQLInjection , Documentation.SBV.Examples.Transformers.SymbolicEval @@ -410,11 +413,11 @@ TypeApplications Build-depends : base >= 4.11, filepath, syb, crackNum >= 2.3 , sbv, directory, random, mtl, containers - , criterion, process, deepseq + , gauge, process, deepseq, silently Hs-Source-Dirs : SBVBenchSuite main-is : SBVBench.hs Other-modules : Utils.SBVBenchFramework - , BenchSuite.Overhead.SBVOverhead + , BenchSuite.Bench.Bench , BenchSuite.Puzzles.Birthday , BenchSuite.Puzzles.Coins , BenchSuite.Puzzles.Counts @@ -427,3 +430,70 @@ , BenchSuite.Puzzles.SendMoreMoney , BenchSuite.Puzzles.Sudoku , BenchSuite.Puzzles.U2Bridge + , BenchSuite.BitPrecise.BitTricks + , BenchSuite.BitPrecise.BrokenSearch + , BenchSuite.BitPrecise.Legato + , BenchSuite.BitPrecise.MergeSort + , BenchSuite.BitPrecise.MultMask + , BenchSuite.BitPrecise.PrefixSum + , BenchSuite.Queries.AllSat + , BenchSuite.Queries.CaseSplit + , BenchSuite.Queries.Concurrency + , BenchSuite.Queries.Enums + , BenchSuite.Queries.FourFours + , BenchSuite.Queries.GuessNumber + , BenchSuite.Queries.Interpolants + , BenchSuite.Queries.UnsatCore + , BenchSuite.WeakestPreconditions.Instances + , BenchSuite.WeakestPreconditions.Append + , BenchSuite.WeakestPreconditions.Basics + , BenchSuite.WeakestPreconditions.Fib + , BenchSuite.WeakestPreconditions.GCD + , BenchSuite.WeakestPreconditions.IntDiv + , BenchSuite.WeakestPreconditions.IntSqrt + , BenchSuite.WeakestPreconditions.Length + , BenchSuite.WeakestPreconditions.Sum + , BenchSuite.Optimization.Instances + , BenchSuite.Optimization.Enumerate + , BenchSuite.Optimization.ExtField + , BenchSuite.Optimization.LinearOpt + , BenchSuite.Optimization.Production + , BenchSuite.Optimization.VM + , BenchSuite.Uninterpreted.AUF + , BenchSuite.Uninterpreted.Deduce + , BenchSuite.Uninterpreted.Function + , BenchSuite.Uninterpreted.Multiply + , BenchSuite.Uninterpreted.Shannon + , BenchSuite.Uninterpreted.Sort + , BenchSuite.Uninterpreted.UISortAllSat + , BenchSuite.ProofTools.BMC + , BenchSuite.ProofTools.Fibonacci + , BenchSuite.ProofTools.Strengthen + , BenchSuite.ProofTools.Sum + , BenchSuite.CodeGeneration.AddSub + , BenchSuite.CodeGeneration.CRC_USB5 + , BenchSuite.CodeGeneration.Fibonacci + , BenchSuite.CodeGeneration.GCD + , BenchSuite.CodeGeneration.PopulationCount + , BenchSuite.CodeGeneration.Uninterpreted + , BenchSuite.Crypto.AES + , BenchSuite.Crypto.RC4 + , BenchSuite.Crypto.SHA + , BenchSuite.Misc.Auxiliary + , BenchSuite.Misc.Enumerate + , BenchSuite.Misc.Floating + , BenchSuite.Misc.ModelExtract + , BenchSuite.Misc.Newtypes + , BenchSuite.Misc.NoDiv0 + , BenchSuite.Misc.Polynomials + , BenchSuite.Misc.SetAlgebra + , BenchSuite.Misc.SoftConstrain + , BenchSuite.Misc.Tuple + , BenchSuite.Lists.BoundedMutex + , BenchSuite.Lists.Fibonacci + , BenchSuite.Lists.Nested + , BenchSuite.Strings.RegexCrossword + , BenchSuite.Strings.SQLInjection + , BenchSuite.Existentials.CRCPolynomial + , BenchSuite.Existentials.Diophantine + , BenchSuite.Transformers.SymbolicEval