| Copyright | (c) Levent Erkok |
|---|---|
| License | BSD3 |
| Maintainer | erkokl@gmail.com |
| Stability | experimental |
| Safe Haskell | None |
| Language | Haskell2010 |
Data.SBV.Internals
Contents
- Running symbolic programs manually
- Solver capabilities
- Internal structures useful for low-level programming
- Is this name reserved?
- Operations useful for instantiating SBV type classes
- Compilation to C, extras
- Code generation primitives
- Various math utilities around floats
- Pretty number printing
- Timing computations
- Coordinating with the solver
- Defining new metrics
- Generalized floats
- lambdas and axioms
Description
Low level functions to access the SBV infrastructure, for developers who want to build further tools on top of SBV. End-users of the library should not need to use this module.
NB. There are various coding invariants in SBV that are maintained throughout the code. Indiscriminate use of functions in this module can break those invariants. So, you are on your own if you do utilize the functions here. (Unfortunately, what exactly those invariants are is a very good but also a very difficult question to answer!)
Synopsis
- data Result = Result {
- progInfo :: ProgInfo
- reskinds :: Set Kind
- resTraces :: [(String, CV)]
- resObservables :: [(String, CV -> Bool, SV)]
- resUISegs :: [(String, [String])]
- resParams :: ResultInp
- resConsts :: (CnstMap, [(SV, CV)])
- resTables :: [((Int, Kind, Kind), [SV])]
- resUIConsts :: [(String, (Bool, Maybe [String], SBVType))]
- resDefinitions :: [(SMTDef, SBVType)]
- resAsgns :: SBVPgm
- resConstraints :: Seq (Bool, [(String, String)], SV)
- resAssertions :: [(String, Maybe CallStack, SV)]
- resOutputs :: [SV]
- data SBVRunMode
- data IStage
- data QueryContext
- data VarContext
- class SatModel a where
- mkNewState :: MonadIO m => SMTConfig -> SBVRunMode -> m State
- data SolverCapabilities = SolverCapabilities {
- supportsQuantifiers :: Bool
- supportsDefineFun :: Bool
- supportsDistinct :: Bool
- supportsBitVectors :: Bool
- supportsUninterpretedSorts :: Bool
- supportsUnboundedInts :: Bool
- supportsReals :: Bool
- supportsApproxReals :: Bool
- supportsDeltaSat :: Maybe String
- supportsIEEE754 :: Bool
- supportsSets :: Bool
- supportsOptimization :: Bool
- supportsPseudoBooleans :: Bool
- supportsCustomQueries :: Bool
- supportsGlobalDecls :: Bool
- supportsDataTypes :: Bool
- supportsLambdas :: Bool
- supportsSpecialRels :: Bool
- supportsDirectAccessors :: Bool
- supportsFlattenedModels :: Maybe [String]
- cvSameType :: CV -> CV -> Bool
- cvToBool :: CV -> Bool
- falseCV :: CV
- isRegularCV :: GeneralizedCV -> Bool
- mapCV :: (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> (FP -> FP) -> (Rational -> Rational) -> CV -> CV
- mapCV2 :: (AlgReal -> AlgReal -> AlgReal) -> (Integer -> Integer -> Integer) -> (Float -> Float -> Float) -> (Double -> Double -> Double) -> (FP -> FP -> FP) -> (Rational -> Rational -> Rational) -> CV -> CV -> CV
- mkConstCV :: Integral a => Kind -> a -> CV
- normCV :: CV -> CV
- trueCV :: CV
- (#) :: forall (n :: Nat) bv (m :: Nat). (KnownNat n, BVIsNonZero n, SymVal (bv n), KnownNat m, BVIsNonZero m, SymVal (bv m)) => SBV (bv n) -> SBV (bv m) -> SBV (bv (n + m))
- (.&&) :: SBool -> SBool -> SBool
- (.<+>) :: SBool -> SBool -> SBool
- (.<=>) :: SBool -> SBool -> SBool
- (.=>) :: SBool -> SBool -> SBool
- (.||) :: SBool -> SBool -> SBool
- (.~&) :: SBool -> SBool -> SBool
- (.~|) :: SBool -> SBool -> SBool
- bvDrop :: forall (i :: Nat) (n :: Nat) (m :: Natural) bv proxy. (KnownNat n, BVIsNonZero n, KnownNat i, (i + 1) <= n, ((i + m) - n) <= 0, BVIsNonZero (n - i)) => proxy i -> SBV (bv n) -> SBV (bv m)
- bvExtract :: forall (i :: Nat) (j :: Nat) (n :: Nat) bv proxy. (KnownNat n, BVIsNonZero n, SymVal (bv n), KnownNat i, KnownNat j, (i + 1) <= n, j <= i, BVIsNonZero ((i - j) + 1)) => proxy i -> proxy j -> SBV (bv n) -> SBV (bv ((i - j) + 1))
- bvTake :: forall (i :: Nat) (n :: Nat) bv proxy. (KnownNat n, BVIsNonZero n, KnownNat i, BVIsNonZero i, i <= n) => proxy i -> SBV (bv n) -> SBV (bv i)
- extendPathCondition :: State -> (SBool -> SBool) -> State
- fromBool :: Bool -> SBool
- getPathCondition :: State -> SBool
- infinity :: Floating a => a
- mkSymSBV :: forall a m. MonadSymbolic m => VarContext -> Kind -> Maybe String -> m (SBV a)
- nan :: Floating a => a
- registerType :: forall a m. (MonadIO m, SolverContext m, HasKind a) => Proxy a -> m ()
- sAll :: (a -> SBool) -> [a] -> SBool
- sAnd :: [SBool] -> SBool
- sAny :: (a -> SBool) -> [a] -> SBool
- sFalse :: SBool
- sInfinity :: (Floating a, SymVal a) => SBV a
- sNaN :: (Floating a, SymVal a) => SBV a
- sNot :: SBool -> SBool
- sOr :: [SBool] -> SBool
- sRNA :: SRoundingMode
- sRNE :: SRoundingMode
- sRTN :: SRoundingMode
- sRTP :: SRoundingMode
- sRTZ :: SRoundingMode
- sRoundNearestTiesToAway :: SRoundingMode
- sRoundNearestTiesToEven :: SRoundingMode
- sRoundTowardNegative :: SRoundingMode
- sRoundTowardPositive :: SRoundingMode
- sRoundTowardZero :: SRoundingMode
- sTrue :: SBool
- sbvToSV :: State -> SBV a -> IO SV
- sbvToSymSV :: MonadSymbolic m => SBV a -> m SV
- cache :: (State -> IO a) -> Cached a
- extractSymbolicSimulationState :: State -> IO Result
- falseSV :: SV
- forceSVArg :: SV -> IO ()
- getTableIndex :: State -> Kind -> Kind -> [SV] -> IO Int
- inSMTMode :: State -> IO Bool
- internalConstraint :: State -> Bool -> [(String, String)] -> SVal -> IO ()
- isCodeGenMode :: State -> IO Bool
- needsExistentials :: [Quantifier] -> Bool
- newExpr :: State -> Kind -> SBVExpr -> IO SV
- newUninterpreted :: State -> UIName -> Maybe [String] -> SBVType -> UICodeKind -> IO String
- runSymbolic :: MonadIO m => SMTConfig -> SBVRunMode -> SymbolicT m a -> m (a, Result)
- smtLibVersionExtension :: SMTLibVersion -> String
- trueSV :: SV
- uncache :: Cached SV -> State -> IO SV
- data AlgReal
- newtype AlgRealPoly = AlgRealPoly [(Integer, Integer)]
- data ArrayModel a b = ArrayModel [(a, b)] b
- data CV = CV {}
- data CVal
- data ExtCV
- data GeneralizedCV
- data RCSet a
- = RegularSet (Set a)
- | ComplementSet (Set a)
- class MonadSymbolic m => Constraint (m :: Type -> Type) a where
- mkConstraint :: State -> a -> m ()
- class EqSymbolic a where
- class MonadSymbolic m => Lambda (m :: Type -> Type) a where
- class Outputtable a where
- output :: MonadSymbolic m => a -> m a
- class QuantifiedBool a where
- quantifiedBool :: a -> SBool
- type SArray a b = SBV (ArrayModel a b)
- newtype SBV a = SBV {}
- type SBool = SBV Bool
- type SChar = SBV Char
- type SDouble = SBV Double
- type SEither a b = SBV (Either a b)
- type SFPBFloat = SBV FPBFloat
- type SFPDouble = SBV FPDouble
- type SFPHalf = SBV FPHalf
- type SFPQuad = SBV FPQuad
- type SFPSingle = SBV FPSingle
- type SFloat = SBV Float
- type SFloatingPoint (eb :: Nat) (sb :: Nat) = SBV (FloatingPoint eb sb)
- type SInt (n :: Nat) = SBV (IntN n)
- type SInt16 = SBV Int16
- type SInt32 = SBV Int32
- type SInt64 = SBV Int64
- type SInt8 = SBV Int8
- type SInteger = SBV Integer
- type SList a = SBV [a]
- newtype SMTProblem = SMTProblem {}
- type SMaybe a = SBV (Maybe a)
- type SRational = SBV Rational
- type SReal = SBV AlgReal
- type SRoundingMode = SBV RoundingMode
- type SSet a = SBV (RCSet a)
- type SString = SBV String
- type STuple a b = SBV (a, b)
- type STuple2 a b = SBV (a, b)
- type STuple3 a b c = SBV (a, b, c)
- type STuple4 a b c d = SBV (a, b, c, d)
- type STuple5 a b c d e = SBV (a, b, c, d, e)
- type STuple6 a b c d e f = SBV (a, b, c, d, e, f)
- type STuple7 a b c d e f g = SBV (a, b, c, d, e, f, g)
- type STuple8 a b c d e f g h = SBV (a, b, c, d, e, f, g, h)
- type SWord (n :: Nat) = SBV (WordN n)
- type SWord16 = SBV Word16
- type SWord32 = SBV Word32
- type SWord64 = SBV Word64
- type SWord8 = SBV Word8
- class SolverContext (m :: Type -> Type) where
- constrain :: QuantifiedBool a => a -> m ()
- softConstrain :: QuantifiedBool a => a -> m ()
- namedConstraint :: QuantifiedBool a => String -> a -> m ()
- constrainWithAttribute :: QuantifiedBool a => [(String, String)] -> a -> m ()
- setInfo :: String -> [String] -> m ()
- setOption :: SMTOption -> m ()
- setLogic :: Logic -> m ()
- setTimeOut :: Integer -> m ()
- contextState :: m State
- internalVariable :: Kind -> m (SBV a)
- class (HasKind a, Typeable a) => SymVal a where
- mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV a)
- literal :: a -> SBV a
- fromCV :: CV -> a
- isConcretely :: SBV a -> (a -> Bool) -> Bool
- free :: MonadSymbolic m => String -> m (SBV a)
- free_ :: MonadSymbolic m => m (SBV a)
- mkFreeVars :: MonadSymbolic m => Int -> m [SBV a]
- symbolic :: MonadSymbolic m => String -> m (SBV a)
- symbolics :: MonadSymbolic m => [String] -> m [SBV a]
- unliteral :: SBV a -> Maybe a
- isConcrete :: SBV a -> Bool
- isSymbolic :: SBV a -> Bool
- class HasKind a where
- kindOf :: a -> Kind
- hasSign :: a -> Bool
- intSizeOf :: a -> Int
- isBoolean :: a -> Bool
- isBounded :: a -> Bool
- isReal :: a -> Bool
- isFloat :: a -> Bool
- isDouble :: a -> Bool
- isRational :: a -> Bool
- isFP :: a -> Bool
- isUnbounded :: a -> Bool
- isUserSort :: a -> Bool
- isChar :: a -> Bool
- isString :: a -> Bool
- isList :: a -> Bool
- isSet :: a -> Bool
- isTuple :: a -> Bool
- isMaybe :: a -> Bool
- isEither :: a -> Bool
- isArray :: a -> Bool
- showType :: a -> String
- data Kind
- data RoundingMode
- data IntN (n :: Nat)
- data WordN (n :: Nat)
- data Cached a
- data FPOp
- data KDOptions = KDOptions {
- ribbonLength :: Int
- firstifyUniqueLen :: Int
- quiet :: Bool
- measureTime :: Bool
- data NamedSymVar = NamedSymVar !SV !Name
- newtype NodeId = NodeId {}
- data Objective a
- data Op
- = Plus
- | Times
- | Minus
- | UNeg
- | Abs
- | Quot
- | Rem
- | Equal
- | Implies
- | NotEqual
- | LessThan
- | GreaterThan
- | LessEq
- | GreaterEq
- | Ite
- | And
- | Or
- | XOr
- | Not
- | Shl
- | Shr
- | Rol Int
- | Ror Int
- | Divides Integer
- | Extract Int Int
- | Join
- | ZeroExtend Int
- | SignExtend Int
- | LkUp (Int, Kind, Kind, Int) !SV !SV
- | KindCast Kind Kind
- | Uninterpreted String
- | QuantifiedBool String
- | SpecialRelOp Kind SpecialRelOp
- | Label String
- | IEEEFP FPOp
- | NonLinear NROp
- | OverflowOp OvOp
- | PseudoBoolean PBOp
- | RegExOp RegExOp
- | StrOp StrOp
- | SeqOp SeqOp
- | SetOp SetOp
- | TupleConstructor Int
- | TupleAccess Int Int
- | EitherConstructor Kind Kind Bool
- | EitherIs Kind Kind Bool
- | EitherAccess Bool
- | RationalConstructor
- | MaybeConstructor Kind Bool
- | MaybeIs Kind Bool
- | MaybeAccess
- | ArrayLambda SMTLambda
- | ReadArray
- | WriteArray
- data OptimizeStyle
- = Lexicographic
- | Independent
- | Pareto (Maybe Int)
- data OvOp
- data PBOp
- data Penalty
- data Quantifier
- data QueryState = QueryState {
- queryAsk :: Maybe Int -> String -> IO String
- querySend :: Maybe Int -> String -> IO ()
- queryRetrieveResponse :: Maybe Int -> IO String
- queryConfig :: SMTConfig
- queryTerminate :: Maybe SomeException -> IO ()
- queryTimeOutValue :: Maybe Int
- queryAssertionStackDepth :: Int
- newtype QueryT (m :: Type -> Type) a = QueryT {}
- data RegExOp
- data RegExp
- data Result = Result {
- progInfo :: ProgInfo
- reskinds :: Set Kind
- resTraces :: [(String, CV)]
- resObservables :: [(String, CV -> Bool, SV)]
- resUISegs :: [(String, [String])]
- resParams :: ResultInp
- resConsts :: (CnstMap, [(SV, CV)])
- resTables :: [((Int, Kind, Kind), [SV])]
- resUIConsts :: [(String, (Bool, Maybe [String], SBVType))]
- resDefinitions :: [(SMTDef, SBVType)]
- resAsgns :: SBVPgm
- resConstraints :: Seq (Bool, [(String, String)], SV)
- resAssertions :: [(String, Maybe CallStack, SV)]
- resOutputs :: [SV]
- data SBVExpr = SBVApp !Op ![SV]
- newtype SBVPgm = SBVPgm {
- pgmAssignments :: Seq (SV, SBVExpr)
- data SBVRunMode
- newtype SBVType = SBVType [Kind]
- data SMTConfig = SMTConfig {
- verbose :: Bool
- timing :: Timing
- printBase :: Int
- printRealPrec :: Int
- crackNum :: Bool
- crackNumSurfaceVals :: [(String, Integer)]
- satCmd :: String
- allSatMaxModelCount :: Maybe Int
- allSatPrintAlong :: Bool
- allSatTrackUFs :: Bool
- isNonModelVar :: String -> Bool
- validateModel :: Bool
- optimizeValidateConstraints :: Bool
- transcript :: Maybe FilePath
- smtLibVersion :: SMTLibVersion
- dsatPrecision :: Maybe Double
- solver :: SMTSolver
- extraArgs :: [String]
- roundingMode :: RoundingMode
- solverSetOptions :: [SMTOption]
- ignoreExitCode :: Bool
- redirectVerbose :: Maybe FilePath
- generateHOEquivs :: Bool
- kdOptions :: KDOptions
- data SMTLibPgm = SMTLibPgm SMTLibVersion [String] [String]
- data SMTLibVersion = SMTLib2
- data SMTModel = SMTModel {
- modelObjectives :: [(String, GeneralizedCV)]
- modelBindings :: Maybe [(NamedSymVar, CV)]
- modelAssocs :: [(String, CV)]
- modelUIFuns :: [(String, (Bool, SBVType, Either String ([([CV], CV)], CV)))]
- data SMTResult
- data SMTScript = SMTScript {
- scriptBody :: String
- scriptModel :: [String]
- data SMTSolver = SMTSolver {
- name :: Solver
- executable :: String
- preprocess :: String -> String
- options :: SMTConfig -> [String]
- engine :: SMTEngine
- capabilities :: SolverCapabilities
- data SV = SV !Kind !NodeId
- data SVal = SVal !Kind !(Either CV (Cached SV))
- data SeqOp
- = SeqConcat
- | SeqLen
- | SeqUnit
- | SeqNth
- | SeqSubseq
- | SeqIndexOf
- | SeqContains
- | SeqPrefixOf
- | SeqSuffixOf
- | SeqReplace
- | SBVReverse Kind
- | SBVZip Kind Kind
- | SBVZipWith Kind Kind Kind SMTLambda
- | SBVPartition Kind SMTLambda
- | SBVMap Kind Kind SMTLambda
- | SBVFoldl Kind Kind SMTLambda
- | SBVFoldr Kind Kind SMTLambda
- | SBVFilter Kind SMTLambda
- | SBVAll Kind SMTLambda
- | SBVAny Kind SMTLambda
- | SBVConcat Kind
- data Solver
- data SolverCapabilities = SolverCapabilities {
- supportsQuantifiers :: Bool
- supportsDefineFun :: Bool
- supportsDistinct :: Bool
- supportsBitVectors :: Bool
- supportsUninterpretedSorts :: Bool
- supportsUnboundedInts :: Bool
- supportsReals :: Bool
- supportsApproxReals :: Bool
- supportsDeltaSat :: Maybe String
- supportsIEEE754 :: Bool
- supportsSets :: Bool
- supportsOptimization :: Bool
- supportsPseudoBooleans :: Bool
- supportsCustomQueries :: Bool
- supportsGlobalDecls :: Bool
- supportsDataTypes :: Bool
- supportsLambdas :: Bool
- supportsSpecialRels :: Bool
- supportsDirectAccessors :: Bool
- supportsFlattenedModels :: Maybe [String]
- data State
- data StrOp
- type Symbolic = SymbolicT IO
- isReserved :: String -> Bool
- data UIName
- genLiteral :: Integral a => Kind -> a -> SBV b
- genFromCV :: Integral a => CV -> a
- data CV = CV {}
- genMkSymVar :: MonadSymbolic m => Kind -> VarContext -> Maybe String -> m (SBV a)
- genParse :: Integral a => Kind -> [CV] -> Maybe (a, [CV])
- showModel :: SMTConfig -> SMTModel -> String
- data SMTModel = SMTModel {
- modelObjectives :: [(String, GeneralizedCV)]
- modelBindings :: Maybe [(NamedSymVar, CV)]
- modelAssocs :: [(String, CV)]
- modelUIFuns :: [(String, (Bool, SBVType, Either String ([([CV], CV)], CV)))]
- liftQRem :: (Eq a, SymVal a) => SBV a -> SBV a -> (SBV a, SBV a)
- liftDMod :: (Ord a, SymVal a, Num a, Num (SBV a), SDivisible (SBV a)) => SBV a -> SBV a -> (SBV a, SBV a)
- registerKind :: State -> Kind -> IO ()
- svToSV :: State -> SVal -> IO SV
- class ExtractIO m => ProvableM (m :: Type -> Type) a
- class ExtractIO m => SatisfiableM (m :: Type -> Type) a
- data UICodeKind
- compileToC' :: String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle)
- compileToCLib' :: String -> [(String, SBVCodeGen a)] -> IO ([a], CgConfig, CgPgmBundle)
- cgAddDecl :: [String] -> SBVCodeGen ()
- cgAddLDFlags :: [String] -> SBVCodeGen ()
- cgAddPrototype :: [String] -> SBVCodeGen ()
- cgGenerateDriver :: Bool -> SBVCodeGen ()
- cgGenerateMakefile :: Bool -> SBVCodeGen ()
- cgIgnoreSAssert :: Bool -> SBVCodeGen ()
- cgInput :: SymVal a => String -> SBVCodeGen (SBV a)
- cgInputArr :: SymVal a => Int -> String -> SBVCodeGen [SBV a]
- cgIntegerSize :: Int -> SBVCodeGen ()
- cgOutput :: String -> SBV a -> SBVCodeGen ()
- cgOutputArr :: SymVal a => String -> [SBV a] -> SBVCodeGen ()
- cgOverwriteFiles :: Bool -> SBVCodeGen ()
- cgPerformRTCs :: Bool -> SBVCodeGen ()
- cgReturn :: SBV a -> SBVCodeGen ()
- cgReturnArr :: SymVal a => [SBV a] -> SBVCodeGen ()
- cgSRealType :: CgSRealType -> SBVCodeGen ()
- cgSetDriverValues :: [Integer] -> SBVCodeGen ()
- cgShowU8UsingHex :: Bool -> SBVCodeGen ()
- cgSym :: Symbolic a -> SBVCodeGen a
- codeGen :: CgTarget l => l -> CgConfig -> String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle)
- defaultCgConfig :: CgConfig
- initCgState :: CgState
- isCgDriver :: CgPgmKind -> Bool
- isCgMakefile :: CgPgmKind -> Bool
- renderCgPgmBundle :: Maybe FilePath -> (CgConfig, CgPgmBundle) -> IO ()
- svCgInput :: Kind -> String -> SBVCodeGen SVal
- svCgInputArr :: Kind -> Int -> String -> SBVCodeGen [SVal]
- svCgOutput :: String -> SVal -> SBVCodeGen ()
- svCgOutputArr :: String -> [SVal] -> SBVCodeGen ()
- svCgReturn :: SVal -> SBVCodeGen ()
- svCgReturnArr :: [SVal] -> SBVCodeGen ()
- data CgConfig = CgConfig {
- cgRTC :: Bool
- cgInteger :: Maybe Int
- cgReal :: Maybe CgSRealType
- cgDriverVals :: [Integer]
- cgGenDriver :: Bool
- cgGenMakefile :: Bool
- cgIgnoreAsserts :: Bool
- cgOverwriteGenerated :: Bool
- cgShowU8InHex :: Bool
- data CgPgmBundle = CgPgmBundle (Maybe Int, Maybe CgSRealType) [(FilePath, (CgPgmKind, [Doc]))]
- data CgPgmKind
- data CgSRealType
- data CgState = CgState {}
- class CgTarget a where
- targetName :: a -> String
- translate :: a -> CgConfig -> String -> CgState -> Result -> CgPgmBundle
- data CgVal
- newtype SBVCodeGen a = SBVCodeGen (StateT CgState Symbolic a)
- doubleToWord :: Double -> Word64
- floatToWord :: Float -> Word32
- fp2fp :: (RealFloat a, RealFloat b) => a -> b
- fpCompareObjectH :: RealFloat a => a -> a -> Ordering
- fpIsEqualObjectH :: RealFloat a => a -> a -> Bool
- fpIsNormalizedH :: RealFloat a => a -> Bool
- fpMaxH :: RealFloat a => a -> a -> a
- fpMinH :: RealFloat a => a -> a -> a
- fpRemH :: RealFloat a => a -> a -> a
- fpRoundToIntegralH :: RealFloat a => a -> a
- wordToDouble :: Word64 -> Double
- wordToFloat :: Word32 -> Float
- smtRoundingMode :: RoundingMode -> String
- chex :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String
- cvToSMTLib :: RoundingMode -> CV -> String
- readBin :: Num a => String -> a
- sbin :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String
- sbinI :: Bool -> Bool -> Integer -> String
- shex :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String
- shexI :: Bool -> Bool -> Integer -> String
- showBFloat :: (Show a, RealFloat a) => a -> ShowS
- showCDouble :: Double -> String
- showCFloat :: Float -> String
- showFloatAtBase :: (Show a, RealFloat a) => Int -> a -> ShowS
- showHDouble :: Double -> String
- showHFloat :: Float -> String
- showNegativeNumber :: (Show a, Num a, Ord a) => a -> String
- showSMTDouble :: RoundingMode -> Double -> String
- showSMTFloat :: RoundingMode -> Float -> String
- class PrettyNum a where
- getElapsedTime :: MonadIO m => Maybe UTCTime -> m (Maybe NominalDiffTime)
- getTimeStampIf :: MonadIO m => Bool -> m (Maybe UTCTime)
- showTDiff :: NominalDiffTime -> String
- timeIf :: MonadIO m => Bool -> m a -> m (Maybe NominalDiffTime, a)
- timeIfRNF :: (NFData a, MonadIO m) => Bool -> m a -> m (Maybe NominalDiffTime, a)
- data Timing
- sendStringToSolver :: (MonadIO m, MonadQuery m) => String -> m ()
- sendRequestToSolver :: (MonadIO m, MonadQuery m) => String -> m String
- retrieveResponseFromSolver :: (MonadIO m, MonadQuery m) => String -> Maybe Int -> m [String]
- addSValOptGoal :: MonadSymbolic m => Objective SVal -> m ()
- sFloatAsComparableSWord32 :: SFloat -> SWord32
- sDoubleAsComparableSWord64 :: SDouble -> SWord64
- sFloatingPointAsComparableSWord :: forall (eb :: Nat) (sb :: Nat). (ValidFloat eb sb, KnownNat (eb + sb), BVIsNonZero (eb + sb)) => SFloatingPoint eb sb -> SWord (eb + sb)
- sComparableSWord32AsSFloat :: SWord32 -> SFloat
- sComparableSWord64AsSDouble :: SWord64 -> SDouble
- sComparableSWordAsSFloatingPoint :: forall (eb :: Natural) (sb :: Natural). (KnownNat (eb + sb), BVIsNonZero (eb + sb), ValidFloat eb sb) => SWord (eb + sb) -> SFloatingPoint eb sb
- svFloatingPointAsSWord :: SVal -> SVal
- lambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTDef
- lambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTLambda
- namedLambda :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> Kind -> a -> m SMTDef
- namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> SBVType -> a -> m String
- constraint :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m SV
- constraintStr :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m String
- class MonadSymbolic m => Lambda (m :: Type -> Type) a where
- class MonadSymbolic m => Constraint (m :: Type -> Type) a where
- mkConstraint :: State -> a -> m ()
- data LambdaScope
Running symbolic programs manually
Result of running a symbolic computation
Constructors
| Result | |
Fields
| |
Instances
| NFData Result Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data Result Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Result -> c Result # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Result # toConstr :: Result -> Constr # dataTypeOf :: Result -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Result) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Result) # gmapT :: (forall b. Data b => b -> b) -> Result -> Result # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Result -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Result -> r # gmapQ :: (forall d. Data d => d -> u) -> Result -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Result -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Result -> m Result # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Result -> m Result # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Result -> m Result # | |
| Show Result Source # | |
data SBVRunMode Source #
Different means of running a symbolic piece of code
Constructors
| SMTMode QueryContext IStage Bool SMTConfig | In regular mode, with a stage. Bool is True if this is SAT. |
| CodeGen | Code generation mode. |
| LambdaGen (Maybe Int) | Inside a lambda-expression at level. If Nothing, then closed lambda. |
| Concrete (Maybe (Bool, [(NamedSymVar, CV)])) | Concrete simulation mode, with given environment if any. If Nothing: Random. |
Instances
| Show SBVRunMode Source # | |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> SBVRunMode -> ShowS # show :: SBVRunMode -> String # showList :: [SBVRunMode] -> ShowS # | |
data QueryContext Source #
Query execution context
Constructors
| QueryInternal | Triggered from inside SBV |
| QueryExternal | Triggered from user code |
Instances
| Show QueryContext Source # | Show instance for |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> QueryContext -> ShowS # show :: QueryContext -> String # showList :: [QueryContext] -> ShowS # | |
data VarContext Source #
Which context is this variable being created?
Constructors
| NonQueryVar (Maybe Quantifier) | |
| QueryVar |
class SatModel a where Source #
Instances of SatModel can be automatically extracted from models returned by the
solvers. The idea is that the sbv infrastructure provides a stream of CV's (constant values)
coming from the solver, and the type a is interpreted based on these constants. Many typical
instances are already provided, so new instances can be declared with relative ease.
Minimum complete definition: parseCVs
Minimal complete definition
Nothing
Methods
parseCVs :: [CV] -> Maybe (a, [CV]) Source #
Given a sequence of constant-words, extract one instance of the type a, returning
the remaining elements untouched. If the next element is not what's expected for this
type you should return Nothing
cvtModel :: (a -> Maybe b) -> Maybe (a, [CV]) -> Maybe (b, [CV]) Source #
Given a parsed model instance, transform it using f, and return the result.
The default definition for this method should be sufficient in most use cases.
Instances
mkNewState :: MonadIO m => SMTConfig -> SBVRunMode -> m State Source #
Create a new state
Solver capabilities
data SolverCapabilities Source #
Translation tricks needed for specific capabilities afforded by each solver
Constructors
| SolverCapabilities | |
Fields
| |
Internal structures useful for low-level programming
isRegularCV :: GeneralizedCV -> Bool Source #
Is this a regular CV?
mapCV :: (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> (FP -> FP) -> (Rational -> Rational) -> CV -> CV Source #
Map a unary function through a CV.
mapCV2 :: (AlgReal -> AlgReal -> AlgReal) -> (Integer -> Integer -> Integer) -> (Float -> Float -> Float) -> (Double -> Double -> Double) -> (FP -> FP -> FP) -> (Rational -> Rational -> Rational) -> CV -> CV -> CV Source #
Map a binary function through a CV.
Normalize a CV. Essentially performs modular arithmetic to make sure the value can fit in the given bit-size. Note that this is rather tricky for negative values, due to asymmetry. (i.e., an 8-bit negative number represents values in the range -128 to 127; thus we have to be careful on the negative side.)
Arguments
| :: forall (n :: Nat) bv (m :: Nat). (KnownNat n, BVIsNonZero n, SymVal (bv n), KnownNat m, BVIsNonZero m, SymVal (bv m)) | |
| => SBV (bv n) | First input, of size |
| -> SBV (bv m) | Second input, of size |
| -> SBV (bv (n + m)) | Concatenation, of size |
Join two bitvectors.
Arguments
| :: forall (i :: Nat) (n :: Nat) (m :: Natural) bv proxy. (KnownNat n, BVIsNonZero n, KnownNat i, (i + 1) <= n, ((i + m) - n) <= 0, BVIsNonZero (n - i)) | |
| => proxy i |
|
| -> SBV (bv n) | Input, of size |
| -> SBV (bv m) | Output, of size |
Drop bits from the top of a bit-vector.
Arguments
| :: forall (i :: Nat) (j :: Nat) (n :: Nat) bv proxy. (KnownNat n, BVIsNonZero n, SymVal (bv n), KnownNat i, KnownNat j, (i + 1) <= n, j <= i, BVIsNonZero ((i - j) + 1)) | |
| => proxy i |
|
| -> proxy j |
|
| -> SBV (bv n) | Input bit vector of size |
| -> SBV (bv ((i - j) + 1)) | Output is of size |
Extract a portion of bits to form a smaller bit-vector.
Arguments
| :: forall (i :: Nat) (n :: Nat) bv proxy. (KnownNat n, BVIsNonZero n, KnownNat i, BVIsNonZero i, i <= n) | |
| => proxy i |
|
| -> SBV (bv n) | Input, of size |
| -> SBV (bv i) | Output, of size |
Take bits from the top of a bit-vector.
extendPathCondition :: State -> (SBool -> SBool) -> State Source #
Extend the path condition with the given test value.
getPathCondition :: State -> SBool Source #
Get the current path condition
mkSymSBV :: forall a m. MonadSymbolic m => VarContext -> Kind -> Maybe String -> m (SBV a) Source #
Generalization of mkSymSBV
registerType :: forall a m. (MonadIO m, SolverContext m, HasKind a) => Proxy a -> m () Source #
Register a type with the solver. Like registerFunction, This is typically not necessary
since SBV will register types as it encounters them automatically. But there are cases
where doing this can explicitly can come handy, typically in query contexts.
sInfinity :: (Floating a, SymVal a) => SBV a Source #
Symbolic variant of infinity. This value will inhabit both
SFloat, SDouble and SFloatingPoint. types.
sNaN :: (Floating a, SymVal a) => SBV a Source #
Symbolic variant of Not-A-Number. This value will inhabit
SFloat, SDouble and SFloatingPoint. types.
sRNA :: SRoundingMode Source #
Alias for sRoundNearestTiesToAway
sRNE :: SRoundingMode Source #
Alias for sRoundNearestTiesToEven
sRTN :: SRoundingMode Source #
Alias for sRoundTowardNegative
sRTP :: SRoundingMode Source #
Alias for sRoundTowardPositive
sRTZ :: SRoundingMode Source #
Alias for sRoundTowardZero
sRoundNearestTiesToAway :: SRoundingMode Source #
Symbolic variant of RoundNearestTiesToAway
sRoundNearestTiesToEven :: SRoundingMode Source #
Symbolic variant of RoundNearestTiesToEven
sRoundTowardNegative :: SRoundingMode Source #
Symbolic variant of RoundTowardNegative
sRoundTowardPositive :: SRoundingMode Source #
Symbolic variant of RoundTowardPositive
sRoundTowardZero :: SRoundingMode Source #
Symbolic variant of RoundTowardZero
sbvToSymSV :: MonadSymbolic m => SBV a -> m SV Source #
Generalization of sbvToSymSW
extractSymbolicSimulationState :: State -> IO Result Source #
Grab the program from a running symbolic simulation state.
Constant False as an SV. Note that this value always occupies slot -2 and level 0.
forceSVArg :: SV -> IO () Source #
Forcing an argument; this is a necessary evil to make sure all the arguments to an uninterpreted function are evaluated before called; the semantics of uinterpreted functions is necessarily strict; deviating from Haskell's
getTableIndex :: State -> Kind -> Kind -> [SV] -> IO Int Source #
Create a new table; hash-cons as necessary
internalConstraint :: State -> Bool -> [(String, String)] -> SVal -> IO () Source #
Require a boolean condition to be true in the state. Only used for internal purposes.
needsExistentials :: [Quantifier] -> Bool Source #
Are there any existential quantifiers?
newExpr :: State -> Kind -> SBVExpr -> IO SV Source #
Create a new expression; hash-cons as necessary
newUninterpreted :: State -> UIName -> Maybe [String] -> SBVType -> UICodeKind -> IO String Source #
Create a new uninterpreted symbol, possibly with user given code. This function might change the name given, putting bars around it if needed. That's the name returned.
runSymbolic :: MonadIO m => SMTConfig -> SBVRunMode -> SymbolicT m a -> m (a, Result) Source #
Generalization of runSymbolic
smtLibVersionExtension :: SMTLibVersion -> String Source #
The extension associated with the version
Constant True as an SV. Note that this value always occupies slot -1 and level 0.
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
Constructors
| AlgRational Bool Rational | bool says it's exact (i.e., SMT-solver did not return it with ? at the end.) |
| AlgPolyRoot (Integer, AlgRealPoly) (Maybe String) | which root of this polynomial and an approximate decimal representation with given precision, if available |
| AlgInterval (RealPoint Rational) (RealPoint Rational) | interval, with low and high bounds |
Instances
newtype AlgRealPoly Source #
A univariate polynomial, represented simply as a coefficient list. For instance, "5x^3 + 2x - 5" is represented as [(5, 3), (2, 1), (-5, 0)]
Constructors
| AlgRealPoly [(Integer, Integer)] |
Instances
| NFData AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals Methods rnf :: AlgRealPoly -> () # | |||||
| Data AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlgRealPoly -> c AlgRealPoly # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlgRealPoly # toConstr :: AlgRealPoly -> Constr # dataTypeOf :: AlgRealPoly -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AlgRealPoly) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlgRealPoly) # gmapT :: (forall b. Data b => b -> b) -> AlgRealPoly -> AlgRealPoly # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlgRealPoly -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlgRealPoly -> r # gmapQ :: (forall d. Data d => d -> u) -> AlgRealPoly -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlgRealPoly -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlgRealPoly -> m AlgRealPoly # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlgRealPoly -> m AlgRealPoly # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlgRealPoly -> m AlgRealPoly # | |||||
| Generic AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals Associated Types
| |||||
| Show AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals Methods showsPrec :: Int -> AlgRealPoly -> ShowS # show :: AlgRealPoly -> String # showList :: [AlgRealPoly] -> ShowS # | |||||
| Eq AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals | |||||
| Ord AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals Methods compare :: AlgRealPoly -> AlgRealPoly -> Ordering # (<) :: AlgRealPoly -> AlgRealPoly -> Bool # (<=) :: AlgRealPoly -> AlgRealPoly -> Bool # (>) :: AlgRealPoly -> AlgRealPoly -> Bool # (>=) :: AlgRealPoly -> AlgRealPoly -> Bool # max :: AlgRealPoly -> AlgRealPoly -> AlgRealPoly # min :: AlgRealPoly -> AlgRealPoly -> AlgRealPoly # | |||||
| type Rep AlgRealPoly Source # | |||||
Defined in Data.SBV.Core.AlgReals type Rep AlgRealPoly = D1 ('MetaData "AlgRealPoly" "Data.SBV.Core.AlgReals" "sbv-11.4-inplace" 'True) (C1 ('MetaCons "AlgRealPoly" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Integer, Integer)]))) | |||||
data ArrayModel a b Source #
Underlying type for SMTLib arrays, as a list of key-value pairs, with a default for unmapped elements. Note that this type matches the typical models returned by SMT-solvers. When we store the array, we do not bother removing earlier writes, so there might be duplicates. That is, we store the history of the writes. The earlier a pair is in the list, the "later" it is done, i.e., it takes precedence over the latter entries.
Constructors
| ArrayModel [(a, b)] b |
Instances
| (NFData a, NFData b) => NFData (ArrayModel a b) Source # | |||||
Defined in Data.SBV.Core.Concrete Methods rnf :: ArrayModel a b -> () # | |||||
| (Data a, Data b) => Data (ArrayModel a b) Source # | |||||
Defined in Data.SBV.Core.Concrete Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> ArrayModel a b -> c (ArrayModel a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ArrayModel a b) # toConstr :: ArrayModel a b -> Constr # dataTypeOf :: ArrayModel a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ArrayModel a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ArrayModel a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> ArrayModel a b -> ArrayModel a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArrayModel a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArrayModel a b -> r # gmapQ :: (forall d. Data d => d -> u) -> ArrayModel a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArrayModel a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArrayModel a b -> m (ArrayModel a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayModel a b -> m (ArrayModel a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayModel a b -> m (ArrayModel a b) # | |||||
| Generic (ArrayModel a b) Source # | |||||
Defined in Data.SBV.Core.Concrete Associated Types
Methods from :: ArrayModel a b -> Rep (ArrayModel a b) x # to :: Rep (ArrayModel a b) x -> ArrayModel a b # | |||||
| (HasKind a, HasKind b, SymVal a, SymVal b) => SymVal (ArrayModel a b) Source # | |||||
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (ArrayModel a b)) Source # literal :: ArrayModel a b -> SBV (ArrayModel a b) Source # fromCV :: CV -> ArrayModel a b Source # isConcretely :: SBV (ArrayModel a b) -> (ArrayModel a b -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (ArrayModel a b)) Source # free_ :: MonadSymbolic m => m (SBV (ArrayModel a b)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (ArrayModel a b)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (ArrayModel a b)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (ArrayModel a b)] Source # unliteral :: SBV (ArrayModel a b) -> Maybe (ArrayModel a b) Source # isConcrete :: SBV (ArrayModel a b) -> Bool Source # isSymbolic :: SBV (ArrayModel a b) -> Bool Source # | |||||
| (HasKind a, HasKind b) => HasKind (ArrayModel a b) Source # | The kind of an ArrayModel | ||||
Defined in Data.SBV.Core.Concrete Methods kindOf :: ArrayModel a b -> Kind Source # hasSign :: ArrayModel a b -> Bool Source # intSizeOf :: ArrayModel a b -> Int Source # isBoolean :: ArrayModel a b -> Bool Source # isBounded :: ArrayModel a b -> Bool Source # isReal :: ArrayModel a b -> Bool Source # isFloat :: ArrayModel a b -> Bool Source # isDouble :: ArrayModel a b -> Bool Source # isRational :: ArrayModel a b -> Bool Source # isFP :: ArrayModel a b -> Bool Source # isUnbounded :: ArrayModel a b -> Bool Source # isUserSort :: ArrayModel a b -> Bool Source # isChar :: ArrayModel a b -> Bool Source # isString :: ArrayModel a b -> Bool Source # isList :: ArrayModel a b -> Bool Source # isSet :: ArrayModel a b -> Bool Source # isTuple :: ArrayModel a b -> Bool Source # isMaybe :: ArrayModel a b -> Bool Source # isEither :: ArrayModel a b -> Bool Source # isArray :: ArrayModel a b -> Bool Source # showType :: ArrayModel a b -> String Source # | |||||
| type Rep (ArrayModel a b) Source # | |||||
Defined in Data.SBV.Core.Concrete type Rep (ArrayModel a b) = D1 ('MetaData "ArrayModel" "Data.SBV.Core.Concrete" "sbv-11.4-inplace" 'False) (C1 ('MetaCons "ArrayModel" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(a, b)]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) | |||||
A CV represents a concrete word of a fixed size:
For signed words, the most significant digit is considered to be the sign.
Instances
| NFData CV Source # | |||||
Defined in Data.SBV.Core.Concrete | |||||
| Data CV Source # | |||||
Defined in Data.SBV.Core.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CV -> c CV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CV # dataTypeOf :: CV -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CV) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CV) # gmapT :: (forall b. Data b => b -> b) -> CV -> CV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CV -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CV -> r # gmapQ :: (forall d. Data d => d -> u) -> CV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CV -> m CV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CV -> m CV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CV -> m CV # | |||||
| Generic CV Source # | |||||
Defined in Data.SBV.Core.Concrete Associated Types
| |||||
| Show CV Source # | Show instance for | ||||
| Eq CV Source # | |||||
| Ord CV Source # | |||||
| HasKind CV Source # |
| ||||
Defined in Data.SBV.Core.Concrete Methods hasSign :: CV -> Bool Source # intSizeOf :: CV -> Int Source # isBoolean :: CV -> Bool Source # isBounded :: CV -> Bool Source # isFloat :: CV -> Bool Source # isDouble :: CV -> Bool Source # isRational :: CV -> Bool Source # isUnbounded :: CV -> Bool Source # isUserSort :: CV -> Bool Source # isString :: CV -> Bool Source # isTuple :: CV -> Bool Source # isMaybe :: CV -> Bool Source # isEither :: CV -> Bool Source # | |||||
| SDivisible CV Source # | |||||
| SatModel CV Source # |
| ||||
| PrettyNum CV Source # | |||||
| type Rep CV Source # | |||||
Defined in Data.SBV.Core.Concrete type Rep CV = D1 ('MetaData "CV" "Data.SBV.Core.Concrete" "sbv-11.4-inplace" 'False) (C1 ('MetaCons "CV" 'PrefixI 'True) (S1 ('MetaSel ('Just "_cvKind") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Kind) :*: S1 ('MetaSel ('Just "cvVal") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CVal))) | |||||
A constant value. Note: If you add a new constructor here, make sure you add the corresponding equality in the instance "Eq CVal" and "Ord CVal"!
Constructors
| CAlgReal !AlgReal | Algebraic real |
| CInteger !Integer | Bit-vector/unbounded integer |
| CFloat !Float | Float |
| CDouble !Double | Double |
| CFP !FP | Arbitrary float |
| CRational Rational | Rational |
| CChar !Char | Character |
| CString !String | String |
| CList ![CVal] | List |
| CSet !(RCSet CVal) | Set. Can be regular or complemented. |
| CUserSort !(Maybe Int, String) | Value of an uninterpreted/user kind. The Maybe Int shows index position for enumerations |
| CTuple ![CVal] | Tuple |
| CMaybe !(Maybe CVal) | Maybe |
| CEither !(Either CVal CVal) | Disjoint union |
| CArray !(ArrayModel CVal CVal) | Arrays are backed by look-up tables concretely |
Instances
| NFData CVal Source # | |||||
Defined in Data.SBV.Core.Concrete | |||||
| Data CVal Source # | |||||
Defined in Data.SBV.Core.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CVal -> c CVal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CVal # dataTypeOf :: CVal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CVal) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CVal) # gmapT :: (forall b. Data b => b -> b) -> CVal -> CVal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CVal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CVal -> r # gmapQ :: (forall d. Data d => d -> u) -> CVal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CVal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CVal -> m CVal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CVal -> m CVal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CVal -> m CVal # | |||||
| Generic CVal Source # | |||||
Defined in Data.SBV.Core.Concrete Associated Types
| |||||
| Eq CVal Source # | Eq instance for CVal. Note that we cannot simply derive Eq/Ord, since CVAlgReal doesn't have proper instances for these when values are infinitely precise reals. However, we do need a structural eq/ord for Map indexes; so define custom ones here: | ||||
| Ord CVal Source # | Ord instance for CVal. Same comments as the | ||||
| type Rep CVal Source # | |||||
Defined in Data.SBV.Core.Concrete type Rep CVal = D1 ('MetaData "CVal" "Data.SBV.Core.Concrete" "sbv-11.4-inplace" 'False) (((C1 ('MetaCons "CAlgReal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 AlgReal)) :+: (C1 ('MetaCons "CInteger" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Integer)) :+: C1 ('MetaCons "CFloat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Float)))) :+: ((C1 ('MetaCons "CDouble" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Double)) :+: C1 ('MetaCons "CFP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FP))) :+: (C1 ('MetaCons "CRational" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "CChar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Char))))) :+: (((C1 ('MetaCons "CString" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String)) :+: C1 ('MetaCons "CList" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 [CVal]))) :+: (C1 ('MetaCons "CSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (RCSet CVal))) :+: C1 ('MetaCons "CUserSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe Int, String))))) :+: ((C1 ('MetaCons "CTuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 [CVal])) :+: C1 ('MetaCons "CMaybe" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe CVal)))) :+: (C1 ('MetaCons "CEither" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Either CVal CVal))) :+: C1 ('MetaCons "CArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (ArrayModel CVal CVal))))))) | |||||
A simple expression type over extended values, covering infinity, epsilon and intervals.
Constructors
| Infinite Kind | |
| Epsilon Kind | |
| Interval ExtCV ExtCV | |
| BoundedCV CV | |
| AddExtCV ExtCV ExtCV | |
| MulExtCV ExtCV ExtCV |
Instances
| Show ExtCV Source # | Show instance, shows with the kind |
| HasKind ExtCV Source # | Kind instance for Extended CV |
Defined in Data.SBV.Core.Concrete Methods kindOf :: ExtCV -> Kind Source # hasSign :: ExtCV -> Bool Source # intSizeOf :: ExtCV -> Int Source # isBoolean :: ExtCV -> Bool Source # isBounded :: ExtCV -> Bool Source # isReal :: ExtCV -> Bool Source # isFloat :: ExtCV -> Bool Source # isDouble :: ExtCV -> Bool Source # isRational :: ExtCV -> Bool Source # isFP :: ExtCV -> Bool Source # isUnbounded :: ExtCV -> Bool Source # isUserSort :: ExtCV -> Bool Source # isChar :: ExtCV -> Bool Source # isString :: ExtCV -> Bool Source # isList :: ExtCV -> Bool Source # isSet :: ExtCV -> Bool Source # isTuple :: ExtCV -> Bool Source # isMaybe :: ExtCV -> Bool Source # isEither :: ExtCV -> Bool Source # | |
data GeneralizedCV Source #
A generalized CV allows for expressions involving infinite and epsilon values/intervals Used in optimization problems.
Constructors
| ExtendedCV ExtCV | |
| RegularCV CV |
Instances
| NFData GeneralizedCV Source # | |
Defined in Data.SBV.Core.Symbolic Methods rnf :: GeneralizedCV -> () # | |
| Show GeneralizedCV Source # | Show instance for Generalized |
Defined in Data.SBV.Core.Concrete Methods showsPrec :: Int -> GeneralizedCV -> ShowS # show :: GeneralizedCV -> String # showList :: [GeneralizedCV] -> ShowS # | |
| HasKind GeneralizedCV Source # |
|
Defined in Data.SBV.Core.Concrete Methods kindOf :: GeneralizedCV -> Kind Source # hasSign :: GeneralizedCV -> Bool Source # intSizeOf :: GeneralizedCV -> Int Source # isBoolean :: GeneralizedCV -> Bool Source # isBounded :: GeneralizedCV -> Bool Source # isReal :: GeneralizedCV -> Bool Source # isFloat :: GeneralizedCV -> Bool Source # isDouble :: GeneralizedCV -> Bool Source # isRational :: GeneralizedCV -> Bool Source # isFP :: GeneralizedCV -> Bool Source # isUnbounded :: GeneralizedCV -> Bool Source # isUserSort :: GeneralizedCV -> Bool Source # isChar :: GeneralizedCV -> Bool Source # isString :: GeneralizedCV -> Bool Source # isList :: GeneralizedCV -> Bool Source # isSet :: GeneralizedCV -> Bool Source # isTuple :: GeneralizedCV -> Bool Source # isMaybe :: GeneralizedCV -> Bool Source # isEither :: GeneralizedCV -> Bool Source # isArray :: GeneralizedCV -> Bool Source # showType :: GeneralizedCV -> String Source # | |
A RCSet is either a regular set or a set given by its complement from the corresponding universal set.
Constructors
| RegularSet (Set a) | |
| ComplementSet (Set a) |
Instances
| NFData a => NFData (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Concrete | |||||
| (Data a, Ord a) => Data (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RCSet a -> c (RCSet a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RCSet a) # toConstr :: RCSet a -> Constr # dataTypeOf :: RCSet a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RCSet a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RCSet a)) # gmapT :: (forall b. Data b => b -> b) -> RCSet a -> RCSet a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RCSet a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RCSet a -> r # gmapQ :: (forall d. Data d => d -> u) -> RCSet a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RCSet a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RCSet a -> m (RCSet a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RCSet a -> m (RCSet a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RCSet a -> m (RCSet a) # | |||||
| Generic (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Concrete Associated Types
| |||||
| Show a => Show (RCSet a) Source # | Show instance. Regular sets are shown as usual. Complements are shown "U -" notation. | ||||
| (Ord a, SymVal a) => SymVal (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (RCSet a)) Source # literal :: RCSet a -> SBV (RCSet a) Source # fromCV :: CV -> RCSet a Source # isConcretely :: SBV (RCSet a) -> (RCSet a -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (RCSet a)) Source # free_ :: MonadSymbolic m => m (SBV (RCSet a)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (RCSet a)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (RCSet a)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (RCSet a)] Source # unliteral :: SBV (RCSet a) -> Maybe (RCSet a) Source # | |||||
| HasKind a => HasKind (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Concrete Methods kindOf :: RCSet a -> Kind Source # hasSign :: RCSet a -> Bool Source # intSizeOf :: RCSet a -> Int Source # isBoolean :: RCSet a -> Bool Source # isBounded :: RCSet a -> Bool Source # isReal :: RCSet a -> Bool Source # isFloat :: RCSet a -> Bool Source # isDouble :: RCSet a -> Bool Source # isRational :: RCSet a -> Bool Source # isFP :: RCSet a -> Bool Source # isUnbounded :: RCSet a -> Bool Source # isUserSort :: RCSet a -> Bool Source # isChar :: RCSet a -> Bool Source # isString :: RCSet a -> Bool Source # isList :: RCSet a -> Bool Source # isSet :: RCSet a -> Bool Source # isTuple :: RCSet a -> Bool Source # isMaybe :: RCSet a -> Bool Source # isEither :: RCSet a -> Bool Source # | |||||
| type Rep (RCSet a) Source # | |||||
Defined in Data.SBV.Core.Concrete type Rep (RCSet a) = D1 ('MetaData "RCSet" "Data.SBV.Core.Concrete" "sbv-11.4-inplace" 'False) (C1 ('MetaCons "RegularSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set a))) :+: C1 ('MetaCons "ComplementSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set a)))) | |||||
class MonadSymbolic m => Constraint (m :: Type -> Type) a where Source #
Values that we can turn into a constraint
Methods
mkConstraint :: State -> a -> m () Source #
Instances
| MonadSymbolic m => Constraint m SBool Source # | Base case: simple booleans |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> SBool -> m () Source # | |
| (SymVal a, Constraint m r) => Constraint m (Exists nm a -> r) Source # | Functions of a single existential |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (Exists nm a -> r) -> m () Source # | |
| (KnownNat n, SymVal a, Constraint m r) => Constraint m (ExistsN n nm a -> r) Source # | Functions of a number of existentials |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ExistsN n nm a -> r) -> m () Source # | |
| (SymVal a, Constraint m r, EqSymbolic (SBV a), QuantifiedBool r) => Constraint m (ExistsUnique nm a -> r) Source # | Functions of a unique single existential |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ExistsUnique nm a -> r) -> m () Source # | |
| (SymVal a, Constraint m r) => Constraint m (Forall nm a -> r) Source # | Functions of a single universal |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (Forall nm a -> r) -> m () Source # | |
| (KnownNat n, SymVal a, Constraint m r) => Constraint m (ForallN n nm a -> r) Source # | Functions of a number of universals |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ForallN n nm a -> r) -> m () Source # | |
class EqSymbolic a where Source #
Symbolic Equality. Note that we can't use Haskell's Eq class since Haskell insists on returning Bool
Comparing symbolic values will necessarily return a symbolic value.
NB. Equality is a built-in notion in SMTLib, and is object-equality. While this mostly matches Haskell's
notion of equality, the correspondence isn't exact. This mostly shows up in containers with floats inside,
such as sequences of floats, sets of doubles, and arrays of doubles. While SBV tries to maintain Haskell
semantics, it does resort to container equality for compound types. For instance, for an IEEE-float,
-0 == 0. But for an SMTLib sequence, equals is done over objects. i.e., [0] == [-0] in Haskell, but
literal [0] ./= literal [-0] when used as SMTLib sequences. The rabbit-hole goes deep here, especially
when NaN is involved, which does not compare equal to itself per IEEE-semantics.
If you are not using floats, then you can ignore all this. If you do, then SBV will do the right thing for them when checking equality directly, but not when you use containers with floating-point elements. In the latter case, object-equality will be used.
Minimal complete definition: None, if the type is instance of Generic. Otherwise (.==).
Minimal complete definition
Nothing
Methods
(.==) :: a -> a -> SBool infix 4 Source #
Symbolic equality.
(./=) :: a -> a -> SBool infix 4 Source #
Symbolic inequality.
(.===) :: a -> a -> SBool infix 4 Source #
Strong equality. On floats (SFloat/SDouble), strong equality is object equality; that
is NaN == NaN holds, but +0 == -0 doesn't. On other types, (.===) is simply (.==).
Note that (.==) is the right notion of equality for floats per IEEE754 specs, since by
definition +0 == -0 and NaN equals no other value including itself. But occasionally
we want to be stronger and state NaN equals NaN and +0 and -0 are different from
each other. In a context where your type is concrete, simply use fpIsEqualObject. But in
a polymorphic context, use the strong equality instead.
NB. If you do not care about or work with floats, simply use (.==) and (./=).
(./==) :: a -> a -> SBool infix 4 Source #
Negation of strong equality. Equaivalent to negation of (.===) on all types.
distinct :: [a] -> SBool Source #
Returns (symbolic) sTrue if all the elements of the given list are different.
distinctExcept :: [a] -> [a] -> SBool Source #
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.
allEqual :: [a] -> SBool Source #
Returns (symbolic) sTrue if all the elements of the given list are the same.
sElem :: a -> [a] -> SBool Source #
Symbolic membership test.
sNotElem :: a -> [a] -> SBool Source #
Symbolic negated membership test.
Instances
| EqSymbolic RegExp Source # | Regular expressions can be compared for equality. Note that we diverge here from the equality in the concrete sense; i.e., the Eq instance does not match the symbolic case. This is a bit unfortunate, but unavoidable with the current design of how we "distinguish" operators. Hopefully shouldn't be a big deal, though one should be careful. |
Defined in Data.SBV.Core.Model Methods (.==) :: RegExp -> RegExp -> SBool Source # (./=) :: RegExp -> RegExp -> SBool Source # (.===) :: RegExp -> RegExp -> SBool Source # (./==) :: RegExp -> RegExp -> SBool Source # distinct :: [RegExp] -> SBool Source # distinctExcept :: [RegExp] -> [RegExp] -> SBool Source # allEqual :: [RegExp] -> SBool Source # | |
| EqSymbolic Bool Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: Bool -> Bool -> SBool Source # (./=) :: Bool -> Bool -> SBool Source # (.===) :: Bool -> Bool -> SBool Source # (./==) :: Bool -> Bool -> SBool Source # distinct :: [Bool] -> SBool Source # distinctExcept :: [Bool] -> [Bool] -> SBool Source # allEqual :: [Bool] -> SBool Source # | |
| EqSymbolic a => EqSymbolic (NonEmpty a) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: NonEmpty a -> NonEmpty a -> SBool Source # (./=) :: NonEmpty a -> NonEmpty a -> SBool Source # (.===) :: NonEmpty a -> NonEmpty a -> SBool Source # (./==) :: NonEmpty a -> NonEmpty a -> SBool Source # distinct :: [NonEmpty a] -> SBool Source # distinctExcept :: [NonEmpty a] -> [NonEmpty a] -> SBool Source # allEqual :: [NonEmpty a] -> SBool Source # | |
| (HasKind a, SymVal a) => EqSymbolic (SBV a) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: SBV a -> SBV a -> SBool Source # (./=) :: SBV a -> SBV a -> SBool Source # (.===) :: SBV a -> SBV a -> SBool Source # (./==) :: SBV a -> SBV a -> SBool Source # distinct :: [SBV a] -> SBool Source # distinctExcept :: [SBV a] -> [SBV a] -> SBool Source # allEqual :: [SBV a] -> SBool Source # | |
| EqSymbolic a => EqSymbolic (S a) Source # | Symbolic equality for |
Defined in Documentation.SBV.Examples.ProofTools.BMC Methods (.==) :: S a -> S a -> SBool Source # (./=) :: S a -> S a -> SBool Source # (.===) :: S a -> S a -> SBool Source # (./==) :: S a -> S a -> SBool Source # distinct :: [S a] -> SBool Source # distinctExcept :: [S a] -> [S a] -> SBool Source # allEqual :: [S a] -> SBool Source # | |
| EqSymbolic a => EqSymbolic (Maybe a) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: Maybe a -> Maybe a -> SBool Source # (./=) :: Maybe a -> Maybe a -> SBool Source # (.===) :: Maybe a -> Maybe a -> SBool Source # (./==) :: Maybe a -> Maybe a -> SBool Source # distinct :: [Maybe a] -> SBool Source # distinctExcept :: [Maybe a] -> [Maybe a] -> SBool Source # allEqual :: [Maybe a] -> SBool Source # | |
| EqSymbolic a => EqSymbolic [a] Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: [a] -> [a] -> SBool Source # (./=) :: [a] -> [a] -> SBool Source # (.===) :: [a] -> [a] -> SBool Source # (./==) :: [a] -> [a] -> SBool Source # distinct :: [[a]] -> SBool Source # distinctExcept :: [[a]] -> [[a]] -> SBool Source # allEqual :: [[a]] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b) => EqSymbolic (Either a b) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: Either a b -> Either a b -> SBool Source # (./=) :: Either a b -> Either a b -> SBool Source # (.===) :: Either a b -> Either a b -> SBool Source # (./==) :: Either a b -> Either a b -> SBool Source # distinct :: [Either a b] -> SBool Source # distinctExcept :: [Either a b] -> [Either a b] -> SBool Source # allEqual :: [Either a b] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b) => EqSymbolic (a, b) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b) -> (a, b) -> SBool Source # (./=) :: (a, b) -> (a, b) -> SBool Source # (.===) :: (a, b) -> (a, b) -> SBool Source # (./==) :: (a, b) -> (a, b) -> SBool Source # distinct :: [(a, b)] -> SBool Source # distinctExcept :: [(a, b)] -> [(a, b)] -> SBool Source # allEqual :: [(a, b)] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b, EqSymbolic c) => EqSymbolic (a, b, c) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b, c) -> (a, b, c) -> SBool Source # (./=) :: (a, b, c) -> (a, b, c) -> SBool Source # (.===) :: (a, b, c) -> (a, b, c) -> SBool Source # (./==) :: (a, b, c) -> (a, b, c) -> SBool Source # distinct :: [(a, b, c)] -> SBool Source # distinctExcept :: [(a, b, c)] -> [(a, b, c)] -> SBool Source # allEqual :: [(a, b, c)] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d) => EqSymbolic (a, b, c, d) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b, c, d) -> (a, b, c, d) -> SBool Source # (./=) :: (a, b, c, d) -> (a, b, c, d) -> SBool Source # (.===) :: (a, b, c, d) -> (a, b, c, d) -> SBool Source # (./==) :: (a, b, c, d) -> (a, b, c, d) -> SBool Source # distinct :: [(a, b, c, d)] -> SBool Source # distinctExcept :: [(a, b, c, d)] -> [(a, b, c, d)] -> SBool Source # allEqual :: [(a, b, c, d)] -> SBool Source # sElem :: (a, b, c, d) -> [(a, b, c, d)] -> SBool Source # sNotElem :: (a, b, c, d) -> [(a, b, c, d)] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e) => EqSymbolic (a, b, c, d, e) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> SBool Source # (./=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> SBool Source # (.===) :: (a, b, c, d, e) -> (a, b, c, d, e) -> SBool Source # (./==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> SBool Source # distinct :: [(a, b, c, d, e)] -> SBool Source # distinctExcept :: [(a, b, c, d, e)] -> [(a, b, c, d, e)] -> SBool Source # allEqual :: [(a, b, c, d, e)] -> SBool Source # sElem :: (a, b, c, d, e) -> [(a, b, c, d, e)] -> SBool Source # sNotElem :: (a, b, c, d, e) -> [(a, b, c, d, e)] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f) => EqSymbolic (a, b, c, d, e, f) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> SBool Source # (./=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> SBool Source # (.===) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> SBool Source # (./==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> SBool Source # distinct :: [(a, b, c, d, e, f)] -> SBool Source # distinctExcept :: [(a, b, c, d, e, f)] -> [(a, b, c, d, e, f)] -> SBool Source # allEqual :: [(a, b, c, d, e, f)] -> SBool Source # sElem :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)] -> SBool Source # sNotElem :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)] -> SBool Source # | |
| (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f, EqSymbolic g) => EqSymbolic (a, b, c, d, e, f, g) Source # | |
Defined in Data.SBV.Core.Model Methods (.==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> SBool Source # (./=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> SBool Source # (.===) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> SBool Source # (./==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> SBool Source # distinct :: [(a, b, c, d, e, f, g)] -> SBool Source # distinctExcept :: [(a, b, c, d, e, f, g)] -> [(a, b, c, d, e, f, g)] -> SBool Source # allEqual :: [(a, b, c, d, e, f, g)] -> SBool Source # sElem :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)] -> SBool Source # sNotElem :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)] -> SBool Source # | |
class MonadSymbolic m => Lambda (m :: Type -> Type) a where Source #
Values that we can turn into a lambda abstraction
class Outputtable a where Source #
A class representing what can be returned from a symbolic computation.
Instances
| Outputtable () Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => () -> m () Source # | |
| Outputtable (SBV a) Source # | |
Defined in Data.SBV.Core.Data | |
| Outputtable a => Outputtable [a] Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => [a] -> m [a] Source # | |
| (Outputtable a, Outputtable b) => Outputtable (a, b) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b) -> m (a, b) Source # | |
| (Outputtable a, Outputtable b, Outputtable c) => Outputtable (a, b, c) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c) -> m (a, b, c) Source # | |
| (Outputtable a, Outputtable b, Outputtable c, Outputtable d) => Outputtable (a, b, c, d) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c, d) -> m (a, b, c, d) Source # | |
| (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e) => Outputtable (a, b, c, d, e) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c, d, e) -> m (a, b, c, d, e) Source # | |
| (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f) => Outputtable (a, b, c, d, e, f) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source # | |
| (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g) => Outputtable (a, b, c, d, e, f, g) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source # | |
| (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g, Outputtable h) => Outputtable (a, b, c, d, e, f, g, h) Source # | |
Defined in Data.SBV.Core.Data Methods output :: MonadSymbolic m => (a, b, c, d, e, f, g, h) -> m (a, b, c, d, e, f, g, h) Source # | |
class QuantifiedBool a where Source #
A value that can be used as a quantified boolean
Methods
quantifiedBool :: a -> SBool Source #
Turn a quantified boolean into a regular boolean. That is, this function turns an exists/forall quantified formula to a simple boolean that can be used as a regular boolean value. An example is:
quantifiedBool $ \(Forall x) (Exists y) -> y .> (x :: SInteger)
is equivalent to sTrue. You can think of this function as performing quantifier-elimination: It takes
a quantified formula, and reduces it to a simple boolean that is equivalent to it, but has no quantifiers.
Instances
| QuantifiedBool SBool Source # | Base case of quantification, simple booleans |
Defined in Data.SBV.Core.Data Methods quantifiedBool :: SBool -> SBool Source # | |
| Constraint Symbolic a => QuantifiedBool a Source # | A constraint can be turned into a boolean |
Defined in Data.SBV.Lambda Methods quantifiedBool :: a -> SBool Source # | |
type SArray a b = SBV (ArrayModel a b) Source #
Symbolic arrays. A symbolic array is more akin to a function in SMTLib (and thus in SBV),
as opposed to contagious-storage with a finite range as found in many programming languages.
Additionally, the domain uses object-equality in the SMTLib semantics. Object equality is
the same as regular equality for most types, except for IEEE-Floats, where NaN doesn't compare
equal to itself and +0 and -0 are not distinguished. So, if your index type is a float,
then NaN can be stored correctly, and 0 and -0 will be distinguished. If you don't use
floats, then you can treat this the same as regular equality in Haskell.
The Symbolic value. The parameter a is phantom, but is
extremely important in keeping the user interface strongly typed.
Instances
| Testable SBool Source # | |||||
| IsString SString Source # | |||||
Defined in Data.SBV.Core.Model Methods fromString :: String -> SString # | |||||
| Floating SReal Source # | SReal Floating instance, used in conjunction with the dReal solver for delta-satisfiability. Note that we do not constant fold these values (except for pi), as Haskell doesn't really have any means of computing them for arbitrary rationals. | ||||
| Num SDouble Source # | |||||
| Num SFloat Source # | |||||
| Num SInt16 Source # | |||||
| Num SInt32 Source # | |||||
| Num SInt64 Source # | |||||
| Num SInt8 Source # | |||||
| Num SInteger Source # | |||||
| Num SReal Source # | |||||
| Num SWord16 Source # | |||||
| Num SWord32 Source # | |||||
| Num SWord64 Source # | |||||
| Num SWord8 Source # | |||||
| Num SKleene Source # | The | ||||
| QNot SBool Source # | Base case; pure symbolic boolean | ||||
| QuantifiedBool SBool Source # | Base case of quantification, simple booleans | ||||
Defined in Data.SBV.Core.Data Methods quantifiedBool :: SBool -> SBool Source # | |||||
| SDivisible SInt16 Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| SDivisible SInt32 Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| SDivisible SInt64 Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| SDivisible SInt8 Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| SDivisible SInteger Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| SDivisible SWord16 Source # | |||||
| SDivisible SWord32 Source # | |||||
| SDivisible SWord64 Source # | |||||
| SDivisible SWord8 Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| RegExpMatchable SChar Source # | Matching a character simply means the singleton string matches the regex. | ||||
| RegExpMatchable SString Source # | Matching symbolic strings. | ||||
| ArithOverflow SInt16 Source # | |||||
| ArithOverflow SInt32 Source # | |||||
| ArithOverflow SInt64 Source # | |||||
| ArithOverflow SInt8 Source # | |||||
| ArithOverflow SWord16 Source # | |||||
| ArithOverflow SWord32 Source # | |||||
| ArithOverflow SWord64 Source # | |||||
| ArithOverflow SWord8 Source # | |||||
| Polynomial SWord16 Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord16 Source # pAdd :: SWord16 -> SWord16 -> SWord16 Source # pMult :: (SWord16, SWord16, [Int]) -> SWord16 Source # pDiv :: SWord16 -> SWord16 -> SWord16 Source # pMod :: SWord16 -> SWord16 -> SWord16 Source # pDivMod :: SWord16 -> SWord16 -> (SWord16, SWord16) Source # | |||||
| Polynomial SWord32 Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord32 Source # pAdd :: SWord32 -> SWord32 -> SWord32 Source # pMult :: (SWord32, SWord32, [Int]) -> SWord32 Source # pDiv :: SWord32 -> SWord32 -> SWord32 Source # pMod :: SWord32 -> SWord32 -> SWord32 Source # pDivMod :: SWord32 -> SWord32 -> (SWord32, SWord32) Source # | |||||
| Polynomial SWord64 Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord64 Source # pAdd :: SWord64 -> SWord64 -> SWord64 Source # pMult :: (SWord64, SWord64, [Int]) -> SWord64 Source # pDiv :: SWord64 -> SWord64 -> SWord64 Source # pMod :: SWord64 -> SWord64 -> SWord64 Source # pDivMod :: SWord64 -> SWord64 -> (SWord64, SWord64) Source # | |||||
| Polynomial SWord8 Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord8 Source # pAdd :: SWord8 -> SWord8 -> SWord8 Source # pMult :: (SWord8, SWord8, [Int]) -> SWord8 Source # pDiv :: SWord8 -> SWord8 -> SWord8 Source # pMod :: SWord8 -> SWord8 -> SWord8 Source # pDivMod :: SWord8 -> SWord8 -> (SWord8, SWord8) Source # | |||||
| BooleanAlgebra SStroke Source # | The boolean algebra of the sheffer stroke. | ||||
Defined in Documentation.SBV.Examples.KnuckleDragger.ShefferStroke Methods ﬧ :: SStroke -> SStroke Source # (⨆) :: SStroke -> SStroke -> SStroke Source # (⨅) :: SStroke -> SStroke -> SStroke Source # (≤) :: SStroke -> SStroke -> SBool Source # (<) :: SStroke -> SStroke -> SBool Source # (\\) :: SStroke -> SStroke -> SStroke Source # | |||||
| Queriable IO SState Source # |
| ||||
Defined in Documentation.SBV.Examples.Puzzles.DieHard Associated Types
| |||||
| MonadSymbolic m => Constraint m SBool Source # | Base case: simple booleans | ||||
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> SBool -> m () Source # | |||||
| ExtractIO m => ProvableM m SBool Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: SBool -> SymbolicT m SBool Source # prove :: SBool -> m ThmResult Source # proveWith :: SMTConfig -> SBool -> m ThmResult Source # dprove :: SBool -> m ThmResult Source # dproveWith :: SMTConfig -> SBool -> m ThmResult Source # isVacuousProof :: SBool -> m Bool Source # isVacuousProofWith :: SMTConfig -> SBool -> m Bool Source # | |||||
| ExtractIO m => SatisfiableM m SBool Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SBool -> SymbolicT m SBool Source # sat :: SBool -> m SatResult Source # satWith :: SMTConfig -> SBool -> m SatResult Source # dsat :: SBool -> m SatResult Source # dsatWith :: SMTConfig -> SBool -> m SatResult Source # allSat :: SBool -> m AllSatResult Source # allSatWith :: SMTConfig -> SBool -> m AllSatResult Source # isSatisfiable :: SBool -> m Bool Source # isSatisfiableWith :: SMTConfig -> SBool -> m Bool Source # optimize :: OptimizeStyle -> SBool -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SBool -> m OptimizeResult Source # | |||||
| Queriable IO (S SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.ProofTools.BMC Associated Types
| |||||
| Queriable IO (S SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.ProofTools.Fibonacci Associated Types
| |||||
| Queriable IO (S SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.ProofTools.Strengthen Associated Types
| |||||
| Queriable IO (S SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.ProofTools.Sum Associated Types
| |||||
| Queriable IO (AppS (SList Integer)) Source # |
| ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.Append Associated Types
| |||||
| Queriable IO (IncS SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.Basics Associated Types
| |||||
| Queriable IO (FibS SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.Fib Associated Types
| |||||
| Queriable IO (GCDS SInteger) Source # | 'Queriable instance for our state | ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.GCD Associated Types
| |||||
| SymVal a => Queriable IO (DivS (SBV a)) Source # |
| ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.IntDiv Associated Types
| |||||
| SymVal a => Queriable IO (SqrtS (SBV a)) Source # | 'Queriable instance for the program state | ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.IntSqrt Associated Types
| |||||
| Queriable IO (SumS SInteger) Source # |
| ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.Sum Associated Types
| |||||
| (MonadIO m, SymVal a) => Queriable m (SBV a) Source # | Generic | ||||
| MonadSymbolic m => Lambda m (SBV a) Source # | Base case, simple values | ||||
| ExtractIO m => SExecutable m (SBV a) Source # | |||||
| ExtractIO m => SExecutable m [SBV a] Source # | |||||
| Queriable IO (LenS (SList Integer) SInteger) Source # | Injection/projection from concrete and symbolic values. | ||||
Defined in Documentation.SBV.Examples.WeakestPreconditions.Length Associated Types
| |||||
| (SymVal a, Lambda m r) => Lambda m (SBV a -> r) Source # | Functions | ||||
| ExtractIO m => ProvableM m (SymbolicT m SBool) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: SymbolicT m SBool -> SymbolicT m SBool Source # prove :: SymbolicT m SBool -> m ThmResult Source # proveWith :: SMTConfig -> SymbolicT m SBool -> m ThmResult Source # dprove :: SymbolicT m SBool -> m ThmResult Source # dproveWith :: SMTConfig -> SymbolicT m SBool -> m ThmResult Source # isVacuousProof :: SymbolicT m SBool -> m Bool Source # isVacuousProofWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # isTheorem :: SymbolicT m SBool -> m Bool Source # isTheoremWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # | |||||
| (SymVal a, ProvableM m p) => ProvableM m (SBV a -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (SBV a -> p) -> SymbolicT m SBool Source # prove :: (SBV a -> p) -> m ThmResult Source # proveWith :: SMTConfig -> (SBV a -> p) -> m ThmResult Source # dprove :: (SBV a -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> (SBV a -> p) -> m ThmResult Source # isVacuousProof :: (SBV a -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # isTheorem :: (SBV a -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, ProvableM m p) => ProvableM m ((SBV a, SBV b) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b) => SExecutable m (SBV a, SBV b) Source # | |||||
| (SymVal a, SExecutable m p) => SExecutable m (SBV a -> p) Source # | |||||
| (SymVal a, SymVal b, SExecutable m p) => SExecutable m ((SBV a, SBV b) -> p) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c) -> p) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover | |||||
| ExtractIO m => SatisfiableM m (SymbolicT m SBool) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SymbolicT m SBool -> SymbolicT m SBool Source # sat :: SymbolicT m SBool -> m SatResult Source # satWith :: SMTConfig -> SymbolicT m SBool -> m SatResult Source # dsat :: SymbolicT m SBool -> m SatResult Source # dsatWith :: SMTConfig -> SymbolicT m SBool -> m SatResult Source # allSat :: SymbolicT m SBool -> m AllSatResult Source # allSatWith :: SMTConfig -> SymbolicT m SBool -> m AllSatResult Source # isSatisfiable :: SymbolicT m SBool -> m Bool Source # isSatisfiableWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # optimize :: OptimizeStyle -> SymbolicT m SBool -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SymbolicT m SBool -> m OptimizeResult Source # | |||||
| (SymVal a, SatisfiableM m p) => SatisfiableM m (SBV a -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (SBV a -> p) -> SymbolicT m SBool Source # sat :: (SBV a -> p) -> m SatResult Source # satWith :: SMTConfig -> (SBV a -> p) -> m SatResult Source # dsat :: (SBV a -> p) -> m SatResult Source # dsatWith :: SMTConfig -> (SBV a -> p) -> m SatResult Source # allSat :: (SBV a -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> (SBV a -> p) -> m AllSatResult Source # isSatisfiable :: (SBV a -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # optimize :: OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m OptimizeResult Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) Source # | |||||
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m OptimizeResult Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c) => SExecutable m (SBV a, SBV b, SBV c) Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c, NFData d, SymVal d) => SExecutable m (SBV a, SBV b, SBV c, SBV d) Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c, NFData d, SymVal d, NFData e, SymVal e) => SExecutable m (SBV a, SBV b, SBV c, SBV d, SBV e) Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c, NFData d, SymVal d, NFData e, SymVal e, NFData f, SymVal f) => SExecutable m (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) Source # | |||||
| (ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c, NFData d, SymVal d, NFData e, SymVal e, NFData f, SymVal f, NFData g, SymVal g) => SExecutable m (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) Source # | |||||
Defined in Data.SBV.Provers.Prover | |||||
| (SymVal a, Arbitrary a) => Arbitrary (SBV a) Source # | |||||
| Testable (Symbolic SBool) Source # | |||||
| NFData (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| (Ord a, Num (SBV a), Num a, Bits a, SymVal a) => Bits (SBV a) Source # | Using | ||||
Defined in Data.SBV.Core.Model Methods (.&.) :: SBV a -> SBV a -> SBV a # (.|.) :: SBV a -> SBV a -> SBV a # xor :: SBV a -> SBV a -> SBV a # complement :: SBV a -> SBV a # shift :: SBV a -> Int -> SBV a # rotate :: SBV a -> Int -> SBV a # setBit :: SBV a -> Int -> SBV a # clearBit :: SBV a -> Int -> SBV a # complementBit :: SBV a -> Int -> SBV a # testBit :: SBV a -> Int -> Bool # bitSizeMaybe :: SBV a -> Maybe Int # shiftL :: SBV a -> Int -> SBV a # unsafeShiftL :: SBV a -> Int -> SBV a # shiftR :: SBV a -> Int -> SBV a # unsafeShiftR :: SBV a -> Int -> SBV a # rotateL :: SBV a -> Int -> SBV a # | |||||
| (SymVal a, Bounded a) => Bounded (SBV a) Source # | |||||
| (Show a, Bounded a, Integral a, Num a, Num (SBV a), SymVal a) => Enum (SBV a) Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| (Ord a, Num (SBV a), SymVal a, Fractional a, Floating a) => Floating (SBV a) Source # | Define Floating instance on SBV's; only for base types that are already floating; i.e., | ||||
| Generic (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data Associated Types
| |||||
| SymVal [a] => IsList (SList a) Source # | IsList instance allows list literals to be written compactly. | ||||
| (Ord a, SymVal a, Num a, Num (SBV a)) => Num (SBV (Maybe a)) Source # | |||||
Defined in Data.SBV.Maybe Methods (+) :: SBV (Maybe a) -> SBV (Maybe a) -> SBV (Maybe a) # (-) :: SBV (Maybe a) -> SBV (Maybe a) -> SBV (Maybe a) # (*) :: SBV (Maybe a) -> SBV (Maybe a) -> SBV (Maybe a) # negate :: SBV (Maybe a) -> SBV (Maybe a) # abs :: SBV (Maybe a) -> SBV (Maybe a) # signum :: SBV (Maybe a) -> SBV (Maybe a) # fromInteger :: Integer -> SBV (Maybe a) # | |||||
| KnownNat n => Num (SInt n) Source # | |||||
| KnownNat n => Num (SWord n) Source # | |||||
| (Ord a, Num (SBV a), SymVal a, Fractional a) => Fractional (SBV a) Source # | |||||
| Show (SBV a) Source # | A | ||||
| (SymVal a, Show a) => Show (IncS (SBV a)) Source # | Show instance for | ||||
| (SymVal a, Show a) => Show (FibS (SBV a)) Source # | Show instance for | ||||
| (SymVal a, Show a) => Show (GCDS (SBV a)) Source # | Show instance for | ||||
| (SymVal a, Show a) => Show (DivS (SBV a)) Source # | Show instance for | ||||
| (SymVal a, Show a) => Show (SqrtS (SBV a)) Source # | Show instance for | ||||
| (SymVal a, Show a) => Show (SumS (SBV a)) Source # | Show instance for | ||||
| Eq (SBV a) Source # | This instance is only defined so that we can define an instance for
| ||||
| (Random a, SymVal a) => Random (SBV a) Source # | |||||
| ByteConverter (SWord 8) Source # |
| ||||
| ByteConverter (SWord 16) Source # |
| ||||
| ByteConverter (SWord 32) Source # |
| ||||
| ByteConverter (SWord 64) Source # |
| ||||
| ByteConverter (SWord 128) Source # |
| ||||
| ByteConverter (SWord 256) Source # |
| ||||
| ByteConverter (SWord 512) Source # |
| ||||
| ByteConverter (SWord 1024) Source # |
| ||||
| (HasKind a, SymVal a) => EqSymbolic (SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods (.==) :: SBV a -> SBV a -> SBool Source # (./=) :: SBV a -> SBV a -> SBool Source # (.===) :: SBV a -> SBV a -> SBool Source # (./==) :: SBV a -> SBV a -> SBool Source # distinct :: [SBV a] -> SBool Source # distinctExcept :: [SBV a] -> [SBV a] -> SBool Source # allEqual :: [SBV a] -> SBool Source # | |||||
| Outputtable (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| Skolemize (SBV a) Source # | Base case; pure symbolic values | ||||
Defined in Data.SBV.Core.Data Associated Types
| |||||
| HasKind a => HasKind (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data Methods kindOf :: SBV a -> Kind Source # hasSign :: SBV a -> Bool Source # intSizeOf :: SBV a -> Int Source # isBoolean :: SBV a -> Bool Source # isBounded :: SBV a -> Bool Source # isReal :: SBV a -> Bool Source # isFloat :: SBV a -> Bool Source # isDouble :: SBV a -> Bool Source # isRational :: SBV a -> Bool Source # isFP :: SBV a -> Bool Source # isUnbounded :: SBV a -> Bool Source # isUserSort :: SBV a -> Bool Source # isChar :: SBV a -> Bool Source # isString :: SBV a -> Bool Source # isList :: SBV a -> Bool Source # isSet :: SBV a -> Bool Source # isTuple :: SBV a -> Bool Source # isMaybe :: SBV a -> Bool Source # isEither :: SBV a -> Bool Source # | |||||
| SymVal a => Mergeable (SBV a) Source # | |||||
| (Ord a, SymVal a) => OrdSymbolic (SBV a) Source # | If comparison is over something SMTLib can handle, just translate it. Otherwise desugar. | ||||
| (KnownNat n, BVIsNonZero n) => SDivisible (SInt n) Source # |
| ||||
Defined in Data.SBV.Core.Model | |||||
| (KnownNat n, BVIsNonZero n) => SDivisible (SWord n) Source # |
| ||||
| (SymVal a, HasKind a) => SMTDefinable (SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> SBV a -> SBV a Source # registerFunction :: SBV a -> Symbolic () Source # uninterpret :: String -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV a Source # cgUninterpret :: String -> [String] -> SBV a -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV a) -> SBV a Source # | |||||
| (KnownNat n, BVIsNonZero n) => ArithOverflow (SInt n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => ArithOverflow (SWord n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Polynomial (SWord n) Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord n Source # pAdd :: SWord n -> SWord n -> SWord n Source # pMult :: (SWord n, SWord n, [Int]) -> SWord n Source # pDiv :: SWord n -> SWord n -> SWord n Source # pMod :: SWord n -> SWord n -> SWord n Source # pDivMod :: SWord n -> SWord n -> (SWord n, SWord n) Source # | |||||
| (SymVal a, PrettyNum a) => PrettyNum (SBV a) Source # | |||||
| ValidFloat eb sb => Floating (SFloatingPoint eb sb) Source # | We give a specific instance for | ||||
Defined in Data.SBV.Core.Model Methods pi :: SFloatingPoint eb sb # exp :: SFloatingPoint eb sb -> SFloatingPoint eb sb # log :: SFloatingPoint eb sb -> SFloatingPoint eb sb # sqrt :: SFloatingPoint eb sb -> SFloatingPoint eb sb # (**) :: SFloatingPoint eb sb -> SFloatingPoint eb sb -> SFloatingPoint eb sb # logBase :: SFloatingPoint eb sb -> SFloatingPoint eb sb -> SFloatingPoint eb sb # sin :: SFloatingPoint eb sb -> SFloatingPoint eb sb # cos :: SFloatingPoint eb sb -> SFloatingPoint eb sb # tan :: SFloatingPoint eb sb -> SFloatingPoint eb sb # asin :: SFloatingPoint eb sb -> SFloatingPoint eb sb # acos :: SFloatingPoint eb sb -> SFloatingPoint eb sb # atan :: SFloatingPoint eb sb -> SFloatingPoint eb sb # sinh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # cosh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # tanh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # asinh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # acosh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # atanh :: SFloatingPoint eb sb -> SFloatingPoint eb sb # log1p :: SFloatingPoint eb sb -> SFloatingPoint eb sb # expm1 :: SFloatingPoint eb sb -> SFloatingPoint eb sb # log1pexp :: SFloatingPoint eb sb -> SFloatingPoint eb sb # log1mexp :: SFloatingPoint eb sb -> SFloatingPoint eb sb # | |||||
| ValidFloat eb sb => Num (SFloatingPoint eb sb) Source # | |||||
Defined in Data.SBV.Core.Data Methods (+) :: SFloatingPoint eb sb -> SFloatingPoint eb sb -> SFloatingPoint eb sb # (-) :: SFloatingPoint eb sb -> SFloatingPoint eb sb -> SFloatingPoint eb sb # (*) :: SFloatingPoint eb sb -> SFloatingPoint eb sb -> SFloatingPoint eb sb # negate :: SFloatingPoint eb sb -> SFloatingPoint eb sb # abs :: SFloatingPoint eb sb -> SFloatingPoint eb sb # signum :: SFloatingPoint eb sb -> SFloatingPoint eb sb # fromInteger :: Integer -> SFloatingPoint eb sb # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> z) Source # | |||||
| (SymVal a, SymVal b, EqSymbolic z) => Equality (SBV a -> SBV b -> z) Source # | |||||
| (SymVal a, EqSymbolic z) => Equality (SBV a -> z) Source # | |||||
| (SymVal a, SymVal b, EqSymbolic z) => Equality ((SBV a, SBV b) -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c) -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d) -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e) -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> z) Source # | |||||
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> z) Source # | |||||
| SymVal e => Mergeable (STree i e) Source # | |||||
| (SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV b -> SBV a) -> SBV b -> SBV a Source # registerFunction :: (SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV b -> SBV a) -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV b -> SBV a) -> SBV b -> SBV a Source # sym :: String -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV b -> SBV a) -> m String Source # | |||||
| (SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV c -> SBV b -> SBV a) -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV c -> SBV b -> SBV a) -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV c -> SBV b -> SBV a) -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV d -> SBV c -> SBV b -> SBV a) -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV d -> SBV c -> SBV b -> SBV a) -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV d -> SBV c -> SBV b -> SBV a) -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, SymVal a, HasKind a) => SMTDefinable (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m => (SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m String Source # | |||||
| (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # registerFunction :: (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> Symbolic () Source # uninterpret :: String -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # uninterpretWithArgs :: String -> [String] -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # cgUninterpret :: String -> [String] -> (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sym :: String -> SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source # sbv2smt :: ExtractIO m0 => (SBV m -> SBV l -> SBV k -> SBV j -> SBV i -> SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> m0 String Source # | |||||
| (SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal m, SymVal l, SymVal k, SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m0 => ((SBV m, SBV l, SBV k, SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m0 String Source # | |||||
| (SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV c, SBV b) -> SBV a) -> (SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV c, SBV b) -> SBV a) -> (SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV c, SBV b) -> SBV a) -> (SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV d, SBV c, SBV b) -> SBV a) -> (SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV d, SBV c, SBV b) -> SBV a) -> (SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV d, SBV c, SBV b) -> SBV a) -> (SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| (SymVal j, SymVal i, SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, SymVal a, HasKind a) => SMTDefinable ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # | |||||
Defined in Data.SBV.Core.Model Methods smtFunction :: String -> ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # registerFunction :: ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> Symbolic () Source # uninterpret :: String -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # uninterpretWithArgs :: String -> [String] -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # cgUninterpret :: String -> [String] -> ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbvDefineValue :: UIName -> Maybe [String] -> UIKind ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sym :: String -> (SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a Source # sbv2smt :: ExtractIO m => ((SBV j, SBV i, SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> m String Source # | |||||
| type QueryResult SState Source # | |||||
Defined in Documentation.SBV.Examples.Puzzles.DieHard | |||||
| type NegatesTo SBool Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| type Rep (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| type Item (SList a) Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| type QueryResult (SBV a) Source # | |||||
Defined in Data.SBV | |||||
| type QueryResult (S SInteger) Source # | |||||
Defined in Documentation.SBV.Examples.ProofTools.BMC | |||||
| type QueryResult (S SInteger) Source # | |||||
| type QueryResult (S SInteger) Source # | |||||
| type QueryResult (S SInteger) Source # | |||||
Defined in Documentation.SBV.Examples.ProofTools.Sum | |||||
| type QueryResult (AppS (SList Integer)) Source # | |||||
| type QueryResult (IncS SInteger) Source # | |||||
| type QueryResult (FibS SInteger) Source # | |||||
| type QueryResult (GCDS SInteger) Source # | |||||
| type QueryResult (DivS (SBV a)) Source # | |||||
| type QueryResult (SqrtS (SBV a)) Source # | |||||
| type QueryResult (SumS SInteger) Source # | |||||
| type SkolemsTo (SBV a) Source # | |||||
Defined in Data.SBV.Core.Data | |||||
| type QueryResult (LenS (SList Integer) SInteger) Source # | |||||
type SChar = SBV Char Source #
A symbolic character. Note that this is the full unicode character set. see: https://smt-lib.org/theories-UnicodeStrings.shtml for details.
type SFloatingPoint (eb :: Nat) (sb :: Nat) = SBV (FloatingPoint eb sb) Source #
A symbolic arbitrary precision floating point value
type SList a = SBV [a] Source #
A symbolic list of items. Note that a symbolic list is not a list of symbolic items,
that is, it is not the case that SList a = [a], unlike what one might expect following
haskell lists/sequences. An SList is a symbolic value of its own, of possibly arbitrary but finite
length, and internally processed as one unit as opposed to a fixed-length list of items.
Note that lists can be nested, i.e., we do allow lists of lists of ... items.
newtype SMTProblem Source #
Internal representation of a symbolic simulation result
Constructors
| SMTProblem | SMTLib representation, given the config |
type SRoundingMode = SBV RoundingMode Source #
The symbolic variant of RoundingMode
type SSet a = SBV (RCSet a) Source #
Symbolic Set. Note that we use RCSet, which supports
both regular sets and complements, i.e., those obtained from the
universal set (of the right type) by removing elements. Similar to SArray
the contents are stored with object equality, which makes a difference if the
underlying type contains IEEE Floats.
type SString = SBV String Source #
A symbolic string. Note that a symbolic string is not a list of symbolic characters,
that is, it is not the case that SString = [SChar], unlike what one might expect following
Haskell strings. An SString is a symbolic value of its own, of possibly arbitrary but finite length,
and internally processed as one unit as opposed to a fixed-length list of characters.
class SolverContext (m :: Type -> Type) where Source #
Actions we can do in a context: Either at problem description
time or while we are dynamically querying. Symbolic and Query are
two instances of this class. Note that we use this mechanism
internally and do not export it from SBV.
Minimal complete definition
constrain, softConstrain, namedConstraint, constrainWithAttribute, setOption, contextState, internalVariable
Methods
constrain :: QuantifiedBool a => a -> m () Source #
Add a constraint, any satisfying instance must satisfy this condition.
softConstrain :: QuantifiedBool a => a -> m () Source #
Add a soft constraint. The solver will try to satisfy this condition if possible, but won't if it cannot.
namedConstraint :: QuantifiedBool a => String -> a -> m () Source #
Add a named constraint. The name is used in unsat-core extraction.
constrainWithAttribute :: QuantifiedBool a => [(String, String)] -> a -> m () Source #
Add a constraint, with arbitrary attributes.
setInfo :: String -> [String] -> m () Source #
Set info. Example: setInfo ":status" ["unsat"].
setOption :: SMTOption -> m () Source #
Set an option.
setLogic :: Logic -> m () Source #
Set the logic.
setTimeOut :: Integer -> m () Source #
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
is in milliseconds. Also see the function timeOut for finer level
control of time-outs, directly from SBV.
contextState :: m State Source #
Get the state associated with this context
internalVariable :: Kind -> m (SBV a) Source #
Get an internal-variable
Instances
| MonadIO m => SolverContext (QueryT m) Source # |
|
Defined in Data.SBV.Control.Utils Methods constrain :: QuantifiedBool a => a -> QueryT m () Source # softConstrain :: QuantifiedBool a => a -> QueryT m () Source # namedConstraint :: QuantifiedBool a => String -> a -> QueryT m () Source # constrainWithAttribute :: QuantifiedBool a => [(String, String)] -> a -> QueryT m () Source # setInfo :: String -> [String] -> QueryT m () Source # setOption :: SMTOption -> QueryT m () Source # setLogic :: Logic -> QueryT m () Source # setTimeOut :: Integer -> QueryT m () Source # contextState :: QueryT m State Source # | |
| MonadIO m => SolverContext (SymbolicT m) Source # | Symbolic computations provide a context for writing symbolic programs. |
Defined in Data.SBV.Core.Model Methods constrain :: QuantifiedBool a => a -> SymbolicT m () Source # softConstrain :: QuantifiedBool a => a -> SymbolicT m () Source # namedConstraint :: QuantifiedBool a => String -> a -> SymbolicT m () Source # constrainWithAttribute :: QuantifiedBool a => [(String, String)] -> a -> SymbolicT m () Source # setInfo :: String -> [String] -> SymbolicT m () Source # setOption :: SMTOption -> SymbolicT m () Source # setLogic :: Logic -> SymbolicT m () Source # setTimeOut :: Integer -> SymbolicT m () Source # contextState :: SymbolicT m State Source # | |
class (HasKind a, Typeable a) => SymVal a where Source #
A SymVal is a potential symbolic value that can be created instances of to be fed to a symbolic program.
Minimal complete definition
Nothing
Methods
mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV a) Source #
Generalization of mkSymVal
default mkSymVal :: (MonadSymbolic m, Read a, Data a) => VarContext -> Maybe String -> m (SBV a) Source #
literal :: a -> SBV a Source #
Turn a literal constant to symbolic
Extract a literal, from a CV representation
isConcretely :: SBV a -> (a -> Bool) -> Bool Source #
Does it concretely satisfy the given predicate?
free :: MonadSymbolic m => String -> m (SBV a) Source #
Generalization of free
free_ :: MonadSymbolic m => m (SBV a) Source #
Generalization of free_
mkFreeVars :: MonadSymbolic m => Int -> m [SBV a] Source #
Generalization of mkFreeVars
symbolic :: MonadSymbolic m => String -> m (SBV a) Source #
Generalization of symbolic
symbolics :: MonadSymbolic m => [String] -> m [SBV a] Source #
Generalization of symbolics
unliteral :: SBV a -> Maybe a Source #
Extract a literal, if the value is concrete
isConcrete :: SBV a -> Bool Source #
Is the symbolic word concrete?
isSymbolic :: SBV a -> Bool Source #
Is the symbolic word really symbolic?
Instances
| SymVal Int16 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Int16) Source # literal :: Int16 -> SBV Int16 Source # fromCV :: CV -> Int16 Source # isConcretely :: SBV Int16 -> (Int16 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Int16) Source # free_ :: MonadSymbolic m => m (SBV Int16) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Int16] Source # symbolic :: MonadSymbolic m => String -> m (SBV Int16) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Int16] Source # unliteral :: SBV Int16 -> Maybe Int16 Source # | |
| SymVal Int32 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Int32) Source # literal :: Int32 -> SBV Int32 Source # fromCV :: CV -> Int32 Source # isConcretely :: SBV Int32 -> (Int32 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Int32) Source # free_ :: MonadSymbolic m => m (SBV Int32) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Int32] Source # symbolic :: MonadSymbolic m => String -> m (SBV Int32) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Int32] Source # unliteral :: SBV Int32 -> Maybe Int32 Source # | |
| SymVal Int64 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Int64) Source # literal :: Int64 -> SBV Int64 Source # fromCV :: CV -> Int64 Source # isConcretely :: SBV Int64 -> (Int64 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Int64) Source # free_ :: MonadSymbolic m => m (SBV Int64) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Int64] Source # symbolic :: MonadSymbolic m => String -> m (SBV Int64) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Int64] Source # unliteral :: SBV Int64 -> Maybe Int64 Source # | |
| SymVal Int8 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Int8) Source # literal :: Int8 -> SBV Int8 Source # isConcretely :: SBV Int8 -> (Int8 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Int8) Source # free_ :: MonadSymbolic m => m (SBV Int8) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Int8] Source # symbolic :: MonadSymbolic m => String -> m (SBV Int8) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Int8] Source # unliteral :: SBV Int8 -> Maybe Int8 Source # | |
| SymVal Rational Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Rational) Source # literal :: Rational -> SBV Rational Source # fromCV :: CV -> Rational Source # isConcretely :: SBV Rational -> (Rational -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Rational) Source # free_ :: MonadSymbolic m => m (SBV Rational) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Rational] Source # symbolic :: MonadSymbolic m => String -> m (SBV Rational) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Rational] Source # unliteral :: SBV Rational -> Maybe Rational Source # | |
| SymVal Word16 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Word16) Source # literal :: Word16 -> SBV Word16 Source # fromCV :: CV -> Word16 Source # isConcretely :: SBV Word16 -> (Word16 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Word16) Source # free_ :: MonadSymbolic m => m (SBV Word16) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Word16] Source # symbolic :: MonadSymbolic m => String -> m (SBV Word16) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Word16] Source # unliteral :: SBV Word16 -> Maybe Word16 Source # | |
| SymVal Word32 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Word32) Source # literal :: Word32 -> SBV Word32 Source # fromCV :: CV -> Word32 Source # isConcretely :: SBV Word32 -> (Word32 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Word32) Source # free_ :: MonadSymbolic m => m (SBV Word32) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Word32] Source # symbolic :: MonadSymbolic m => String -> m (SBV Word32) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Word32] Source # unliteral :: SBV Word32 -> Maybe Word32 Source # | |
| SymVal Word64 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Word64) Source # literal :: Word64 -> SBV Word64 Source # fromCV :: CV -> Word64 Source # isConcretely :: SBV Word64 -> (Word64 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Word64) Source # free_ :: MonadSymbolic m => m (SBV Word64) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Word64] Source # symbolic :: MonadSymbolic m => String -> m (SBV Word64) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Word64] Source # unliteral :: SBV Word64 -> Maybe Word64 Source # | |
| SymVal Word8 Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Word8) Source # literal :: Word8 -> SBV Word8 Source # fromCV :: CV -> Word8 Source # isConcretely :: SBV Word8 -> (Word8 -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Word8) Source # free_ :: MonadSymbolic m => m (SBV Word8) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Word8] Source # symbolic :: MonadSymbolic m => String -> m (SBV Word8) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Word8] Source # unliteral :: SBV Word8 -> Maybe Word8 Source # | |
| SymVal AlgReal Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV AlgReal) Source # literal :: AlgReal -> SBV AlgReal Source # fromCV :: CV -> AlgReal Source # isConcretely :: SBV AlgReal -> (AlgReal -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV AlgReal) Source # free_ :: MonadSymbolic m => m (SBV AlgReal) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV AlgReal] Source # symbolic :: MonadSymbolic m => String -> m (SBV AlgReal) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV AlgReal] Source # unliteral :: SBV AlgReal -> Maybe AlgReal Source # | |
| SymVal RoundingMode Source # |
|
Defined in Data.SBV.Core.Data Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV RoundingMode) Source # literal :: RoundingMode -> SBV RoundingMode Source # fromCV :: CV -> RoundingMode Source # isConcretely :: SBV RoundingMode -> (RoundingMode -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV RoundingMode) Source # free_ :: MonadSymbolic m => m (SBV RoundingMode) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV RoundingMode] Source # symbolic :: MonadSymbolic m => String -> m (SBV RoundingMode) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV RoundingMode] Source # unliteral :: SBV RoundingMode -> Maybe RoundingMode Source # isConcrete :: SBV RoundingMode -> Bool Source # isSymbolic :: SBV RoundingMode -> Bool Source # | |
| SymVal T Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Basics Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV T) Source # literal :: T -> SBV T Source # isConcretely :: SBV T -> (T -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV T) Source # free_ :: MonadSymbolic m => m (SBV T) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV T] Source # symbolic :: MonadSymbolic m => String -> m (SBV T) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV T] Source # unliteral :: SBV T -> Maybe T Source # | |
| SymVal Kleene Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Kleene Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Kleene) Source # literal :: Kleene -> SBV Kleene Source # fromCV :: CV -> Kleene Source # isConcretely :: SBV Kleene -> (Kleene -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Kleene) Source # free_ :: MonadSymbolic m => m (SBV Kleene) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Kleene] Source # symbolic :: MonadSymbolic m => String -> m (SBV Kleene) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Kleene] Source # unliteral :: SBV Kleene -> Maybe Kleene Source # | |
| SymVal A Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Lists Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV A) Source # literal :: A -> SBV A Source # isConcretely :: SBV A -> (A -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV A) Source # free_ :: MonadSymbolic m => m (SBV A) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV A] Source # symbolic :: MonadSymbolic m => String -> m (SBV A) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV A] Source # unliteral :: SBV A -> Maybe A Source # | |
| SymVal B Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Lists Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV B) Source # literal :: B -> SBV B Source # isConcretely :: SBV B -> (B -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV B) Source # free_ :: MonadSymbolic m => m (SBV B) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV B] Source # symbolic :: MonadSymbolic m => String -> m (SBV B) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV B] Source # unliteral :: SBV B -> Maybe B Source # | |
| SymVal C Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Lists Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV C) Source # literal :: C -> SBV C Source # isConcretely :: SBV C -> (C -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV C) Source # free_ :: MonadSymbolic m => m (SBV C) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV C] Source # symbolic :: MonadSymbolic m => String -> m (SBV C) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV C] Source # unliteral :: SBV C -> Maybe C Source # | |
| SymVal Stroke Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.ShefferStroke Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Stroke) Source # literal :: Stroke -> SBV Stroke Source # fromCV :: CV -> Stroke Source # isConcretely :: SBV Stroke -> (Stroke -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Stroke) Source # free_ :: MonadSymbolic m => m (SBV Stroke) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Stroke] Source # symbolic :: MonadSymbolic m => String -> m (SBV Stroke) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Stroke] Source # unliteral :: SBV Stroke -> Maybe Stroke Source # | |
| SymVal T Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Tao Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV T) Source # literal :: T -> SBV T Source # isConcretely :: SBV T -> (T -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV T) Source # free_ :: MonadSymbolic m => m (SBV T) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV T] Source # symbolic :: MonadSymbolic m => String -> m (SBV T) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV T] Source # unliteral :: SBV T -> Maybe T Source # | |
| SymVal State Source # | |
Defined in Documentation.SBV.Examples.Lists.BoundedMutex Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV State) Source # literal :: State -> SBV State Source # fromCV :: CV -> State Source # isConcretely :: SBV State -> (State -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV State) Source # free_ :: MonadSymbolic m => m (SBV State) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV State] Source # symbolic :: MonadSymbolic m => String -> m (SBV State) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV State] Source # unliteral :: SBV State -> Maybe State Source # | |
| SymVal E Source # | |
Defined in Documentation.SBV.Examples.Misc.Enumerate Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV E) Source # literal :: E -> SBV E Source # isConcretely :: SBV E -> (E -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV E) Source # free_ :: MonadSymbolic m => m (SBV E) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV E] Source # symbolic :: MonadSymbolic m => String -> m (SBV E) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV E] Source # unliteral :: SBV E -> Maybe E Source # | |
| SymVal E Source # | |
Defined in Documentation.SBV.Examples.Misc.FirstOrderLogic Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV E) Source # literal :: E -> SBV E Source # isConcretely :: SBV E -> (E -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV E) Source # free_ :: MonadSymbolic m => m (SBV E) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV E] Source # symbolic :: MonadSymbolic m => String -> m (SBV E) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV E] Source # unliteral :: SBV E -> Maybe E Source # | |
| SymVal U Source # | |
Defined in Documentation.SBV.Examples.Misc.FirstOrderLogic Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV U) Source # literal :: U -> SBV U Source # isConcretely :: SBV U -> (U -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV U) Source # free_ :: MonadSymbolic m => m (SBV U) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV U] Source # symbolic :: MonadSymbolic m => String -> m (SBV U) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV U] Source # unliteral :: SBV U -> Maybe U Source # | |
| SymVal V Source # | |
Defined in Documentation.SBV.Examples.Misc.FirstOrderLogic Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV V) Source # literal :: V -> SBV V Source # isConcretely :: SBV V -> (V -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV V) Source # free_ :: MonadSymbolic m => m (SBV V) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV V] Source # symbolic :: MonadSymbolic m => String -> m (SBV V) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV V] Source # unliteral :: SBV V -> Maybe V Source # | |
| SymVal HumanHeightInCm Source # | Similarly here, for the |
Defined in Documentation.SBV.Examples.Misc.Newtypes Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV HumanHeightInCm) Source # literal :: HumanHeightInCm -> SBV HumanHeightInCm Source # fromCV :: CV -> HumanHeightInCm Source # isConcretely :: SBV HumanHeightInCm -> (HumanHeightInCm -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV HumanHeightInCm) Source # free_ :: MonadSymbolic m => m (SBV HumanHeightInCm) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV HumanHeightInCm] Source # symbolic :: MonadSymbolic m => String -> m (SBV HumanHeightInCm) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV HumanHeightInCm] Source # unliteral :: SBV HumanHeightInCm -> Maybe HumanHeightInCm Source # isConcrete :: SBV HumanHeightInCm -> Bool Source # isSymbolic :: SBV HumanHeightInCm -> Bool Source # | |
| SymVal Metres Source # | The |
Defined in Documentation.SBV.Examples.Misc.Newtypes Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Metres) Source # literal :: Metres -> SBV Metres Source # fromCV :: CV -> Metres Source # isConcretely :: SBV Metres -> (Metres -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Metres) Source # free_ :: MonadSymbolic m => m (SBV Metres) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Metres] Source # symbolic :: MonadSymbolic m => String -> m (SBV Metres) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Metres] Source # unliteral :: SBV Metres -> Maybe Metres Source # | |
| SymVal Day Source # | |
Defined in Documentation.SBV.Examples.Optimization.Enumerate Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Day) Source # literal :: Day -> SBV Day Source # isConcretely :: SBV Day -> (Day -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Day) Source # free_ :: MonadSymbolic m => m (SBV Day) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Day] Source # symbolic :: MonadSymbolic m => String -> m (SBV Day) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Day] Source # unliteral :: SBV Day -> Maybe Day Source # | |
| SymVal Day Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Birthday Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Day) Source # literal :: Day -> SBV Day Source # isConcretely :: SBV Day -> (Day -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Day) Source # free_ :: MonadSymbolic m => m (SBV Day) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Day] Source # symbolic :: MonadSymbolic m => String -> m (SBV Day) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Day] Source # unliteral :: SBV Day -> Maybe Day Source # | |
| SymVal Month Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Birthday Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Month) Source # literal :: Month -> SBV Month Source # fromCV :: CV -> Month Source # isConcretely :: SBV Month -> (Month -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Month) Source # free_ :: MonadSymbolic m => m (SBV Month) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Month] Source # symbolic :: MonadSymbolic m => String -> m (SBV Month) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Month] Source # unliteral :: SBV Month -> Maybe Month Source # | |
| SymVal Action Source # | |
Defined in Documentation.SBV.Examples.Puzzles.DieHard Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Action) Source # literal :: Action -> SBV Action Source # fromCV :: CV -> Action Source # isConcretely :: SBV Action -> (Action -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Action) Source # free_ :: MonadSymbolic m => m (SBV Action) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Action] Source # symbolic :: MonadSymbolic m => String -> m (SBV Action) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Action] Source # unliteral :: SBV Action -> Maybe Action Source # | |
| SymVal P Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Drinker Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV P) Source # literal :: P -> SBV P Source # isConcretely :: SBV P -> (P -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV P) Source # free_ :: MonadSymbolic m => m (SBV P) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV P] Source # symbolic :: MonadSymbolic m => String -> m (SBV P) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV P] Source # unliteral :: SBV P -> Maybe P Source # | |
| SymVal Beverage Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Beverage) Source # literal :: Beverage -> SBV Beverage Source # fromCV :: CV -> Beverage Source # isConcretely :: SBV Beverage -> (Beverage -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Beverage) Source # free_ :: MonadSymbolic m => m (SBV Beverage) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Beverage] Source # symbolic :: MonadSymbolic m => String -> m (SBV Beverage) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Beverage] Source # unliteral :: SBV Beverage -> Maybe Beverage Source # | |
| SymVal Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Color) Source # literal :: Color -> SBV Color Source # fromCV :: CV -> Color Source # isConcretely :: SBV Color -> (Color -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Color) Source # free_ :: MonadSymbolic m => m (SBV Color) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Color] Source # symbolic :: MonadSymbolic m => String -> m (SBV Color) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Color] Source # unliteral :: SBV Color -> Maybe Color Source # | |
| SymVal Nationality Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Nationality) Source # literal :: Nationality -> SBV Nationality Source # fromCV :: CV -> Nationality Source # isConcretely :: SBV Nationality -> (Nationality -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Nationality) Source # free_ :: MonadSymbolic m => m (SBV Nationality) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Nationality] Source # symbolic :: MonadSymbolic m => String -> m (SBV Nationality) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Nationality] Source # unliteral :: SBV Nationality -> Maybe Nationality Source # isConcrete :: SBV Nationality -> Bool Source # isSymbolic :: SBV Nationality -> Bool Source # | |
| SymVal Pet Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Pet) Source # literal :: Pet -> SBV Pet Source # isConcretely :: SBV Pet -> (Pet -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Pet) Source # free_ :: MonadSymbolic m => m (SBV Pet) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Pet] Source # symbolic :: MonadSymbolic m => String -> m (SBV Pet) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Pet] Source # unliteral :: SBV Pet -> Maybe Pet Source # | |
| SymVal Sport Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Sport) Source # literal :: Sport -> SBV Sport Source # fromCV :: CV -> Sport Source # isConcretely :: SBV Sport -> (Sport -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Sport) Source # free_ :: MonadSymbolic m => m (SBV Sport) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Sport] Source # symbolic :: MonadSymbolic m => String -> m (SBV Sport) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Sport] Source # unliteral :: SBV Sport -> Maybe Sport Source # | |
| SymVal Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Garden Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Color) Source # literal :: Color -> SBV Color Source # fromCV :: CV -> Color Source # isConcretely :: SBV Color -> (Color -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Color) Source # free_ :: MonadSymbolic m => m (SBV Color) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Color] Source # symbolic :: MonadSymbolic m => String -> m (SBV Color) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Color] Source # unliteral :: SBV Color -> Maybe Color Source # | |
| SymVal Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.HexPuzzle Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Color) Source # literal :: Color -> SBV Color Source # fromCV :: CV -> Color Source # isConcretely :: SBV Color -> (Color -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Color) Source # free_ :: MonadSymbolic m => m (SBV Color) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Color] Source # symbolic :: MonadSymbolic m => String -> m (SBV Color) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Color] Source # unliteral :: SBV Color -> Maybe Color Source # | |
| SymVal Identity Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Identity) Source # literal :: Identity -> SBV Identity Source # fromCV :: CV -> Identity Source # isConcretely :: SBV Identity -> (Identity -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Identity) Source # free_ :: MonadSymbolic m => m (SBV Identity) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Identity] Source # symbolic :: MonadSymbolic m => String -> m (SBV Identity) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Identity] Source # unliteral :: SBV Identity -> Maybe Identity Source # | |
| SymVal Inhabitant Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Inhabitant) Source # literal :: Inhabitant -> SBV Inhabitant Source # fromCV :: CV -> Inhabitant Source # isConcretely :: SBV Inhabitant -> (Inhabitant -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Inhabitant) Source # free_ :: MonadSymbolic m => m (SBV Inhabitant) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Inhabitant] Source # symbolic :: MonadSymbolic m => String -> m (SBV Inhabitant) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Inhabitant] Source # unliteral :: SBV Inhabitant -> Maybe Inhabitant Source # isConcrete :: SBV Inhabitant -> Bool Source # isSymbolic :: SBV Inhabitant -> Bool Source # | |
| SymVal Statement Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Statement) Source # literal :: Statement -> SBV Statement Source # fromCV :: CV -> Statement Source # isConcretely :: SBV Statement -> (Statement -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Statement) Source # free_ :: MonadSymbolic m => m (SBV Statement) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Statement] Source # symbolic :: MonadSymbolic m => String -> m (SBV Statement) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Statement] Source # unliteral :: SBV Statement -> Maybe Statement Source # | |
| SymVal Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Location) Source # literal :: Location -> SBV Location Source # fromCV :: CV -> Location Source # isConcretely :: SBV Location -> (Location -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Location) Source # free_ :: MonadSymbolic m => m (SBV Location) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Location] Source # symbolic :: MonadSymbolic m => String -> m (SBV Location) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Location] Source # unliteral :: SBV Location -> Maybe Location Source # | |
| SymVal Role Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Role) Source # literal :: Role -> SBV Role Source # isConcretely :: SBV Role -> (Role -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Role) Source # free_ :: MonadSymbolic m => m (SBV Role) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Role] Source # symbolic :: MonadSymbolic m => String -> m (SBV Role) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Role] Source # unliteral :: SBV Role -> Maybe Role Source # | |
| SymVal Sex Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Sex) Source # literal :: Sex -> SBV Sex Source # isConcretely :: SBV Sex -> (Sex -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Sex) Source # free_ :: MonadSymbolic m => m (SBV Sex) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Sex] Source # symbolic :: MonadSymbolic m => String -> m (SBV Sex) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Sex] Source # unliteral :: SBV Sex -> Maybe Sex Source # | |
| SymVal Handler Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Handler) Source # literal :: Handler -> SBV Handler Source # fromCV :: CV -> Handler Source # isConcretely :: SBV Handler -> (Handler -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Handler) Source # free_ :: MonadSymbolic m => m (SBV Handler) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Handler] Source # symbolic :: MonadSymbolic m => String -> m (SBV Handler) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Handler] Source # unliteral :: SBV Handler -> Maybe Handler Source # | |
| SymVal Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Location) Source # literal :: Location -> SBV Location Source # fromCV :: CV -> Location Source # isConcretely :: SBV Location -> (Location -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Location) Source # free_ :: MonadSymbolic m => m (SBV Location) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Location] Source # symbolic :: MonadSymbolic m => String -> m (SBV Location) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Location] Source # unliteral :: SBV Location -> Maybe Location Source # | |
| SymVal Orangutan Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Orangutan) Source # literal :: Orangutan -> SBV Orangutan Source # fromCV :: CV -> Orangutan Source # isConcretely :: SBV Orangutan -> (Orangutan -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Orangutan) Source # free_ :: MonadSymbolic m => m (SBV Orangutan) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Orangutan] Source # symbolic :: MonadSymbolic m => String -> m (SBV Orangutan) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Orangutan] Source # unliteral :: SBV Orangutan -> Maybe Orangutan Source # | |
| SymVal Rabbit Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Rabbits Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Rabbit) Source # literal :: Rabbit -> SBV Rabbit Source # fromCV :: CV -> Rabbit Source # isConcretely :: SBV Rabbit -> (Rabbit -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Rabbit) Source # free_ :: MonadSymbolic m => m (SBV Rabbit) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Rabbit] Source # symbolic :: MonadSymbolic m => String -> m (SBV Rabbit) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Rabbit] Source # unliteral :: SBV Rabbit -> Maybe Rabbit Source # | |
| SymVal Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.U2Bridge Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Location) Source # literal :: Location -> SBV Location Source # fromCV :: CV -> Location Source # isConcretely :: SBV Location -> (Location -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Location) Source # free_ :: MonadSymbolic m => m (SBV Location) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Location] Source # symbolic :: MonadSymbolic m => String -> m (SBV Location) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Location] Source # unliteral :: SBV Location -> Maybe Location Source # | |
| SymVal U2Member Source # | |
Defined in Documentation.SBV.Examples.Puzzles.U2Bridge Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV U2Member) Source # literal :: U2Member -> SBV U2Member Source # fromCV :: CV -> U2Member Source # isConcretely :: SBV U2Member -> (U2Member -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV U2Member) Source # free_ :: MonadSymbolic m => m (SBV U2Member) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV U2Member] Source # symbolic :: MonadSymbolic m => String -> m (SBV U2Member) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV U2Member] Source # unliteral :: SBV U2Member -> Maybe U2Member Source # | |
| SymVal Day Source # | |
Defined in Documentation.SBV.Examples.Queries.Enums Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Day) Source # literal :: Day -> SBV Day Source # isConcretely :: SBV Day -> (Day -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Day) Source # free_ :: MonadSymbolic m => m (SBV Day) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Day] Source # symbolic :: MonadSymbolic m => String -> m (SBV Day) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Day] Source # unliteral :: SBV Day -> Maybe Day Source # | |
| SymVal BinOp Source # | |
Defined in Documentation.SBV.Examples.Queries.FourFours Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV BinOp) Source # literal :: BinOp -> SBV BinOp Source # fromCV :: CV -> BinOp Source # isConcretely :: SBV BinOp -> (BinOp -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV BinOp) Source # free_ :: MonadSymbolic m => m (SBV BinOp) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV BinOp] Source # symbolic :: MonadSymbolic m => String -> m (SBV BinOp) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV BinOp] Source # unliteral :: SBV BinOp -> Maybe BinOp Source # | |
| SymVal UnOp Source # | |
Defined in Documentation.SBV.Examples.Queries.FourFours Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV UnOp) Source # literal :: UnOp -> SBV UnOp Source # isConcretely :: SBV UnOp -> (UnOp -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV UnOp) Source # free_ :: MonadSymbolic m => m (SBV UnOp) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV UnOp] Source # symbolic :: MonadSymbolic m => String -> m (SBV UnOp) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV UnOp] Source # unliteral :: SBV UnOp -> Maybe UnOp Source # | |
| SymVal B Source # | |
Defined in Documentation.SBV.Examples.Uninterpreted.Deduce Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV B) Source # literal :: B -> SBV B Source # isConcretely :: SBV B -> (B -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV B) Source # free_ :: MonadSymbolic m => m (SBV B) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV B] Source # symbolic :: MonadSymbolic m => String -> m (SBV B) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV B] Source # unliteral :: SBV B -> Maybe B Source # | |
| SymVal Q Source # | |
Defined in Documentation.SBV.Examples.Uninterpreted.Sort Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Q) Source # literal :: Q -> SBV Q Source # isConcretely :: SBV Q -> (Q -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Q) Source # free_ :: MonadSymbolic m => m (SBV Q) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Q] Source # symbolic :: MonadSymbolic m => String -> m (SBV Q) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Q] Source # unliteral :: SBV Q -> Maybe Q Source # | |
| SymVal L Source # | |
Defined in Documentation.SBV.Examples.Uninterpreted.UISortAllSat Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV L) Source # literal :: L -> SBV L Source # isConcretely :: SBV L -> (L -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV L) Source # free_ :: MonadSymbolic m => m (SBV L) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV L] Source # symbolic :: MonadSymbolic m => String -> m (SBV L) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV L] Source # unliteral :: SBV L -> Maybe L Source # | |
| SymVal Integer Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Integer) Source # literal :: Integer -> SBV Integer Source # fromCV :: CV -> Integer Source # isConcretely :: SBV Integer -> (Integer -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Integer) Source # free_ :: MonadSymbolic m => m (SBV Integer) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Integer] Source # symbolic :: MonadSymbolic m => String -> m (SBV Integer) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Integer] Source # unliteral :: SBV Integer -> Maybe Integer Source # | |
| SymVal () Source # | SymVal for 0-tuple (i.e., unit) |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV ()) Source # literal :: () -> SBV () Source # isConcretely :: SBV () -> (() -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV ()) Source # free_ :: MonadSymbolic m => m (SBV ()) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV ()] Source # symbolic :: MonadSymbolic m => String -> m (SBV ()) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV ()] Source # unliteral :: SBV () -> Maybe () Source # isConcrete :: SBV () -> Bool Source # isSymbolic :: SBV () -> Bool Source # | |
| SymVal Bool Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Bool) Source # literal :: Bool -> SBV Bool Source # isConcretely :: SBV Bool -> (Bool -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Bool) Source # free_ :: MonadSymbolic m => m (SBV Bool) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Bool] Source # symbolic :: MonadSymbolic m => String -> m (SBV Bool) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Bool] Source # unliteral :: SBV Bool -> Maybe Bool Source # | |
| SymVal Char Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Char) Source # literal :: Char -> SBV Char Source # isConcretely :: SBV Char -> (Char -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Char) Source # free_ :: MonadSymbolic m => m (SBV Char) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Char] Source # symbolic :: MonadSymbolic m => String -> m (SBV Char) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Char] Source # unliteral :: SBV Char -> Maybe Char Source # | |
| SymVal Double Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Double) Source # literal :: Double -> SBV Double Source # fromCV :: CV -> Double Source # isConcretely :: SBV Double -> (Double -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Double) Source # free_ :: MonadSymbolic m => m (SBV Double) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Double] Source # symbolic :: MonadSymbolic m => String -> m (SBV Double) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Double] Source # unliteral :: SBV Double -> Maybe Double Source # | |
| SymVal Float Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV Float) Source # literal :: Float -> SBV Float Source # fromCV :: CV -> Float Source # isConcretely :: SBV Float -> (Float -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV Float) Source # free_ :: MonadSymbolic m => m (SBV Float) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV Float] Source # symbolic :: MonadSymbolic m => String -> m (SBV Float) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV Float] Source # unliteral :: SBV Float -> Maybe Float Source # | |
| (Ord a, SymVal a) => SymVal (RCSet a) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (RCSet a)) Source # literal :: RCSet a -> SBV (RCSet a) Source # fromCV :: CV -> RCSet a Source # isConcretely :: SBV (RCSet a) -> (RCSet a -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (RCSet a)) Source # free_ :: MonadSymbolic m => m (SBV (RCSet a)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (RCSet a)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (RCSet a)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (RCSet a)] Source # unliteral :: SBV (RCSet a) -> Maybe (RCSet a) Source # | |
| (KnownNat n, BVIsNonZero n) => SymVal (IntN n) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (IntN n)) Source # literal :: IntN n -> SBV (IntN n) Source # fromCV :: CV -> IntN n Source # isConcretely :: SBV (IntN n) -> (IntN n -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (IntN n)) Source # free_ :: MonadSymbolic m => m (SBV (IntN n)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (IntN n)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (IntN n)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (IntN n)] Source # unliteral :: SBV (IntN n) -> Maybe (IntN n) Source # | |
| (KnownNat n, BVIsNonZero n) => SymVal (WordN n) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (WordN n)) Source # literal :: WordN n -> SBV (WordN n) Source # fromCV :: CV -> WordN n Source # isConcretely :: SBV (WordN n) -> (WordN n -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (WordN n)) Source # free_ :: MonadSymbolic m => m (SBV (WordN n)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (WordN n)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (WordN n)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (WordN n)] Source # unliteral :: SBV (WordN n) -> Maybe (WordN n) Source # | |
| SymVal a => SymVal (Maybe a) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (Maybe a)) Source # literal :: Maybe a -> SBV (Maybe a) Source # fromCV :: CV -> Maybe a Source # isConcretely :: SBV (Maybe a) -> (Maybe a -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (Maybe a)) Source # free_ :: MonadSymbolic m => m (SBV (Maybe a)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (Maybe a)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (Maybe a)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (Maybe a)] Source # unliteral :: SBV (Maybe a) -> Maybe (Maybe a) Source # | |
| SymVal a => SymVal [a] Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV [a]) Source # literal :: [a] -> SBV [a] Source # isConcretely :: SBV [a] -> ([a] -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV [a]) Source # free_ :: MonadSymbolic m => m (SBV [a]) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV [a]] Source # symbolic :: MonadSymbolic m => String -> m (SBV [a]) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV [a]] Source # unliteral :: SBV [a] -> Maybe [a] Source # isConcrete :: SBV [a] -> Bool Source # isSymbolic :: SBV [a] -> Bool Source # | |
| (SymVal a, SymVal b) => SymVal (Either a b) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (Either a b)) Source # literal :: Either a b -> SBV (Either a b) Source # fromCV :: CV -> Either a b Source # isConcretely :: SBV (Either a b) -> (Either a b -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (Either a b)) Source # free_ :: MonadSymbolic m => m (SBV (Either a b)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (Either a b)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (Either a b)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (Either a b)] Source # unliteral :: SBV (Either a b) -> Maybe (Either a b) Source # | |
| (HasKind a, HasKind b, SymVal a, SymVal b) => SymVal (ArrayModel a b) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (ArrayModel a b)) Source # literal :: ArrayModel a b -> SBV (ArrayModel a b) Source # fromCV :: CV -> ArrayModel a b Source # isConcretely :: SBV (ArrayModel a b) -> (ArrayModel a b -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (ArrayModel a b)) Source # free_ :: MonadSymbolic m => m (SBV (ArrayModel a b)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (ArrayModel a b)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (ArrayModel a b)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (ArrayModel a b)] Source # unliteral :: SBV (ArrayModel a b) -> Maybe (ArrayModel a b) Source # isConcrete :: SBV (ArrayModel a b) -> Bool Source # isSymbolic :: SBV (ArrayModel a b) -> Bool Source # | |
| ValidFloat eb sb => SymVal (FloatingPoint eb sb) Source # | |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (FloatingPoint eb sb)) Source # literal :: FloatingPoint eb sb -> SBV (FloatingPoint eb sb) Source # fromCV :: CV -> FloatingPoint eb sb Source # isConcretely :: SBV (FloatingPoint eb sb) -> (FloatingPoint eb sb -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (FloatingPoint eb sb)) Source # free_ :: MonadSymbolic m => m (SBV (FloatingPoint eb sb)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (FloatingPoint eb sb)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (FloatingPoint eb sb)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (FloatingPoint eb sb)] Source # unliteral :: SBV (FloatingPoint eb sb) -> Maybe (FloatingPoint eb sb) Source # isConcrete :: SBV (FloatingPoint eb sb) -> Bool Source # isSymbolic :: SBV (FloatingPoint eb sb) -> Bool Source # | |
| (SymVal a, SymVal b) => SymVal (a, b) Source # | SymVal for 2-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b)) Source # literal :: (a, b) -> SBV (a, b) Source # fromCV :: CV -> (a, b) Source # isConcretely :: SBV (a, b) -> ((a, b) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b)) Source # free_ :: MonadSymbolic m => m (SBV (a, b)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b)] Source # unliteral :: SBV (a, b) -> Maybe (a, b) Source # isConcrete :: SBV (a, b) -> Bool Source # isSymbolic :: SBV (a, b) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c) => SymVal (a, b, c) Source # | SymVal for 3-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c)) Source # literal :: (a, b, c) -> SBV (a, b, c) Source # fromCV :: CV -> (a, b, c) Source # isConcretely :: SBV (a, b, c) -> ((a, b, c) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c)] Source # unliteral :: SBV (a, b, c) -> Maybe (a, b, c) Source # isConcrete :: SBV (a, b, c) -> Bool Source # isSymbolic :: SBV (a, b, c) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d) => SymVal (a, b, c, d) Source # | SymVal for 4-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c, d)) Source # literal :: (a, b, c, d) -> SBV (a, b, c, d) Source # fromCV :: CV -> (a, b, c, d) Source # isConcretely :: SBV (a, b, c, d) -> ((a, b, c, d) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c, d)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c, d)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c, d)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c, d)] Source # unliteral :: SBV (a, b, c, d) -> Maybe (a, b, c, d) Source # isConcrete :: SBV (a, b, c, d) -> Bool Source # isSymbolic :: SBV (a, b, c, d) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e) => SymVal (a, b, c, d, e) Source # | SymVal for 5-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c, d, e)) Source # literal :: (a, b, c, d, e) -> SBV (a, b, c, d, e) Source # fromCV :: CV -> (a, b, c, d, e) Source # isConcretely :: SBV (a, b, c, d, e) -> ((a, b, c, d, e) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c, d, e)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c, d, e)] Source # unliteral :: SBV (a, b, c, d, e) -> Maybe (a, b, c, d, e) Source # isConcrete :: SBV (a, b, c, d, e) -> Bool Source # isSymbolic :: SBV (a, b, c, d, e) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f) => SymVal (a, b, c, d, e, f) Source # | SymVal for 6-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c, d, e, f)) Source # literal :: (a, b, c, d, e, f) -> SBV (a, b, c, d, e, f) Source # fromCV :: CV -> (a, b, c, d, e, f) Source # isConcretely :: SBV (a, b, c, d, e, f) -> ((a, b, c, d, e, f) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c, d, e, f)] Source # unliteral :: SBV (a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f) Source # isConcrete :: SBV (a, b, c, d, e, f) -> Bool Source # isSymbolic :: SBV (a, b, c, d, e, f) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g) => SymVal (a, b, c, d, e, f, g) Source # | SymVal for 7-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c, d, e, f, g)) Source # literal :: (a, b, c, d, e, f, g) -> SBV (a, b, c, d, e, f, g) Source # fromCV :: CV -> (a, b, c, d, e, f, g) Source # isConcretely :: SBV (a, b, c, d, e, f, g) -> ((a, b, c, d, e, f, g) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c, d, e, f, g)] Source # unliteral :: SBV (a, b, c, d, e, f, g) -> Maybe (a, b, c, d, e, f, g) Source # isConcrete :: SBV (a, b, c, d, e, f, g) -> Bool Source # isSymbolic :: SBV (a, b, c, d, e, f, g) -> Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h) => SymVal (a, b, c, d, e, f, g, h) Source # | SymVal for 8-tuples |
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (a, b, c, d, e, f, g, h)) Source # literal :: (a, b, c, d, e, f, g, h) -> SBV (a, b, c, d, e, f, g, h) Source # fromCV :: CV -> (a, b, c, d, e, f, g, h) Source # isConcretely :: SBV (a, b, c, d, e, f, g, h) -> ((a, b, c, d, e, f, g, h) -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g, h)) Source # free_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g, h)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g, h)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g, h)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (a, b, c, d, e, f, g, h)] Source # unliteral :: SBV (a, b, c, d, e, f, g, h) -> Maybe (a, b, c, d, e, f, g, h) Source # isConcrete :: SBV (a, b, c, d, e, f, g, h) -> Bool Source # isSymbolic :: SBV (a, b, c, d, e, f, g, h) -> Bool Source # | |
class HasKind a where Source #
A class for capturing values that have a sign and a size (finite or infinite)
minimal complete definition: kindOf, unless you can take advantage of the default
signature: This class can be automatically derived for data-types that have
a Data instance; this is useful for creating uninterpreted sorts. So, in
reality, end users should almost never need to define any methods.
Minimal complete definition
Nothing
Methods
intSizeOf :: a -> Int Source #
isBoolean :: a -> Bool Source #
isBounded :: a -> Bool Source #
isDouble :: a -> Bool Source #
isRational :: a -> Bool Source #
isUnbounded :: a -> Bool Source #
isUserSort :: a -> Bool Source #
isString :: a -> Bool Source #
Instances
| HasKind Int16 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Int16 -> Kind Source # hasSign :: Int16 -> Bool Source # intSizeOf :: Int16 -> Int Source # isBoolean :: Int16 -> Bool Source # isBounded :: Int16 -> Bool Source # isReal :: Int16 -> Bool Source # isFloat :: Int16 -> Bool Source # isDouble :: Int16 -> Bool Source # isRational :: Int16 -> Bool Source # isFP :: Int16 -> Bool Source # isUnbounded :: Int16 -> Bool Source # isUserSort :: Int16 -> Bool Source # isChar :: Int16 -> Bool Source # isString :: Int16 -> Bool Source # isList :: Int16 -> Bool Source # isSet :: Int16 -> Bool Source # isTuple :: Int16 -> Bool Source # isMaybe :: Int16 -> Bool Source # isEither :: Int16 -> Bool Source # | |
| HasKind Int32 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Int32 -> Kind Source # hasSign :: Int32 -> Bool Source # intSizeOf :: Int32 -> Int Source # isBoolean :: Int32 -> Bool Source # isBounded :: Int32 -> Bool Source # isReal :: Int32 -> Bool Source # isFloat :: Int32 -> Bool Source # isDouble :: Int32 -> Bool Source # isRational :: Int32 -> Bool Source # isFP :: Int32 -> Bool Source # isUnbounded :: Int32 -> Bool Source # isUserSort :: Int32 -> Bool Source # isChar :: Int32 -> Bool Source # isString :: Int32 -> Bool Source # isList :: Int32 -> Bool Source # isSet :: Int32 -> Bool Source # isTuple :: Int32 -> Bool Source # isMaybe :: Int32 -> Bool Source # isEither :: Int32 -> Bool Source # | |
| HasKind Int64 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Int64 -> Kind Source # hasSign :: Int64 -> Bool Source # intSizeOf :: Int64 -> Int Source # isBoolean :: Int64 -> Bool Source # isBounded :: Int64 -> Bool Source # isReal :: Int64 -> Bool Source # isFloat :: Int64 -> Bool Source # isDouble :: Int64 -> Bool Source # isRational :: Int64 -> Bool Source # isFP :: Int64 -> Bool Source # isUnbounded :: Int64 -> Bool Source # isUserSort :: Int64 -> Bool Source # isChar :: Int64 -> Bool Source # isString :: Int64 -> Bool Source # isList :: Int64 -> Bool Source # isSet :: Int64 -> Bool Source # isTuple :: Int64 -> Bool Source # isMaybe :: Int64 -> Bool Source # isEither :: Int64 -> Bool Source # | |
| HasKind Int8 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Int8 -> Kind Source # hasSign :: Int8 -> Bool Source # intSizeOf :: Int8 -> Int Source # isBoolean :: Int8 -> Bool Source # isBounded :: Int8 -> Bool Source # isReal :: Int8 -> Bool Source # isFloat :: Int8 -> Bool Source # isDouble :: Int8 -> Bool Source # isRational :: Int8 -> Bool Source # isUnbounded :: Int8 -> Bool Source # isUserSort :: Int8 -> Bool Source # isChar :: Int8 -> Bool Source # isString :: Int8 -> Bool Source # isList :: Int8 -> Bool Source # isSet :: Int8 -> Bool Source # isTuple :: Int8 -> Bool Source # isMaybe :: Int8 -> Bool Source # isEither :: Int8 -> Bool Source # | |
| HasKind Rational Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Rational -> Kind Source # hasSign :: Rational -> Bool Source # intSizeOf :: Rational -> Int Source # isBoolean :: Rational -> Bool Source # isBounded :: Rational -> Bool Source # isReal :: Rational -> Bool Source # isFloat :: Rational -> Bool Source # isDouble :: Rational -> Bool Source # isRational :: Rational -> Bool Source # isFP :: Rational -> Bool Source # isUnbounded :: Rational -> Bool Source # isUserSort :: Rational -> Bool Source # isChar :: Rational -> Bool Source # isString :: Rational -> Bool Source # isList :: Rational -> Bool Source # isSet :: Rational -> Bool Source # isTuple :: Rational -> Bool Source # isMaybe :: Rational -> Bool Source # isEither :: Rational -> Bool Source # | |
| HasKind Word16 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Word16 -> Kind Source # hasSign :: Word16 -> Bool Source # intSizeOf :: Word16 -> Int Source # isBoolean :: Word16 -> Bool Source # isBounded :: Word16 -> Bool Source # isReal :: Word16 -> Bool Source # isFloat :: Word16 -> Bool Source # isDouble :: Word16 -> Bool Source # isRational :: Word16 -> Bool Source # isFP :: Word16 -> Bool Source # isUnbounded :: Word16 -> Bool Source # isUserSort :: Word16 -> Bool Source # isChar :: Word16 -> Bool Source # isString :: Word16 -> Bool Source # isList :: Word16 -> Bool Source # isSet :: Word16 -> Bool Source # isTuple :: Word16 -> Bool Source # isMaybe :: Word16 -> Bool Source # isEither :: Word16 -> Bool Source # | |
| HasKind Word32 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Word32 -> Kind Source # hasSign :: Word32 -> Bool Source # intSizeOf :: Word32 -> Int Source # isBoolean :: Word32 -> Bool Source # isBounded :: Word32 -> Bool Source # isReal :: Word32 -> Bool Source # isFloat :: Word32 -> Bool Source # isDouble :: Word32 -> Bool Source # isRational :: Word32 -> Bool Source # isFP :: Word32 -> Bool Source # isUnbounded :: Word32 -> Bool Source # isUserSort :: Word32 -> Bool Source # isChar :: Word32 -> Bool Source # isString :: Word32 -> Bool Source # isList :: Word32 -> Bool Source # isSet :: Word32 -> Bool Source # isTuple :: Word32 -> Bool Source # isMaybe :: Word32 -> Bool Source # isEither :: Word32 -> Bool Source # | |
| HasKind Word64 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Word64 -> Kind Source # hasSign :: Word64 -> Bool Source # intSizeOf :: Word64 -> Int Source # isBoolean :: Word64 -> Bool Source # isBounded :: Word64 -> Bool Source # isReal :: Word64 -> Bool Source # isFloat :: Word64 -> Bool Source # isDouble :: Word64 -> Bool Source # isRational :: Word64 -> Bool Source # isFP :: Word64 -> Bool Source # isUnbounded :: Word64 -> Bool Source # isUserSort :: Word64 -> Bool Source # isChar :: Word64 -> Bool Source # isString :: Word64 -> Bool Source # isList :: Word64 -> Bool Source # isSet :: Word64 -> Bool Source # isTuple :: Word64 -> Bool Source # isMaybe :: Word64 -> Bool Source # isEither :: Word64 -> Bool Source # | |
| HasKind Word8 Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Word8 -> Kind Source # hasSign :: Word8 -> Bool Source # intSizeOf :: Word8 -> Int Source # isBoolean :: Word8 -> Bool Source # isBounded :: Word8 -> Bool Source # isReal :: Word8 -> Bool Source # isFloat :: Word8 -> Bool Source # isDouble :: Word8 -> Bool Source # isRational :: Word8 -> Bool Source # isFP :: Word8 -> Bool Source # isUnbounded :: Word8 -> Bool Source # isUserSort :: Word8 -> Bool Source # isChar :: Word8 -> Bool Source # isString :: Word8 -> Bool Source # isList :: Word8 -> Bool Source # isSet :: Word8 -> Bool Source # isTuple :: Word8 -> Bool Source # isMaybe :: Word8 -> Bool Source # isEither :: Word8 -> Bool Source # | |
| HasKind AlgReal Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: AlgReal -> Kind Source # hasSign :: AlgReal -> Bool Source # intSizeOf :: AlgReal -> Int Source # isBoolean :: AlgReal -> Bool Source # isBounded :: AlgReal -> Bool Source # isReal :: AlgReal -> Bool Source # isFloat :: AlgReal -> Bool Source # isDouble :: AlgReal -> Bool Source # isRational :: AlgReal -> Bool Source # isFP :: AlgReal -> Bool Source # isUnbounded :: AlgReal -> Bool Source # isUserSort :: AlgReal -> Bool Source # isChar :: AlgReal -> Bool Source # isString :: AlgReal -> Bool Source # isList :: AlgReal -> Bool Source # isSet :: AlgReal -> Bool Source # isTuple :: AlgReal -> Bool Source # isMaybe :: AlgReal -> Bool Source # isEither :: AlgReal -> Bool Source # | |
| HasKind CV Source # |
|
Defined in Data.SBV.Core.Concrete Methods hasSign :: CV -> Bool Source # intSizeOf :: CV -> Int Source # isBoolean :: CV -> Bool Source # isBounded :: CV -> Bool Source # isFloat :: CV -> Bool Source # isDouble :: CV -> Bool Source # isRational :: CV -> Bool Source # isUnbounded :: CV -> Bool Source # isUserSort :: CV -> Bool Source # isString :: CV -> Bool Source # isTuple :: CV -> Bool Source # isMaybe :: CV -> Bool Source # isEither :: CV -> Bool Source # | |
| HasKind ExtCV Source # | Kind instance for Extended CV |
Defined in Data.SBV.Core.Concrete Methods kindOf :: ExtCV -> Kind Source # hasSign :: ExtCV -> Bool Source # intSizeOf :: ExtCV -> Int Source # isBoolean :: ExtCV -> Bool Source # isBounded :: ExtCV -> Bool Source # isReal :: ExtCV -> Bool Source # isFloat :: ExtCV -> Bool Source # isDouble :: ExtCV -> Bool Source # isRational :: ExtCV -> Bool Source # isFP :: ExtCV -> Bool Source # isUnbounded :: ExtCV -> Bool Source # isUserSort :: ExtCV -> Bool Source # isChar :: ExtCV -> Bool Source # isString :: ExtCV -> Bool Source # isList :: ExtCV -> Bool Source # isSet :: ExtCV -> Bool Source # isTuple :: ExtCV -> Bool Source # isMaybe :: ExtCV -> Bool Source # isEither :: ExtCV -> Bool Source # | |
| HasKind GeneralizedCV Source # |
|
Defined in Data.SBV.Core.Concrete Methods kindOf :: GeneralizedCV -> Kind Source # hasSign :: GeneralizedCV -> Bool Source # intSizeOf :: GeneralizedCV -> Int Source # isBoolean :: GeneralizedCV -> Bool Source # isBounded :: GeneralizedCV -> Bool Source # isReal :: GeneralizedCV -> Bool Source # isFloat :: GeneralizedCV -> Bool Source # isDouble :: GeneralizedCV -> Bool Source # isRational :: GeneralizedCV -> Bool Source # isFP :: GeneralizedCV -> Bool Source # isUnbounded :: GeneralizedCV -> Bool Source # isUserSort :: GeneralizedCV -> Bool Source # isChar :: GeneralizedCV -> Bool Source # isString :: GeneralizedCV -> Bool Source # isList :: GeneralizedCV -> Bool Source # isSet :: GeneralizedCV -> Bool Source # isTuple :: GeneralizedCV -> Bool Source # isMaybe :: GeneralizedCV -> Bool Source # isEither :: GeneralizedCV -> Bool Source # isArray :: GeneralizedCV -> Bool Source # showType :: GeneralizedCV -> String Source # | |
| HasKind Kind Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Kind -> Kind Source # hasSign :: Kind -> Bool Source # intSizeOf :: Kind -> Int Source # isBoolean :: Kind -> Bool Source # isBounded :: Kind -> Bool Source # isReal :: Kind -> Bool Source # isFloat :: Kind -> Bool Source # isDouble :: Kind -> Bool Source # isRational :: Kind -> Bool Source # isUnbounded :: Kind -> Bool Source # isUserSort :: Kind -> Bool Source # isChar :: Kind -> Bool Source # isString :: Kind -> Bool Source # isList :: Kind -> Bool Source # isSet :: Kind -> Bool Source # isTuple :: Kind -> Bool Source # isMaybe :: Kind -> Bool Source # isEither :: Kind -> Bool Source # | |
| HasKind RoundingMode Source # |
|
Defined in Data.SBV.Core.Kind Methods kindOf :: RoundingMode -> Kind Source # hasSign :: RoundingMode -> Bool Source # intSizeOf :: RoundingMode -> Int Source # isBoolean :: RoundingMode -> Bool Source # isBounded :: RoundingMode -> Bool Source # isReal :: RoundingMode -> Bool Source # isFloat :: RoundingMode -> Bool Source # isDouble :: RoundingMode -> Bool Source # isRational :: RoundingMode -> Bool Source # isFP :: RoundingMode -> Bool Source # isUnbounded :: RoundingMode -> Bool Source # isUserSort :: RoundingMode -> Bool Source # isChar :: RoundingMode -> Bool Source # isString :: RoundingMode -> Bool Source # isList :: RoundingMode -> Bool Source # isSet :: RoundingMode -> Bool Source # isTuple :: RoundingMode -> Bool Source # isMaybe :: RoundingMode -> Bool Source # isEither :: RoundingMode -> Bool Source # isArray :: RoundingMode -> Bool Source # showType :: RoundingMode -> String Source # | |
| HasKind SV Source # | |
Defined in Data.SBV.Core.Symbolic Methods hasSign :: SV -> Bool Source # intSizeOf :: SV -> Int Source # isBoolean :: SV -> Bool Source # isBounded :: SV -> Bool Source # isFloat :: SV -> Bool Source # isDouble :: SV -> Bool Source # isRational :: SV -> Bool Source # isUnbounded :: SV -> Bool Source # isUserSort :: SV -> Bool Source # isString :: SV -> Bool Source # isTuple :: SV -> Bool Source # isMaybe :: SV -> Bool Source # isEither :: SV -> Bool Source # | |
| HasKind SVal Source # | |
Defined in Data.SBV.Core.Symbolic Methods kindOf :: SVal -> Kind Source # hasSign :: SVal -> Bool Source # intSizeOf :: SVal -> Int Source # isBoolean :: SVal -> Bool Source # isBounded :: SVal -> Bool Source # isReal :: SVal -> Bool Source # isFloat :: SVal -> Bool Source # isDouble :: SVal -> Bool Source # isRational :: SVal -> Bool Source # isUnbounded :: SVal -> Bool Source # isUserSort :: SVal -> Bool Source # isChar :: SVal -> Bool Source # isString :: SVal -> Bool Source # isList :: SVal -> Bool Source # isSet :: SVal -> Bool Source # isTuple :: SVal -> Bool Source # isMaybe :: SVal -> Bool Source # isEither :: SVal -> Bool Source # | |
| HasKind T Source # | |
| HasKind Kleene Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.Kleene Methods kindOf :: Kleene -> Kind Source # hasSign :: Kleene -> Bool Source # intSizeOf :: Kleene -> Int Source # isBoolean :: Kleene -> Bool Source # isBounded :: Kleene -> Bool Source # isReal :: Kleene -> Bool Source # isFloat :: Kleene -> Bool Source # isDouble :: Kleene -> Bool Source # isRational :: Kleene -> Bool Source # isFP :: Kleene -> Bool Source # isUnbounded :: Kleene -> Bool Source # isUserSort :: Kleene -> Bool Source # isChar :: Kleene -> Bool Source # isString :: Kleene -> Bool Source # isList :: Kleene -> Bool Source # isSet :: Kleene -> Bool Source # isTuple :: Kleene -> Bool Source # isMaybe :: Kleene -> Bool Source # isEither :: Kleene -> Bool Source # | |
| HasKind A Source # | |
| HasKind B Source # | |
| HasKind C Source # | |
| HasKind Stroke Source # | |
Defined in Documentation.SBV.Examples.KnuckleDragger.ShefferStroke Methods kindOf :: Stroke -> Kind Source # hasSign :: Stroke -> Bool Source # intSizeOf :: Stroke -> Int Source # isBoolean :: Stroke -> Bool Source # isBounded :: Stroke -> Bool Source # isReal :: Stroke -> Bool Source # isFloat :: Stroke -> Bool Source # isDouble :: Stroke -> Bool Source # isRational :: Stroke -> Bool Source # isFP :: Stroke -> Bool Source # isUnbounded :: Stroke -> Bool Source # isUserSort :: Stroke -> Bool Source # isChar :: Stroke -> Bool Source # isString :: Stroke -> Bool Source # isList :: Stroke -> Bool Source # isSet :: Stroke -> Bool Source # isTuple :: Stroke -> Bool Source # isMaybe :: Stroke -> Bool Source # isEither :: Stroke -> Bool Source # | |
| HasKind T Source # | |
| HasKind State Source # | |
Defined in Documentation.SBV.Examples.Lists.BoundedMutex Methods kindOf :: State -> Kind Source # hasSign :: State -> Bool Source # intSizeOf :: State -> Int Source # isBoolean :: State -> Bool Source # isBounded :: State -> Bool Source # isReal :: State -> Bool Source # isFloat :: State -> Bool Source # isDouble :: State -> Bool Source # isRational :: State -> Bool Source # isFP :: State -> Bool Source # isUnbounded :: State -> Bool Source # isUserSort :: State -> Bool Source # isChar :: State -> Bool Source # isString :: State -> Bool Source # isList :: State -> Bool Source # isSet :: State -> Bool Source # isTuple :: State -> Bool Source # isMaybe :: State -> Bool Source # isEither :: State -> Bool Source # | |
| HasKind E Source # | |
Defined in Documentation.SBV.Examples.Misc.Enumerate | |
| HasKind E Source # | |
| HasKind U Source # | |
| HasKind V Source # | |
| HasKind HumanHeightInCm Source # | Symbolic instance simply follows the underlying type, just like |
Defined in Documentation.SBV.Examples.Misc.Newtypes Methods kindOf :: HumanHeightInCm -> Kind Source # hasSign :: HumanHeightInCm -> Bool Source # intSizeOf :: HumanHeightInCm -> Int Source # isBoolean :: HumanHeightInCm -> Bool Source # isBounded :: HumanHeightInCm -> Bool Source # isReal :: HumanHeightInCm -> Bool Source # isFloat :: HumanHeightInCm -> Bool Source # isDouble :: HumanHeightInCm -> Bool Source # isRational :: HumanHeightInCm -> Bool Source # isFP :: HumanHeightInCm -> Bool Source # isUnbounded :: HumanHeightInCm -> Bool Source # isUserSort :: HumanHeightInCm -> Bool Source # isChar :: HumanHeightInCm -> Bool Source # isString :: HumanHeightInCm -> Bool Source # isList :: HumanHeightInCm -> Bool Source # isSet :: HumanHeightInCm -> Bool Source # isTuple :: HumanHeightInCm -> Bool Source # isMaybe :: HumanHeightInCm -> Bool Source # isEither :: HumanHeightInCm -> Bool Source # isArray :: HumanHeightInCm -> Bool Source # showType :: HumanHeightInCm -> String Source # | |
| HasKind Metres Source # | To use |
Defined in Documentation.SBV.Examples.Misc.Newtypes Methods kindOf :: Metres -> Kind Source # hasSign :: Metres -> Bool Source # intSizeOf :: Metres -> Int Source # isBoolean :: Metres -> Bool Source # isBounded :: Metres -> Bool Source # isReal :: Metres -> Bool Source # isFloat :: Metres -> Bool Source # isDouble :: Metres -> Bool Source # isRational :: Metres -> Bool Source # isFP :: Metres -> Bool Source # isUnbounded :: Metres -> Bool Source # isUserSort :: Metres -> Bool Source # isChar :: Metres -> Bool Source # isString :: Metres -> Bool Source # isList :: Metres -> Bool Source # isSet :: Metres -> Bool Source # isTuple :: Metres -> Bool Source # isMaybe :: Metres -> Bool Source # isEither :: Metres -> Bool Source # | |
| HasKind Day Source # | |
Defined in Documentation.SBV.Examples.Optimization.Enumerate Methods kindOf :: Day -> Kind Source # hasSign :: Day -> Bool Source # intSizeOf :: Day -> Int Source # isBoolean :: Day -> Bool Source # isBounded :: Day -> Bool Source # isReal :: Day -> Bool Source # isFloat :: Day -> Bool Source # isDouble :: Day -> Bool Source # isRational :: Day -> Bool Source # isUnbounded :: Day -> Bool Source # isUserSort :: Day -> Bool Source # isChar :: Day -> Bool Source # isString :: Day -> Bool Source # isList :: Day -> Bool Source # isTuple :: Day -> Bool Source # isMaybe :: Day -> Bool Source # isEither :: Day -> Bool Source # | |
| HasKind Day Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Birthday Methods kindOf :: Day -> Kind Source # hasSign :: Day -> Bool Source # intSizeOf :: Day -> Int Source # isBoolean :: Day -> Bool Source # isBounded :: Day -> Bool Source # isReal :: Day -> Bool Source # isFloat :: Day -> Bool Source # isDouble :: Day -> Bool Source # isRational :: Day -> Bool Source # isUnbounded :: Day -> Bool Source # isUserSort :: Day -> Bool Source # isChar :: Day -> Bool Source # isString :: Day -> Bool Source # isList :: Day -> Bool Source # isTuple :: Day -> Bool Source # isMaybe :: Day -> Bool Source # isEither :: Day -> Bool Source # | |
| HasKind Month Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Birthday Methods kindOf :: Month -> Kind Source # hasSign :: Month -> Bool Source # intSizeOf :: Month -> Int Source # isBoolean :: Month -> Bool Source # isBounded :: Month -> Bool Source # isReal :: Month -> Bool Source # isFloat :: Month -> Bool Source # isDouble :: Month -> Bool Source # isRational :: Month -> Bool Source # isFP :: Month -> Bool Source # isUnbounded :: Month -> Bool Source # isUserSort :: Month -> Bool Source # isChar :: Month -> Bool Source # isString :: Month -> Bool Source # isList :: Month -> Bool Source # isSet :: Month -> Bool Source # isTuple :: Month -> Bool Source # isMaybe :: Month -> Bool Source # isEither :: Month -> Bool Source # | |
| HasKind Action Source # | |
Defined in Documentation.SBV.Examples.Puzzles.DieHard Methods kindOf :: Action -> Kind Source # hasSign :: Action -> Bool Source # intSizeOf :: Action -> Int Source # isBoolean :: Action -> Bool Source # isBounded :: Action -> Bool Source # isReal :: Action -> Bool Source # isFloat :: Action -> Bool Source # isDouble :: Action -> Bool Source # isRational :: Action -> Bool Source # isFP :: Action -> Bool Source # isUnbounded :: Action -> Bool Source # isUserSort :: Action -> Bool Source # isChar :: Action -> Bool Source # isString :: Action -> Bool Source # isList :: Action -> Bool Source # isSet :: Action -> Bool Source # isTuple :: Action -> Bool Source # isMaybe :: Action -> Bool Source # isEither :: Action -> Bool Source # | |
| HasKind P Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Drinker | |
| HasKind Beverage Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods kindOf :: Beverage -> Kind Source # hasSign :: Beverage -> Bool Source # intSizeOf :: Beverage -> Int Source # isBoolean :: Beverage -> Bool Source # isBounded :: Beverage -> Bool Source # isReal :: Beverage -> Bool Source # isFloat :: Beverage -> Bool Source # isDouble :: Beverage -> Bool Source # isRational :: Beverage -> Bool Source # isFP :: Beverage -> Bool Source # isUnbounded :: Beverage -> Bool Source # isUserSort :: Beverage -> Bool Source # isChar :: Beverage -> Bool Source # isString :: Beverage -> Bool Source # isList :: Beverage -> Bool Source # isSet :: Beverage -> Bool Source # isTuple :: Beverage -> Bool Source # isMaybe :: Beverage -> Bool Source # isEither :: Beverage -> Bool Source # | |
| HasKind Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods kindOf :: Color -> Kind Source # hasSign :: Color -> Bool Source # intSizeOf :: Color -> Int Source # isBoolean :: Color -> Bool Source # isBounded :: Color -> Bool Source # isReal :: Color -> Bool Source # isFloat :: Color -> Bool Source # isDouble :: Color -> Bool Source # isRational :: Color -> Bool Source # isFP :: Color -> Bool Source # isUnbounded :: Color -> Bool Source # isUserSort :: Color -> Bool Source # isChar :: Color -> Bool Source # isString :: Color -> Bool Source # isList :: Color -> Bool Source # isSet :: Color -> Bool Source # isTuple :: Color -> Bool Source # isMaybe :: Color -> Bool Source # isEither :: Color -> Bool Source # | |
| HasKind Nationality Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods kindOf :: Nationality -> Kind Source # hasSign :: Nationality -> Bool Source # intSizeOf :: Nationality -> Int Source # isBoolean :: Nationality -> Bool Source # isBounded :: Nationality -> Bool Source # isReal :: Nationality -> Bool Source # isFloat :: Nationality -> Bool Source # isDouble :: Nationality -> Bool Source # isRational :: Nationality -> Bool Source # isFP :: Nationality -> Bool Source # isUnbounded :: Nationality -> Bool Source # isUserSort :: Nationality -> Bool Source # isChar :: Nationality -> Bool Source # isString :: Nationality -> Bool Source # isList :: Nationality -> Bool Source # isSet :: Nationality -> Bool Source # isTuple :: Nationality -> Bool Source # isMaybe :: Nationality -> Bool Source # isEither :: Nationality -> Bool Source # isArray :: Nationality -> Bool Source # showType :: Nationality -> String Source # | |
| HasKind Pet Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods kindOf :: Pet -> Kind Source # hasSign :: Pet -> Bool Source # intSizeOf :: Pet -> Int Source # isBoolean :: Pet -> Bool Source # isBounded :: Pet -> Bool Source # isReal :: Pet -> Bool Source # isFloat :: Pet -> Bool Source # isDouble :: Pet -> Bool Source # isRational :: Pet -> Bool Source # isUnbounded :: Pet -> Bool Source # isUserSort :: Pet -> Bool Source # isChar :: Pet -> Bool Source # isString :: Pet -> Bool Source # isList :: Pet -> Bool Source # isTuple :: Pet -> Bool Source # isMaybe :: Pet -> Bool Source # isEither :: Pet -> Bool Source # | |
| HasKind Sport Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Fish Methods kindOf :: Sport -> Kind Source # hasSign :: Sport -> Bool Source # intSizeOf :: Sport -> Int Source # isBoolean :: Sport -> Bool Source # isBounded :: Sport -> Bool Source # isReal :: Sport -> Bool Source # isFloat :: Sport -> Bool Source # isDouble :: Sport -> Bool Source # isRational :: Sport -> Bool Source # isFP :: Sport -> Bool Source # isUnbounded :: Sport -> Bool Source # isUserSort :: Sport -> Bool Source # isChar :: Sport -> Bool Source # isString :: Sport -> Bool Source # isList :: Sport -> Bool Source # isSet :: Sport -> Bool Source # isTuple :: Sport -> Bool Source # isMaybe :: Sport -> Bool Source # isEither :: Sport -> Bool Source # | |
| HasKind Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Garden Methods kindOf :: Color -> Kind Source # hasSign :: Color -> Bool Source # intSizeOf :: Color -> Int Source # isBoolean :: Color -> Bool Source # isBounded :: Color -> Bool Source # isReal :: Color -> Bool Source # isFloat :: Color -> Bool Source # isDouble :: Color -> Bool Source # isRational :: Color -> Bool Source # isFP :: Color -> Bool Source # isUnbounded :: Color -> Bool Source # isUserSort :: Color -> Bool Source # isChar :: Color -> Bool Source # isString :: Color -> Bool Source # isList :: Color -> Bool Source # isSet :: Color -> Bool Source # isTuple :: Color -> Bool Source # isMaybe :: Color -> Bool Source # isEither :: Color -> Bool Source # | |
| HasKind Color Source # | |
Defined in Documentation.SBV.Examples.Puzzles.HexPuzzle Methods kindOf :: Color -> Kind Source # hasSign :: Color -> Bool Source # intSizeOf :: Color -> Int Source # isBoolean :: Color -> Bool Source # isBounded :: Color -> Bool Source # isReal :: Color -> Bool Source # isFloat :: Color -> Bool Source # isDouble :: Color -> Bool Source # isRational :: Color -> Bool Source # isFP :: Color -> Bool Source # isUnbounded :: Color -> Bool Source # isUserSort :: Color -> Bool Source # isChar :: Color -> Bool Source # isString :: Color -> Bool Source # isList :: Color -> Bool Source # isSet :: Color -> Bool Source # isTuple :: Color -> Bool Source # isMaybe :: Color -> Bool Source # isEither :: Color -> Bool Source # | |
| HasKind Identity Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods kindOf :: Identity -> Kind Source # hasSign :: Identity -> Bool Source # intSizeOf :: Identity -> Int Source # isBoolean :: Identity -> Bool Source # isBounded :: Identity -> Bool Source # isReal :: Identity -> Bool Source # isFloat :: Identity -> Bool Source # isDouble :: Identity -> Bool Source # isRational :: Identity -> Bool Source # isFP :: Identity -> Bool Source # isUnbounded :: Identity -> Bool Source # isUserSort :: Identity -> Bool Source # isChar :: Identity -> Bool Source # isString :: Identity -> Bool Source # isList :: Identity -> Bool Source # isSet :: Identity -> Bool Source # isTuple :: Identity -> Bool Source # isMaybe :: Identity -> Bool Source # isEither :: Identity -> Bool Source # | |
| HasKind Inhabitant Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods kindOf :: Inhabitant -> Kind Source # hasSign :: Inhabitant -> Bool Source # intSizeOf :: Inhabitant -> Int Source # isBoolean :: Inhabitant -> Bool Source # isBounded :: Inhabitant -> Bool Source # isReal :: Inhabitant -> Bool Source # isFloat :: Inhabitant -> Bool Source # isDouble :: Inhabitant -> Bool Source # isRational :: Inhabitant -> Bool Source # isFP :: Inhabitant -> Bool Source # isUnbounded :: Inhabitant -> Bool Source # isUserSort :: Inhabitant -> Bool Source # isChar :: Inhabitant -> Bool Source # isString :: Inhabitant -> Bool Source # isList :: Inhabitant -> Bool Source # isSet :: Inhabitant -> Bool Source # isTuple :: Inhabitant -> Bool Source # isMaybe :: Inhabitant -> Bool Source # isEither :: Inhabitant -> Bool Source # isArray :: Inhabitant -> Bool Source # showType :: Inhabitant -> String Source # | |
| HasKind Statement Source # | |
Defined in Documentation.SBV.Examples.Puzzles.KnightsAndKnaves Methods kindOf :: Statement -> Kind Source # hasSign :: Statement -> Bool Source # intSizeOf :: Statement -> Int Source # isBoolean :: Statement -> Bool Source # isBounded :: Statement -> Bool Source # isReal :: Statement -> Bool Source # isFloat :: Statement -> Bool Source # isDouble :: Statement -> Bool Source # isRational :: Statement -> Bool Source # isFP :: Statement -> Bool Source # isUnbounded :: Statement -> Bool Source # isUserSort :: Statement -> Bool Source # isChar :: Statement -> Bool Source # isString :: Statement -> Bool Source # isList :: Statement -> Bool Source # isSet :: Statement -> Bool Source # isTuple :: Statement -> Bool Source # isMaybe :: Statement -> Bool Source # isEither :: Statement -> Bool Source # | |
| HasKind Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods kindOf :: Location -> Kind Source # hasSign :: Location -> Bool Source # intSizeOf :: Location -> Int Source # isBoolean :: Location -> Bool Source # isBounded :: Location -> Bool Source # isReal :: Location -> Bool Source # isFloat :: Location -> Bool Source # isDouble :: Location -> Bool Source # isRational :: Location -> Bool Source # isFP :: Location -> Bool Source # isUnbounded :: Location -> Bool Source # isUserSort :: Location -> Bool Source # isChar :: Location -> Bool Source # isString :: Location -> Bool Source # isList :: Location -> Bool Source # isSet :: Location -> Bool Source # isTuple :: Location -> Bool Source # isMaybe :: Location -> Bool Source # isEither :: Location -> Bool Source # | |
| HasKind Role Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods kindOf :: Role -> Kind Source # hasSign :: Role -> Bool Source # intSizeOf :: Role -> Int Source # isBoolean :: Role -> Bool Source # isBounded :: Role -> Bool Source # isReal :: Role -> Bool Source # isFloat :: Role -> Bool Source # isDouble :: Role -> Bool Source # isRational :: Role -> Bool Source # isUnbounded :: Role -> Bool Source # isUserSort :: Role -> Bool Source # isChar :: Role -> Bool Source # isString :: Role -> Bool Source # isList :: Role -> Bool Source # isSet :: Role -> Bool Source # isTuple :: Role -> Bool Source # isMaybe :: Role -> Bool Source # isEither :: Role -> Bool Source # | |
| HasKind Sex Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Murder Methods kindOf :: Sex -> Kind Source # hasSign :: Sex -> Bool Source # intSizeOf :: Sex -> Int Source # isBoolean :: Sex -> Bool Source # isBounded :: Sex -> Bool Source # isReal :: Sex -> Bool Source # isFloat :: Sex -> Bool Source # isDouble :: Sex -> Bool Source # isRational :: Sex -> Bool Source # isUnbounded :: Sex -> Bool Source # isUserSort :: Sex -> Bool Source # isChar :: Sex -> Bool Source # isString :: Sex -> Bool Source # isList :: Sex -> Bool Source # isTuple :: Sex -> Bool Source # isMaybe :: Sex -> Bool Source # isEither :: Sex -> Bool Source # | |
| HasKind Handler Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods kindOf :: Handler -> Kind Source # hasSign :: Handler -> Bool Source # intSizeOf :: Handler -> Int Source # isBoolean :: Handler -> Bool Source # isBounded :: Handler -> Bool Source # isReal :: Handler -> Bool Source # isFloat :: Handler -> Bool Source # isDouble :: Handler -> Bool Source # isRational :: Handler -> Bool Source # isFP :: Handler -> Bool Source # isUnbounded :: Handler -> Bool Source # isUserSort :: Handler -> Bool Source # isChar :: Handler -> Bool Source # isString :: Handler -> Bool Source # isList :: Handler -> Bool Source # isSet :: Handler -> Bool Source # isTuple :: Handler -> Bool Source # isMaybe :: Handler -> Bool Source # isEither :: Handler -> Bool Source # | |
| HasKind Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods kindOf :: Location -> Kind Source # hasSign :: Location -> Bool Source # intSizeOf :: Location -> Int Source # isBoolean :: Location -> Bool Source # isBounded :: Location -> Bool Source # isReal :: Location -> Bool Source # isFloat :: Location -> Bool Source # isDouble :: Location -> Bool Source # isRational :: Location -> Bool Source # isFP :: Location -> Bool Source # isUnbounded :: Location -> Bool Source # isUserSort :: Location -> Bool Source # isChar :: Location -> Bool Source # isString :: Location -> Bool Source # isList :: Location -> Bool Source # isSet :: Location -> Bool Source # isTuple :: Location -> Bool Source # isMaybe :: Location -> Bool Source # isEither :: Location -> Bool Source # | |
| HasKind Orangutan Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Orangutans Methods kindOf :: Orangutan -> Kind Source # hasSign :: Orangutan -> Bool Source # intSizeOf :: Orangutan -> Int Source # isBoolean :: Orangutan -> Bool Source # isBounded :: Orangutan -> Bool Source # isReal :: Orangutan -> Bool Source # isFloat :: Orangutan -> Bool Source # isDouble :: Orangutan -> Bool Source # isRational :: Orangutan -> Bool Source # isFP :: Orangutan -> Bool Source # isUnbounded :: Orangutan -> Bool Source # isUserSort :: Orangutan -> Bool Source # isChar :: Orangutan -> Bool Source # isString :: Orangutan -> Bool Source # isList :: Orangutan -> Bool Source # isSet :: Orangutan -> Bool Source # isTuple :: Orangutan -> Bool Source # isMaybe :: Orangutan -> Bool Source # isEither :: Orangutan -> Bool Source # | |
| HasKind Rabbit Source # | |
Defined in Documentation.SBV.Examples.Puzzles.Rabbits Methods kindOf :: Rabbit -> Kind Source # hasSign :: Rabbit -> Bool Source # intSizeOf :: Rabbit -> Int Source # isBoolean :: Rabbit -> Bool Source # isBounded :: Rabbit -> Bool Source # isReal :: Rabbit -> Bool Source # isFloat :: Rabbit -> Bool Source # isDouble :: Rabbit -> Bool Source # isRational :: Rabbit -> Bool Source # isFP :: Rabbit -> Bool Source # isUnbounded :: Rabbit -> Bool Source # isUserSort :: Rabbit -> Bool Source # isChar :: Rabbit -> Bool Source # isString :: Rabbit -> Bool Source # isList :: Rabbit -> Bool Source # isSet :: Rabbit -> Bool Source # isTuple :: Rabbit -> Bool Source # isMaybe :: Rabbit -> Bool Source # isEither :: Rabbit -> Bool Source # | |
| HasKind Location Source # | |
Defined in Documentation.SBV.Examples.Puzzles.U2Bridge Methods kindOf :: Location -> Kind Source # hasSign :: Location -> Bool Source # intSizeOf :: Location -> Int Source # isBoolean :: Location -> Bool Source # isBounded :: Location -> Bool Source # isReal :: Location -> Bool Source # isFloat :: Location -> Bool Source # isDouble :: Location -> Bool Source # isRational :: Location -> Bool Source # isFP :: Location -> Bool Source # isUnbounded :: Location -> Bool Source # isUserSort :: Location -> Bool Source # isChar :: Location -> Bool Source # isString :: Location -> Bool Source # isList :: Location -> Bool Source # isSet :: Location -> Bool Source # isTuple :: Location -> Bool Source # isMaybe :: Location -> Bool Source # isEither :: Location -> Bool Source # | |
| HasKind U2Member Source # | |
Defined in Documentation.SBV.Examples.Puzzles.U2Bridge Methods kindOf :: U2Member -> Kind Source # hasSign :: U2Member -> Bool Source # intSizeOf :: U2Member -> Int Source # isBoolean :: U2Member -> Bool Source # isBounded :: U2Member -> Bool Source # isReal :: U2Member -> Bool Source # isFloat :: U2Member -> Bool Source # isDouble :: U2Member -> Bool Source # isRational :: U2Member -> Bool Source # isFP :: U2Member -> Bool Source # isUnbounded :: U2Member -> Bool Source # isUserSort :: U2Member -> Bool Source # isChar :: U2Member -> Bool Source # isString :: U2Member -> Bool Source # isList :: U2Member -> Bool Source # isSet :: U2Member -> Bool Source # isTuple :: U2Member -> Bool Source # isMaybe :: U2Member -> Bool Source # isEither :: U2Member -> Bool Source # | |
| HasKind Day Source # | |
Defined in Documentation.SBV.Examples.Queries.Enums Methods kindOf :: Day -> Kind Source # hasSign :: Day -> Bool Source # intSizeOf :: Day -> Int Source # isBoolean :: Day -> Bool Source # isBounded :: Day -> Bool Source # isReal :: Day -> Bool Source # isFloat :: Day -> Bool Source # isDouble :: Day -> Bool Source # isRational :: Day -> Bool Source # isUnbounded :: Day -> Bool Source # isUserSort :: Day -> Bool Source # isChar :: Day -> Bool Source # isString :: Day -> Bool Source # isList :: Day -> Bool Source # isTuple :: Day -> Bool Source # isMaybe :: Day -> Bool Source # isEither :: Day -> Bool Source # | |
| HasKind BinOp Source # | |
Defined in Documentation.SBV.Examples.Queries.FourFours Methods kindOf :: BinOp -> Kind Source # hasSign :: BinOp -> Bool Source # intSizeOf :: BinOp -> Int Source # isBoolean :: BinOp -> Bool Source # isBounded :: BinOp -> Bool Source # isReal :: BinOp -> Bool Source # isFloat :: BinOp -> Bool Source # isDouble :: BinOp -> Bool Source # isRational :: BinOp -> Bool Source # isFP :: BinOp -> Bool Source # isUnbounded :: BinOp -> Bool Source # isUserSort :: BinOp -> Bool Source # isChar :: BinOp -> Bool Source # isString :: BinOp -> Bool Source # isList :: BinOp -> Bool Source # isSet :: BinOp -> Bool Source # isTuple :: BinOp -> Bool Source # isMaybe :: BinOp -> Bool Source # isEither :: BinOp -> Bool Source # | |
| HasKind UnOp Source # | |
Defined in Documentation.SBV.Examples.Queries.FourFours Methods kindOf :: UnOp -> Kind Source # hasSign :: UnOp -> Bool Source # intSizeOf :: UnOp -> Int Source # isBoolean :: UnOp -> Bool Source # isBounded :: UnOp -> Bool Source # isReal :: UnOp -> Bool Source # isFloat :: UnOp -> Bool Source # isDouble :: UnOp -> Bool Source # isRational :: UnOp -> Bool Source # isUnbounded :: UnOp -> Bool Source # isUserSort :: UnOp -> Bool Source # isChar :: UnOp -> Bool Source # isString :: UnOp -> Bool Source # isList :: UnOp -> Bool Source # isSet :: UnOp -> Bool Source # isTuple :: UnOp -> Bool Source # isMaybe :: UnOp -> Bool Source # isEither :: UnOp -> Bool Source # | |
| HasKind B Source # | |
| HasKind Q Source # | |
| HasKind L Source # | |
Defined in Documentation.SBV.Examples.Uninterpreted.UISortAllSat | |
| HasKind Integer Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Integer -> Kind Source # hasSign :: Integer -> Bool Source # intSizeOf :: Integer -> Int Source # isBoolean :: Integer -> Bool Source # isBounded :: Integer -> Bool Source # isReal :: Integer -> Bool Source # isFloat :: Integer -> Bool Source # isDouble :: Integer -> Bool Source # isRational :: Integer -> Bool Source # isFP :: Integer -> Bool Source # isUnbounded :: Integer -> Bool Source # isUserSort :: Integer -> Bool Source # isChar :: Integer -> Bool Source # isString :: Integer -> Bool Source # isList :: Integer -> Bool Source # isSet :: Integer -> Bool Source # isTuple :: Integer -> Bool Source # isMaybe :: Integer -> Bool Source # isEither :: Integer -> Bool Source # | |
| HasKind () Source # | |
Defined in Data.SBV.Core.Kind Methods hasSign :: () -> Bool Source # intSizeOf :: () -> Int Source # isBoolean :: () -> Bool Source # isBounded :: () -> Bool Source # isFloat :: () -> Bool Source # isDouble :: () -> Bool Source # isRational :: () -> Bool Source # isUnbounded :: () -> Bool Source # isUserSort :: () -> Bool Source # isString :: () -> Bool Source # isTuple :: () -> Bool Source # isMaybe :: () -> Bool Source # isEither :: () -> Bool Source # | |
| HasKind Bool Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Bool -> Kind Source # hasSign :: Bool -> Bool Source # intSizeOf :: Bool -> Int Source # isBoolean :: Bool -> Bool Source # isBounded :: Bool -> Bool Source # isReal :: Bool -> Bool Source # isFloat :: Bool -> Bool Source # isDouble :: Bool -> Bool Source # isRational :: Bool -> Bool Source # isUnbounded :: Bool -> Bool Source # isUserSort :: Bool -> Bool Source # isChar :: Bool -> Bool Source # isString :: Bool -> Bool Source # isList :: Bool -> Bool Source # isSet :: Bool -> Bool Source # isTuple :: Bool -> Bool Source # isMaybe :: Bool -> Bool Source # isEither :: Bool -> Bool Source # | |
| HasKind Char Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Char -> Kind Source # hasSign :: Char -> Bool Source # intSizeOf :: Char -> Int Source # isBoolean :: Char -> Bool Source # isBounded :: Char -> Bool Source # isReal :: Char -> Bool Source # isFloat :: Char -> Bool Source # isDouble :: Char -> Bool Source # isRational :: Char -> Bool Source # isUnbounded :: Char -> Bool Source # isUserSort :: Char -> Bool Source # isChar :: Char -> Bool Source # isString :: Char -> Bool Source # isList :: Char -> Bool Source # isSet :: Char -> Bool Source # isTuple :: Char -> Bool Source # isMaybe :: Char -> Bool Source # isEither :: Char -> Bool Source # | |
| HasKind Double Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Double -> Kind Source # hasSign :: Double -> Bool Source # intSizeOf :: Double -> Int Source # isBoolean :: Double -> Bool Source # isBounded :: Double -> Bool Source # isReal :: Double -> Bool Source # isFloat :: Double -> Bool Source # isDouble :: Double -> Bool Source # isRational :: Double -> Bool Source # isFP :: Double -> Bool Source # isUnbounded :: Double -> Bool Source # isUserSort :: Double -> Bool Source # isChar :: Double -> Bool Source # isString :: Double -> Bool Source # isList :: Double -> Bool Source # isSet :: Double -> Bool Source # isTuple :: Double -> Bool Source # isMaybe :: Double -> Bool Source # isEither :: Double -> Bool Source # | |
| HasKind Float Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Float -> Kind Source # hasSign :: Float -> Bool Source # intSizeOf :: Float -> Int Source # isBoolean :: Float -> Bool Source # isBounded :: Float -> Bool Source # isReal :: Float -> Bool Source # isFloat :: Float -> Bool Source # isDouble :: Float -> Bool Source # isRational :: Float -> Bool Source # isFP :: Float -> Bool Source # isUnbounded :: Float -> Bool Source # isUserSort :: Float -> Bool Source # isChar :: Float -> Bool Source # isString :: Float -> Bool Source # isList :: Float -> Bool Source # isSet :: Float -> Bool Source # isTuple :: Float -> Bool Source # isMaybe :: Float -> Bool Source # isEither :: Float -> Bool Source # | |
| HasKind a => HasKind (RCSet a) Source # | |
Defined in Data.SBV.Core.Concrete Methods kindOf :: RCSet a -> Kind Source # hasSign :: RCSet a -> Bool Source # intSizeOf :: RCSet a -> Int Source # isBoolean :: RCSet a -> Bool Source # isBounded :: RCSet a -> Bool Source # isReal :: RCSet a -> Bool Source # isFloat :: RCSet a -> Bool Source # isDouble :: RCSet a -> Bool Source # isRational :: RCSet a -> Bool Source # isFP :: RCSet a -> Bool Source # isUnbounded :: RCSet a -> Bool Source # isUserSort :: RCSet a -> Bool Source # isChar :: RCSet a -> Bool Source # isString :: RCSet a -> Bool Source # isList :: RCSet a -> Bool Source # isSet :: RCSet a -> Bool Source # isTuple :: RCSet a -> Bool Source # isMaybe :: RCSet a -> Bool Source # isEither :: RCSet a -> Bool Source # | |
| HasKind a => HasKind (SBV a) Source # | |
Defined in Data.SBV.Core.Data Methods kindOf :: SBV a -> Kind Source # hasSign :: SBV a -> Bool Source # intSizeOf :: SBV a -> Int Source # isBoolean :: SBV a -> Bool Source # isBounded :: SBV a -> Bool Source # isReal :: SBV a -> Bool Source # isFloat :: SBV a -> Bool Source # isDouble :: SBV a -> Bool Source # isRational :: SBV a -> Bool Source # isFP :: SBV a -> Bool Source # isUnbounded :: SBV a -> Bool Source # isUserSort :: SBV a -> Bool Source # isChar :: SBV a -> Bool Source # isString :: SBV a -> Bool Source # isList :: SBV a -> Bool Source # isSet :: SBV a -> Bool Source # isTuple :: SBV a -> Bool Source # isMaybe :: SBV a -> Bool Source # isEither :: SBV a -> Bool Source # | |
| (KnownNat n, BVIsNonZero n) => HasKind (IntN n) Source # |
|
Defined in Data.SBV.Core.Sized Methods kindOf :: IntN n -> Kind Source # hasSign :: IntN n -> Bool Source # intSizeOf :: IntN n -> Int Source # isBoolean :: IntN n -> Bool Source # isBounded :: IntN n -> Bool Source # isReal :: IntN n -> Bool Source # isFloat :: IntN n -> Bool Source # isDouble :: IntN n -> Bool Source # isRational :: IntN n -> Bool Source # isFP :: IntN n -> Bool Source # isUnbounded :: IntN n -> Bool Source # isUserSort :: IntN n -> Bool Source # isChar :: IntN n -> Bool Source # isString :: IntN n -> Bool Source # isList :: IntN n -> Bool Source # isSet :: IntN n -> Bool Source # isTuple :: IntN n -> Bool Source # isMaybe :: IntN n -> Bool Source # isEither :: IntN n -> Bool Source # | |
| (KnownNat n, BVIsNonZero n) => HasKind (WordN n) Source # |
|
Defined in Data.SBV.Core.Sized Methods kindOf :: WordN n -> Kind Source # hasSign :: WordN n -> Bool Source # intSizeOf :: WordN n -> Int Source # isBoolean :: WordN n -> Bool Source # isBounded :: WordN n -> Bool Source # isReal :: WordN n -> Bool Source # isFloat :: WordN n -> Bool Source # isDouble :: WordN n -> Bool Source # isRational :: WordN n -> Bool Source # isFP :: WordN n -> Bool Source # isUnbounded :: WordN n -> Bool Source # isUserSort :: WordN n -> Bool Source # isChar :: WordN n -> Bool Source # isString :: WordN n -> Bool Source # isList :: WordN n -> Bool Source # isSet :: WordN n -> Bool Source # isTuple :: WordN n -> Bool Source # isMaybe :: WordN n -> Bool Source # isEither :: WordN n -> Bool Source # | |
| HasKind a => HasKind (Maybe a) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Maybe a -> Kind Source # hasSign :: Maybe a -> Bool Source # intSizeOf :: Maybe a -> Int Source # isBoolean :: Maybe a -> Bool Source # isBounded :: Maybe a -> Bool Source # isReal :: Maybe a -> Bool Source # isFloat :: Maybe a -> Bool Source # isDouble :: Maybe a -> Bool Source # isRational :: Maybe a -> Bool Source # isFP :: Maybe a -> Bool Source # isUnbounded :: Maybe a -> Bool Source # isUserSort :: Maybe a -> Bool Source # isChar :: Maybe a -> Bool Source # isString :: Maybe a -> Bool Source # isList :: Maybe a -> Bool Source # isSet :: Maybe a -> Bool Source # isTuple :: Maybe a -> Bool Source # isMaybe :: Maybe a -> Bool Source # isEither :: Maybe a -> Bool Source # | |
| (Typeable a, HasKind a) => HasKind [a] Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: [a] -> Kind Source # hasSign :: [a] -> Bool Source # intSizeOf :: [a] -> Int Source # isBoolean :: [a] -> Bool Source # isBounded :: [a] -> Bool Source # isReal :: [a] -> Bool Source # isFloat :: [a] -> Bool Source # isDouble :: [a] -> Bool Source # isRational :: [a] -> Bool Source # isUnbounded :: [a] -> Bool Source # isUserSort :: [a] -> Bool Source # isChar :: [a] -> Bool Source # isString :: [a] -> Bool Source # isList :: [a] -> Bool Source # isTuple :: [a] -> Bool Source # isMaybe :: [a] -> Bool Source # isEither :: [a] -> Bool Source # | |
| (HasKind a, HasKind b) => HasKind (Either a b) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: Either a b -> Kind Source # hasSign :: Either a b -> Bool Source # intSizeOf :: Either a b -> Int Source # isBoolean :: Either a b -> Bool Source # isBounded :: Either a b -> Bool Source # isReal :: Either a b -> Bool Source # isFloat :: Either a b -> Bool Source # isDouble :: Either a b -> Bool Source # isRational :: Either a b -> Bool Source # isFP :: Either a b -> Bool Source # isUnbounded :: Either a b -> Bool Source # isUserSort :: Either a b -> Bool Source # isChar :: Either a b -> Bool Source # isString :: Either a b -> Bool Source # isList :: Either a b -> Bool Source # isSet :: Either a b -> Bool Source # isTuple :: Either a b -> Bool Source # isMaybe :: Either a b -> Bool Source # isEither :: Either a b -> Bool Source # | |
| HasKind a => HasKind (Proxy a) Source # | This instance allows us to use the `kindOf (Proxy @a)` idiom instead of the `kindOf (undefined :: a)`, which is safer and looks more idiomatic. |
Defined in Data.SBV.Core.Kind Methods kindOf :: Proxy a -> Kind Source # hasSign :: Proxy a -> Bool Source # intSizeOf :: Proxy a -> Int Source # isBoolean :: Proxy a -> Bool Source # isBounded :: Proxy a -> Bool Source # isReal :: Proxy a -> Bool Source # isFloat :: Proxy a -> Bool Source # isDouble :: Proxy a -> Bool Source # isRational :: Proxy a -> Bool Source # isFP :: Proxy a -> Bool Source # isUnbounded :: Proxy a -> Bool Source # isUserSort :: Proxy a -> Bool Source # isChar :: Proxy a -> Bool Source # isString :: Proxy a -> Bool Source # isList :: Proxy a -> Bool Source # isSet :: Proxy a -> Bool Source # isTuple :: Proxy a -> Bool Source # isMaybe :: Proxy a -> Bool Source # isEither :: Proxy a -> Bool Source # | |
| (HasKind a, HasKind b) => HasKind (ArrayModel a b) Source # | The kind of an ArrayModel |
Defined in Data.SBV.Core.Concrete Methods kindOf :: ArrayModel a b -> Kind Source # hasSign :: ArrayModel a b -> Bool Source # intSizeOf :: ArrayModel a b -> Int Source # isBoolean :: ArrayModel a b -> Bool Source # isBounded :: ArrayModel a b -> Bool Source # isReal :: ArrayModel a b -> Bool Source # isFloat :: ArrayModel a b -> Bool Source # isDouble :: ArrayModel a b -> Bool Source # isRational :: ArrayModel a b -> Bool Source # isFP :: ArrayModel a b -> Bool Source # isUnbounded :: ArrayModel a b -> Bool Source # isUserSort :: ArrayModel a b -> Bool Source # isChar :: ArrayModel a b -> Bool Source # isString :: ArrayModel a b -> Bool Source # isList :: ArrayModel a b -> Bool Source # isSet :: ArrayModel a b -> Bool Source # isTuple :: ArrayModel a b -> Bool Source # isMaybe :: ArrayModel a b -> Bool Source # isEither :: ArrayModel a b -> Bool Source # isArray :: ArrayModel a b -> Bool Source # showType :: ArrayModel a b -> String Source # | |
| ValidFloat eb sb => HasKind (FloatingPoint eb sb) Source # | |
Defined in Data.SBV.Core.Model Methods kindOf :: FloatingPoint eb sb -> Kind Source # hasSign :: FloatingPoint eb sb -> Bool Source # intSizeOf :: FloatingPoint eb sb -> Int Source # isBoolean :: FloatingPoint eb sb -> Bool Source # isBounded :: FloatingPoint eb sb -> Bool Source # isReal :: FloatingPoint eb sb -> Bool Source # isFloat :: FloatingPoint eb sb -> Bool Source # isDouble :: FloatingPoint eb sb -> Bool Source # isRational :: FloatingPoint eb sb -> Bool Source # isFP :: FloatingPoint eb sb -> Bool Source # isUnbounded :: FloatingPoint eb sb -> Bool Source # isUserSort :: FloatingPoint eb sb -> Bool Source # isChar :: FloatingPoint eb sb -> Bool Source # isString :: FloatingPoint eb sb -> Bool Source # isList :: FloatingPoint eb sb -> Bool Source # isSet :: FloatingPoint eb sb -> Bool Source # isTuple :: FloatingPoint eb sb -> Bool Source # isMaybe :: FloatingPoint eb sb -> Bool Source # isEither :: FloatingPoint eb sb -> Bool Source # isArray :: FloatingPoint eb sb -> Bool Source # showType :: FloatingPoint eb sb -> String Source # | |
| (HasKind a, HasKind b) => HasKind (a, b) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b) -> Kind Source # hasSign :: (a, b) -> Bool Source # intSizeOf :: (a, b) -> Int Source # isBoolean :: (a, b) -> Bool Source # isBounded :: (a, b) -> Bool Source # isReal :: (a, b) -> Bool Source # isFloat :: (a, b) -> Bool Source # isDouble :: (a, b) -> Bool Source # isRational :: (a, b) -> Bool Source # isFP :: (a, b) -> Bool Source # isUnbounded :: (a, b) -> Bool Source # isUserSort :: (a, b) -> Bool Source # isChar :: (a, b) -> Bool Source # isString :: (a, b) -> Bool Source # isList :: (a, b) -> Bool Source # isSet :: (a, b) -> Bool Source # isTuple :: (a, b) -> Bool Source # isMaybe :: (a, b) -> Bool Source # isEither :: (a, b) -> Bool Source # | |
| (HasKind a, HasKind b) => HasKind (a -> b) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a -> b) -> Kind Source # hasSign :: (a -> b) -> Bool Source # intSizeOf :: (a -> b) -> Int Source # isBoolean :: (a -> b) -> Bool Source # isBounded :: (a -> b) -> Bool Source # isReal :: (a -> b) -> Bool Source # isFloat :: (a -> b) -> Bool Source # isDouble :: (a -> b) -> Bool Source # isRational :: (a -> b) -> Bool Source # isFP :: (a -> b) -> Bool Source # isUnbounded :: (a -> b) -> Bool Source # isUserSort :: (a -> b) -> Bool Source # isChar :: (a -> b) -> Bool Source # isString :: (a -> b) -> Bool Source # isList :: (a -> b) -> Bool Source # isSet :: (a -> b) -> Bool Source # isTuple :: (a -> b) -> Bool Source # isMaybe :: (a -> b) -> Bool Source # isEither :: (a -> b) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c) => HasKind (a, b, c) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c) -> Kind Source # hasSign :: (a, b, c) -> Bool Source # intSizeOf :: (a, b, c) -> Int Source # isBoolean :: (a, b, c) -> Bool Source # isBounded :: (a, b, c) -> Bool Source # isReal :: (a, b, c) -> Bool Source # isFloat :: (a, b, c) -> Bool Source # isDouble :: (a, b, c) -> Bool Source # isRational :: (a, b, c) -> Bool Source # isFP :: (a, b, c) -> Bool Source # isUnbounded :: (a, b, c) -> Bool Source # isUserSort :: (a, b, c) -> Bool Source # isChar :: (a, b, c) -> Bool Source # isString :: (a, b, c) -> Bool Source # isList :: (a, b, c) -> Bool Source # isSet :: (a, b, c) -> Bool Source # isTuple :: (a, b, c) -> Bool Source # isMaybe :: (a, b, c) -> Bool Source # isEither :: (a, b, c) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c, HasKind d) => HasKind (a, b, c, d) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c, d) -> Kind Source # hasSign :: (a, b, c, d) -> Bool Source # intSizeOf :: (a, b, c, d) -> Int Source # isBoolean :: (a, b, c, d) -> Bool Source # isBounded :: (a, b, c, d) -> Bool Source # isReal :: (a, b, c, d) -> Bool Source # isFloat :: (a, b, c, d) -> Bool Source # isDouble :: (a, b, c, d) -> Bool Source # isRational :: (a, b, c, d) -> Bool Source # isFP :: (a, b, c, d) -> Bool Source # isUnbounded :: (a, b, c, d) -> Bool Source # isUserSort :: (a, b, c, d) -> Bool Source # isChar :: (a, b, c, d) -> Bool Source # isString :: (a, b, c, d) -> Bool Source # isList :: (a, b, c, d) -> Bool Source # isSet :: (a, b, c, d) -> Bool Source # isTuple :: (a, b, c, d) -> Bool Source # isMaybe :: (a, b, c, d) -> Bool Source # isEither :: (a, b, c, d) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c, HasKind d, HasKind e) => HasKind (a, b, c, d, e) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c, d, e) -> Kind Source # hasSign :: (a, b, c, d, e) -> Bool Source # intSizeOf :: (a, b, c, d, e) -> Int Source # isBoolean :: (a, b, c, d, e) -> Bool Source # isBounded :: (a, b, c, d, e) -> Bool Source # isReal :: (a, b, c, d, e) -> Bool Source # isFloat :: (a, b, c, d, e) -> Bool Source # isDouble :: (a, b, c, d, e) -> Bool Source # isRational :: (a, b, c, d, e) -> Bool Source # isFP :: (a, b, c, d, e) -> Bool Source # isUnbounded :: (a, b, c, d, e) -> Bool Source # isUserSort :: (a, b, c, d, e) -> Bool Source # isChar :: (a, b, c, d, e) -> Bool Source # isString :: (a, b, c, d, e) -> Bool Source # isList :: (a, b, c, d, e) -> Bool Source # isSet :: (a, b, c, d, e) -> Bool Source # isTuple :: (a, b, c, d, e) -> Bool Source # isMaybe :: (a, b, c, d, e) -> Bool Source # isEither :: (a, b, c, d, e) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c, HasKind d, HasKind e, HasKind f) => HasKind (a, b, c, d, e, f) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c, d, e, f) -> Kind Source # hasSign :: (a, b, c, d, e, f) -> Bool Source # intSizeOf :: (a, b, c, d, e, f) -> Int Source # isBoolean :: (a, b, c, d, e, f) -> Bool Source # isBounded :: (a, b, c, d, e, f) -> Bool Source # isReal :: (a, b, c, d, e, f) -> Bool Source # isFloat :: (a, b, c, d, e, f) -> Bool Source # isDouble :: (a, b, c, d, e, f) -> Bool Source # isRational :: (a, b, c, d, e, f) -> Bool Source # isFP :: (a, b, c, d, e, f) -> Bool Source # isUnbounded :: (a, b, c, d, e, f) -> Bool Source # isUserSort :: (a, b, c, d, e, f) -> Bool Source # isChar :: (a, b, c, d, e, f) -> Bool Source # isString :: (a, b, c, d, e, f) -> Bool Source # isList :: (a, b, c, d, e, f) -> Bool Source # isSet :: (a, b, c, d, e, f) -> Bool Source # isTuple :: (a, b, c, d, e, f) -> Bool Source # isMaybe :: (a, b, c, d, e, f) -> Bool Source # isEither :: (a, b, c, d, e, f) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c, HasKind d, HasKind e, HasKind f, HasKind g) => HasKind (a, b, c, d, e, f, g) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c, d, e, f, g) -> Kind Source # hasSign :: (a, b, c, d, e, f, g) -> Bool Source # intSizeOf :: (a, b, c, d, e, f, g) -> Int Source # isBoolean :: (a, b, c, d, e, f, g) -> Bool Source # isBounded :: (a, b, c, d, e, f, g) -> Bool Source # isReal :: (a, b, c, d, e, f, g) -> Bool Source # isFloat :: (a, b, c, d, e, f, g) -> Bool Source # isDouble :: (a, b, c, d, e, f, g) -> Bool Source # isRational :: (a, b, c, d, e, f, g) -> Bool Source # isFP :: (a, b, c, d, e, f, g) -> Bool Source # isUnbounded :: (a, b, c, d, e, f, g) -> Bool Source # isUserSort :: (a, b, c, d, e, f, g) -> Bool Source # isChar :: (a, b, c, d, e, f, g) -> Bool Source # isString :: (a, b, c, d, e, f, g) -> Bool Source # isList :: (a, b, c, d, e, f, g) -> Bool Source # isSet :: (a, b, c, d, e, f, g) -> Bool Source # isTuple :: (a, b, c, d, e, f, g) -> Bool Source # isMaybe :: (a, b, c, d, e, f, g) -> Bool Source # isEither :: (a, b, c, d, e, f, g) -> Bool Source # | |
| (HasKind a, HasKind b, HasKind c, HasKind d, HasKind e, HasKind f, HasKind g, HasKind h) => HasKind (a, b, c, d, e, f, g, h) Source # | |
Defined in Data.SBV.Core.Kind Methods kindOf :: (a, b, c, d, e, f, g, h) -> Kind Source # hasSign :: (a, b, c, d, e, f, g, h) -> Bool Source # intSizeOf :: (a, b, c, d, e, f, g, h) -> Int Source # isBoolean :: (a, b, c, d, e, f, g, h) -> Bool Source # isBounded :: (a, b, c, d, e, f, g, h) -> Bool Source # isReal :: (a, b, c, d, e, f, g, h) -> Bool Source # isFloat :: (a, b, c, d, e, f, g, h) -> Bool Source # isDouble :: (a, b, c, d, e, f, g, h) -> Bool Source # isRational :: (a, b, c, d, e, f, g, h) -> Bool Source # isFP :: (a, b, c, d, e, f, g, h) -> Bool Source # isUnbounded :: (a, b, c, d, e, f, g, h) -> Bool Source # isUserSort :: (a, b, c, d, e, f, g, h) -> Bool Source # isChar :: (a, b, c, d, e, f, g, h) -> Bool Source # isString :: (a, b, c, d, e, f, g, h) -> Bool Source # isList :: (a, b, c, d, e, f, g, h) -> Bool Source # isSet :: (a, b, c, d, e, f, g, h) -> Bool Source # isTuple :: (a, b, c, d, e, f, g, h) -> Bool Source # isMaybe :: (a, b, c, d, e, f, g, h) -> Bool Source # isEither :: (a, b, c, d, e, f, g, h) -> Bool Source # | |
Kind of symbolic value
Constructors
| KBool | |
| KBounded !Bool !Int | |
| KUnbounded | |
| KReal | |
| KUserSort String (Maybe [String]) | |
| KFloat | |
| KDouble | |
| KFP !Int !Int | |
| KChar | |
| KString | |
| KList Kind | |
| KSet Kind | |
| KTuple [Kind] | |
| KMaybe Kind | |
| KRational | |
| KEither Kind Kind | |
| KArray Kind Kind |
Instances
| NFData Kind Source # | |||||
Defined in Data.SBV.Core.Kind | |||||
| Data Kind Source # | |||||
Defined in Data.SBV.Core.Kind Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Kind -> c Kind # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Kind # dataTypeOf :: Kind -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Kind) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Kind) # gmapT :: (forall b. Data b => b -> b) -> Kind -> Kind # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Kind -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Kind -> r # gmapQ :: (forall d. Data d => d -> u) -> Kind -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Kind -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Kind -> m Kind # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Kind -> m Kind # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Kind -> m Kind # | |||||
| Generic Kind Source # | |||||
Defined in Data.SBV.Core.Kind Associated Types
| |||||
| Show Kind Source # | The interesting about the show instance is that it can tell apart two kinds nicely; since it conveniently
ignores the enumeration constructors. Also, when we construct a | ||||
| Eq Kind Source # | |||||
| Ord Kind Source # | |||||
| HasKind Kind Source # | |||||
Defined in Data.SBV.Core.Kind Methods kindOf :: Kind -> Kind Source # hasSign :: Kind -> Bool Source # intSizeOf :: Kind -> Int Source # isBoolean :: Kind -> Bool Source # isBounded :: Kind -> Bool Source # isReal :: Kind -> Bool Source # isFloat :: Kind -> Bool Source # isDouble :: Kind -> Bool Source # isRational :: Kind -> Bool Source # isUnbounded :: Kind -> Bool Source # isUserSort :: Kind -> Bool Source # isChar :: Kind -> Bool Source # isString :: Kind -> Bool Source # isList :: Kind -> Bool Source # isSet :: Kind -> Bool Source # isTuple :: Kind -> Bool Source # isMaybe :: Kind -> Bool Source # isEither :: Kind -> Bool Source # | |||||
| type Rep Kind Source # | |||||
Defined in Data.SBV.Core.Kind type Rep Kind = D1 ('MetaData "Kind" "Data.SBV.Core.Kind" "sbv-11.4-inplace" 'False) ((((C1 ('MetaCons "KBool" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KBounded" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int))) :+: (C1 ('MetaCons "KUnbounded" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KReal" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "KUserSort" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [String]))) :+: C1 ('MetaCons "KFloat" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KDouble" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KFP" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int))))) :+: (((C1 ('MetaCons "KChar" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KString" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KList" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "KSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)))) :+: ((C1 ('MetaCons "KTuple" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Kind])) :+: C1 ('MetaCons "KMaybe" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind))) :+: (C1 ('MetaCons "KRational" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "KEither" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind)) :+: C1 ('MetaCons "KArray" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind))))))) | |||||
data RoundingMode Source #
Rounding mode to be used for the IEEE floating-point operations.
Note that Haskell's default is RoundNearestTiesToEven. If you use
a different rounding mode, then the counter-examples you get may not
match what you observe in Haskell.
Constructors
| RoundNearestTiesToEven | Round to nearest representable floating point value. If precisely at half-way, pick the even number. (In this context, even means the lowest-order bit is zero.) |
| RoundNearestTiesToAway | Round to nearest representable floating point value. If precisely at half-way, pick the number further away from 0. (That is, for positive values, pick the greater; for negative values, pick the smaller.) |
| RoundTowardPositive | Round towards positive infinity. (Also known as rounding-up or ceiling.) |
| RoundTowardNegative | Round towards negative infinity. (Also known as rounding-down or floor.) |
| RoundTowardZero | Round towards zero. (Also known as truncation.) |
Instances
| Data RoundingMode Source # | |
Defined in Data.SBV.Core.Kind Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoundingMode -> c RoundingMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RoundingMode # toConstr :: RoundingMode -> Constr # dataTypeOf :: RoundingMode -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RoundingMode) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RoundingMode) # gmapT :: (forall b. Data b => b -> b) -> RoundingMode -> RoundingMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoundingMode -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoundingMode -> r # gmapQ :: (forall d. Data d => d -> u) -> RoundingMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoundingMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode # | |
| Bounded RoundingMode Source # | |
Defined in Data.SBV.Core.Kind | |
| Enum RoundingMode Source # | |
Defined in Data.SBV.Core.Kind Methods succ :: RoundingMode -> RoundingMode # pred :: RoundingMode -> RoundingMode # toEnum :: Int -> RoundingMode # fromEnum :: RoundingMode -> Int # enumFrom :: RoundingMode -> [RoundingMode] # enumFromThen :: RoundingMode -> RoundingMode -> [RoundingMode] # enumFromTo :: RoundingMode -> RoundingMode -> [RoundingMode] # enumFromThenTo :: RoundingMode -> RoundingMode -> RoundingMode -> [RoundingMode] # | |
| Read RoundingMode Source # | |
Defined in Data.SBV.Core.Kind Methods readsPrec :: Int -> ReadS RoundingMode # readList :: ReadS [RoundingMode] # | |
| Show RoundingMode Source # | |
Defined in Data.SBV.Core.Kind Methods showsPrec :: Int -> RoundingMode -> ShowS # show :: RoundingMode -> String # showList :: [RoundingMode] -> ShowS # | |
| Eq RoundingMode Source # | |
Defined in Data.SBV.Core.Kind | |
| Ord RoundingMode Source # | |
Defined in Data.SBV.Core.Kind Methods compare :: RoundingMode -> RoundingMode -> Ordering # (<) :: RoundingMode -> RoundingMode -> Bool # (<=) :: RoundingMode -> RoundingMode -> Bool # (>) :: RoundingMode -> RoundingMode -> Bool # (>=) :: RoundingMode -> RoundingMode -> Bool # max :: RoundingMode -> RoundingMode -> RoundingMode # min :: RoundingMode -> RoundingMode -> RoundingMode # | |
| SymVal RoundingMode Source # |
|
Defined in Data.SBV.Core.Data Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV RoundingMode) Source # literal :: RoundingMode -> SBV RoundingMode Source # fromCV :: CV -> RoundingMode Source # isConcretely :: SBV RoundingMode -> (RoundingMode -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV RoundingMode) Source # free_ :: MonadSymbolic m => m (SBV RoundingMode) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV RoundingMode] Source # symbolic :: MonadSymbolic m => String -> m (SBV RoundingMode) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV RoundingMode] Source # unliteral :: SBV RoundingMode -> Maybe RoundingMode Source # isConcrete :: SBV RoundingMode -> Bool Source # isSymbolic :: SBV RoundingMode -> Bool Source # | |
| HasKind RoundingMode Source # |
|
Defined in Data.SBV.Core.Kind Methods kindOf :: RoundingMode -> Kind Source # hasSign :: RoundingMode -> Bool Source # intSizeOf :: RoundingMode -> Int Source # isBoolean :: RoundingMode -> Bool Source # isBounded :: RoundingMode -> Bool Source # isReal :: RoundingMode -> Bool Source # isFloat :: RoundingMode -> Bool Source # isDouble :: RoundingMode -> Bool Source # isRational :: RoundingMode -> Bool Source # isFP :: RoundingMode -> Bool Source # isUnbounded :: RoundingMode -> Bool Source # isUserSort :: RoundingMode -> Bool Source # isChar :: RoundingMode -> Bool Source # isString :: RoundingMode -> Bool Source # isList :: RoundingMode -> Bool Source # isSet :: RoundingMode -> Bool Source # isTuple :: RoundingMode -> Bool Source # isMaybe :: RoundingMode -> Bool Source # isEither :: RoundingMode -> Bool Source # isArray :: RoundingMode -> Bool Source # showType :: RoundingMode -> String Source # | |
| SatModel RoundingMode Source # | A rounding mode, extracted from a model. (Default definition suffices) |
Defined in Data.SBV.SMT.SMT | |
A signed bit-vector carrying its size info
Instances
| KnownNat n => Arbitrary (IntN n) Source # | Quickcheck instance for IntN | ||||
| (KnownNat n, BVIsNonZero n) => Bits (IntN n) Source # | |||||
Defined in Data.SBV.Core.Sized Methods (.&.) :: IntN n -> IntN n -> IntN n # (.|.) :: IntN n -> IntN n -> IntN n # xor :: IntN n -> IntN n -> IntN n # complement :: IntN n -> IntN n # shift :: IntN n -> Int -> IntN n # rotate :: IntN n -> Int -> IntN n # setBit :: IntN n -> Int -> IntN n # clearBit :: IntN n -> Int -> IntN n # complementBit :: IntN n -> Int -> IntN n # testBit :: IntN n -> Int -> Bool # bitSizeMaybe :: IntN n -> Maybe Int # shiftL :: IntN n -> Int -> IntN n # unsafeShiftL :: IntN n -> Int -> IntN n # shiftR :: IntN n -> Int -> IntN n # unsafeShiftR :: IntN n -> Int -> IntN n # rotateL :: IntN n -> Int -> IntN n # | |||||
| (KnownNat n, BVIsNonZero n) => Bounded (IntN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Enum (IntN n) Source # | |||||
Defined in Data.SBV.Core.Sized | |||||
| KnownNat n => Num (SInt n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Num (IntN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Integral (IntN n) Source # | |||||
Defined in Data.SBV.Core.Sized | |||||
| (KnownNat n, BVIsNonZero n) => Real (IntN n) Source # | |||||
Defined in Data.SBV.Core.Sized Methods toRational :: IntN n -> Rational # | |||||
| Show (IntN n) Source # | Show instance for | ||||
| Eq (IntN n) Source # | |||||
| Ord (IntN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => SymVal (IntN n) Source # | |||||
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (IntN n)) Source # literal :: IntN n -> SBV (IntN n) Source # fromCV :: CV -> IntN n Source # isConcretely :: SBV (IntN n) -> (IntN n -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (IntN n)) Source # free_ :: MonadSymbolic m => m (SBV (IntN n)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (IntN n)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (IntN n)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (IntN n)] Source # unliteral :: SBV (IntN n) -> Maybe (IntN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => HasKind (IntN n) Source # |
| ||||
Defined in Data.SBV.Core.Sized Methods kindOf :: IntN n -> Kind Source # hasSign :: IntN n -> Bool Source # intSizeOf :: IntN n -> Int Source # isBoolean :: IntN n -> Bool Source # isBounded :: IntN n -> Bool Source # isReal :: IntN n -> Bool Source # isFloat :: IntN n -> Bool Source # isDouble :: IntN n -> Bool Source # isRational :: IntN n -> Bool Source # isFP :: IntN n -> Bool Source # isUnbounded :: IntN n -> Bool Source # isUserSort :: IntN n -> Bool Source # isChar :: IntN n -> Bool Source # isString :: IntN n -> Bool Source # isList :: IntN n -> Bool Source # isSet :: IntN n -> Bool Source # isTuple :: IntN n -> Bool Source # isMaybe :: IntN n -> Bool Source # isEither :: IntN n -> Bool Source # | |||||
| (KnownNat n, BVIsNonZero n) => Metric (IntN n) Source # | Optimizing | ||||
Defined in Data.SBV.Core.Model Associated Types
Methods toMetricSpace :: SBV (IntN n) -> SBV (MetricSpace (IntN n)) Source # fromMetricSpace :: SBV (MetricSpace (IntN n)) -> SBV (IntN n) Source # annotateForMS :: Proxy (IntN n) -> String -> String Source # msMinimize :: (MonadSymbolic m, SolverContext m) => String -> SBV (IntN n) -> m () Source # msMaximize :: (MonadSymbolic m, SolverContext m) => String -> SBV (IntN n) -> m () Source # | |||||
| (KnownNat n, BVIsNonZero n) => SDivisible (SInt n) Source # |
| ||||
Defined in Data.SBV.Core.Model | |||||
| (KnownNat n, BVIsNonZero n) => SDivisible (IntN n) Source # |
| ||||
Defined in Data.SBV.Core.Model | |||||
| (KnownNat n, BVIsNonZero n) => SFiniteBits (IntN n) Source # | |||||
Defined in Data.SBV.Core.Model Methods sFiniteBitSize :: SBV (IntN n) -> Int Source # lsb :: SBV (IntN n) -> SBool Source # msb :: SBV (IntN n) -> SBool Source # blastBE :: SBV (IntN n) -> [SBool] Source # blastLE :: SBV (IntN n) -> [SBool] Source # fromBitsBE :: [SBool] -> SBV (IntN n) Source # fromBitsLE :: [SBool] -> SBV (IntN n) Source # sTestBit :: SBV (IntN n) -> Int -> SBool Source # sExtractBits :: SBV (IntN n) -> [Int] -> [SBool] Source # sPopCount :: SBV (IntN n) -> SWord8 Source # setBitTo :: SBV (IntN n) -> Int -> SBool -> SBV (IntN n) Source # sSetBitTo :: SBV (IntN n) -> SBV (IntN n) -> SBool -> SBV (IntN n) Source # fullAdder :: SBV (IntN n) -> SBV (IntN n) -> (SBool, SBV (IntN n)) Source # fullMultiplier :: SBV (IntN n) -> SBV (IntN n) -> (SBV (IntN n), SBV (IntN n)) Source # | |||||
| (KnownNat n, BVIsNonZero n) => SIntegral (IntN n) Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| (KnownNat n, BVIsNonZero n) => SatModel (IntN n) Source # | Constructing models for | ||||
| (KnownNat n, BVIsNonZero n) => ArithOverflow (SInt n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => CheckedArithmetic (IntN n) Source # | |||||
| type MetricSpace (IntN n) Source # | |||||
Defined in Data.SBV.Core.Model | |||||
data WordN (n :: Nat) Source #
An unsigned bit-vector carrying its size info
Instances
| KnownNat n => Arbitrary (WordN n) Source # | Quickcheck instance for WordN | ||||
| (KnownNat n, BVIsNonZero n) => Bits (WordN n) Source # | |||||
Defined in Data.SBV.Core.Sized Methods (.&.) :: WordN n -> WordN n -> WordN n # (.|.) :: WordN n -> WordN n -> WordN n # xor :: WordN n -> WordN n -> WordN n # complement :: WordN n -> WordN n # shift :: WordN n -> Int -> WordN n # rotate :: WordN n -> Int -> WordN n # setBit :: WordN n -> Int -> WordN n # clearBit :: WordN n -> Int -> WordN n # complementBit :: WordN n -> Int -> WordN n # testBit :: WordN n -> Int -> Bool # bitSizeMaybe :: WordN n -> Maybe Int # shiftL :: WordN n -> Int -> WordN n # unsafeShiftL :: WordN n -> Int -> WordN n # shiftR :: WordN n -> Int -> WordN n # unsafeShiftR :: WordN n -> Int -> WordN n # rotateL :: WordN n -> Int -> WordN n # | |||||
| (KnownNat n, BVIsNonZero n) => Bounded (WordN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Enum (WordN n) Source # | |||||
| KnownNat n => Num (SWord n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Num (WordN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Integral (WordN n) Source # | |||||
Defined in Data.SBV.Core.Sized | |||||
| (KnownNat n, BVIsNonZero n) => Real (WordN n) Source # | |||||
Defined in Data.SBV.Core.Sized Methods toRational :: WordN n -> Rational # | |||||
| Show (WordN n) Source # | Show instance for | ||||
| Eq (WordN n) Source # | |||||
| Ord (WordN n) Source # | |||||
| ByteConverter (SWord 8) Source # |
| ||||
| ByteConverter (SWord 16) Source # |
| ||||
| ByteConverter (SWord 32) Source # |
| ||||
| ByteConverter (SWord 64) Source # |
| ||||
| ByteConverter (SWord 128) Source # |
| ||||
| ByteConverter (SWord 256) Source # |
| ||||
| ByteConverter (SWord 512) Source # |
| ||||
| ByteConverter (SWord 1024) Source # |
| ||||
| (KnownNat n, BVIsNonZero n) => SymVal (WordN n) Source # | |||||
Defined in Data.SBV.Core.Model Methods mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV (WordN n)) Source # literal :: WordN n -> SBV (WordN n) Source # fromCV :: CV -> WordN n Source # isConcretely :: SBV (WordN n) -> (WordN n -> Bool) -> Bool Source # free :: MonadSymbolic m => String -> m (SBV (WordN n)) Source # free_ :: MonadSymbolic m => m (SBV (WordN n)) Source # mkFreeVars :: MonadSymbolic m => Int -> m [SBV (WordN n)] Source # symbolic :: MonadSymbolic m => String -> m (SBV (WordN n)) Source # symbolics :: MonadSymbolic m => [String] -> m [SBV (WordN n)] Source # unliteral :: SBV (WordN n) -> Maybe (WordN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => HasKind (WordN n) Source # |
| ||||
Defined in Data.SBV.Core.Sized Methods kindOf :: WordN n -> Kind Source # hasSign :: WordN n -> Bool Source # intSizeOf :: WordN n -> Int Source # isBoolean :: WordN n -> Bool Source # isBounded :: WordN n -> Bool Source # isReal :: WordN n -> Bool Source # isFloat :: WordN n -> Bool Source # isDouble :: WordN n -> Bool Source # isRational :: WordN n -> Bool Source # isFP :: WordN n -> Bool Source # isUnbounded :: WordN n -> Bool Source # isUserSort :: WordN n -> Bool Source # isChar :: WordN n -> Bool Source # isString :: WordN n -> Bool Source # isList :: WordN n -> Bool Source # isSet :: WordN n -> Bool Source # isTuple :: WordN n -> Bool Source # isMaybe :: WordN n -> Bool Source # isEither :: WordN n -> Bool Source # | |||||
| (KnownNat n, BVIsNonZero n) => Metric (WordN n) Source # | Optimizing | ||||
Defined in Data.SBV.Core.Model Associated Types
Methods toMetricSpace :: SBV (WordN n) -> SBV (MetricSpace (WordN n)) Source # fromMetricSpace :: SBV (MetricSpace (WordN n)) -> SBV (WordN n) Source # annotateForMS :: Proxy (WordN n) -> String -> String Source # msMinimize :: (MonadSymbolic m, SolverContext m) => String -> SBV (WordN n) -> m () Source # msMaximize :: (MonadSymbolic m, SolverContext m) => String -> SBV (WordN n) -> m () Source # | |||||
| (KnownNat n, BVIsNonZero n) => SDivisible (SWord n) Source # |
| ||||
| (KnownNat n, BVIsNonZero n) => SDivisible (WordN n) Source # |
| ||||
| (KnownNat n, BVIsNonZero n) => SFiniteBits (WordN n) Source # | |||||
Defined in Data.SBV.Core.Model Methods sFiniteBitSize :: SBV (WordN n) -> Int Source # lsb :: SBV (WordN n) -> SBool Source # msb :: SBV (WordN n) -> SBool Source # blastBE :: SBV (WordN n) -> [SBool] Source # blastLE :: SBV (WordN n) -> [SBool] Source # fromBitsBE :: [SBool] -> SBV (WordN n) Source # fromBitsLE :: [SBool] -> SBV (WordN n) Source # sTestBit :: SBV (WordN n) -> Int -> SBool Source # sExtractBits :: SBV (WordN n) -> [Int] -> [SBool] Source # sPopCount :: SBV (WordN n) -> SWord8 Source # setBitTo :: SBV (WordN n) -> Int -> SBool -> SBV (WordN n) Source # sSetBitTo :: SBV (WordN n) -> SBV (WordN n) -> SBool -> SBV (WordN n) Source # fullAdder :: SBV (WordN n) -> SBV (WordN n) -> (SBool, SBV (WordN n)) Source # fullMultiplier :: SBV (WordN n) -> SBV (WordN n) -> (SBV (WordN n), SBV (WordN n)) Source # | |||||
| (KnownNat n, BVIsNonZero n) => SIntegral (WordN n) Source # | |||||
Defined in Data.SBV.Core.Model | |||||
| (KnownNat n, BVIsNonZero n) => SatModel (WordN n) Source # | Constructing models for | ||||
| (KnownNat n, BVIsNonZero n) => ArithOverflow (SWord n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => CheckedArithmetic (WordN n) Source # | |||||
| (KnownNat n, BVIsNonZero n) => Polynomial (SWord n) Source # | |||||
Defined in Data.SBV.Tools.Polynomial Methods polynomial :: [Int] -> SWord n Source # pAdd :: SWord n -> SWord n -> SWord n Source # pMult :: (SWord n, SWord n, [Int]) -> SWord n Source # pDiv :: SWord n -> SWord n -> SWord n Source # pMod :: SWord n -> SWord n -> SWord n Source # pDivMod :: SWord n -> SWord n -> (SWord n, SWord n) Source # | |||||
| type MetricSpace (WordN n) Source # | |||||
Defined in Data.SBV.Core.Model | |||||
We implement a peculiar caching mechanism, applicable to the use case in implementation of SBV's. Whenever we do a state based computation, we do not want to keep on evaluating it in the then-current state. That will produce essentially a semantically equivalent value. Thus, we want to run it only once, and reuse that result, capturing the sharing at the Haskell level. This is similar to the "type-safe observable sharing" work, but also takes into the account of how symbolic simulation executes.
See Andy Gill's type-safe observable sharing trick for the inspiration behind this technique: http://ku-fpg.github.io/files/Gill-09-TypeSafeReification.pdf
Note that this is *not* a general memo utility!
Floating point operations
Constructors
| FP_Cast Kind Kind SV | |
| FP_Reinterpret Kind Kind | |
| FP_Abs | |
| FP_Neg | |
| FP_Add | |
| FP_Sub | |
| FP_Mul | |
| FP_Div | |
| FP_FMA | |
| FP_Sqrt | |
| FP_Rem | |
| FP_RoundToIntegral | |
| FP_Min | |
| FP_Max | |
| FP_ObjEqual | |
| FP_IsNormal | |
| FP_IsSubnormal | |
| FP_IsZero | |
| FP_IsInfinite | |
| FP_IsNaN | |
| FP_IsNegative | |
| FP_IsPositive |
Instances
| NFData FPOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data FPOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FPOp -> c FPOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FPOp # dataTypeOf :: FPOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FPOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FPOp) # gmapT :: (forall b. Data b => b -> b) -> FPOp -> FPOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FPOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FPOp -> r # gmapQ :: (forall d. Data d => d -> u) -> FPOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FPOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FPOp -> m FPOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FPOp -> m FPOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FPOp -> m FPOp # | |||||
| Generic FPOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show FPOp Source # | |||||
| Eq FPOp Source # | |||||
| Ord FPOp Source # | |||||
| type Rep FPOp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep FPOp = D1 ('MetaData "FPOp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) ((((C1 ('MetaCons "FP_Cast" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SV))) :+: C1 ('MetaCons "FP_Reinterpret" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Kind))) :+: (C1 ('MetaCons "FP_Abs" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_Neg" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_Add" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "FP_Sub" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_Mul" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_Div" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "FP_FMA" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_Sqrt" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_Rem" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "FP_RoundToIntegral" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_Min" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FP_Max" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_ObjEqual" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_IsNormal" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "FP_IsSubnormal" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_IsZero" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_IsInfinite" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "FP_IsNaN" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FP_IsNegative" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FP_IsPositive" 'PrefixI 'False) (U1 :: Type -> Type)))))) | |||||
Configuration for KnuckleDragger
Constructors
| KDOptions | |
Fields
| |
data NamedSymVar Source #
NamedSymVar pairs symbolic values and user given/automatically generated names
Constructors
| NamedSymVar !SV !Name |
Instances
| NFData NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods rnf :: NamedSymVar -> () # | |||||
| Data NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NamedSymVar -> c NamedSymVar # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NamedSymVar # toConstr :: NamedSymVar -> Constr # dataTypeOf :: NamedSymVar -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NamedSymVar) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NamedSymVar) # gmapT :: (forall b. Data b => b -> b) -> NamedSymVar -> NamedSymVar # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NamedSymVar -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NamedSymVar -> r # gmapQ :: (forall d. Data d => d -> u) -> NamedSymVar -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NamedSymVar -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NamedSymVar -> m NamedSymVar # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NamedSymVar -> m NamedSymVar # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NamedSymVar -> m NamedSymVar # | |||||
| Generic NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> NamedSymVar -> ShowS # show :: NamedSymVar -> String # showList :: [NamedSymVar] -> ShowS # | |||||
| Eq NamedSymVar Source # | For comparison purposes, we simply use the SV and ignore the name | ||||
Defined in Data.SBV.Core.Symbolic | |||||
| Ord NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods compare :: NamedSymVar -> NamedSymVar -> Ordering # (<) :: NamedSymVar -> NamedSymVar -> Bool # (<=) :: NamedSymVar -> NamedSymVar -> Bool # (>) :: NamedSymVar -> NamedSymVar -> Bool # (>=) :: NamedSymVar -> NamedSymVar -> Bool # max :: NamedSymVar -> NamedSymVar -> NamedSymVar # min :: NamedSymVar -> NamedSymVar -> NamedSymVar # | |||||
| type Rep NamedSymVar Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
A symbolic node id
Instances
| Data NodeId Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NodeId -> c NodeId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NodeId # toConstr :: NodeId -> Constr # dataTypeOf :: NodeId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NodeId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NodeId) # gmapT :: (forall b. Data b => b -> b) -> NodeId -> NodeId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NodeId -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NodeId -> r # gmapQ :: (forall d. Data d => d -> u) -> NodeId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NodeId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId # | |
| Eq NodeId Source # | |
| Ord NodeId Source # | |
Objective of optimization. We can minimize, maximize, or give a soft assertion with a penalty for not satisfying it.
Constructors
| Minimize String a | Minimize this metric |
| Maximize String a | Maximize this metric |
| AssertWithPenalty String a Penalty | A soft assertion, with an associated penalty |
Symbolic operations
Constructors
| Plus | |
| Times | |
| Minus | |
| UNeg | |
| Abs | |
| Quot | |
| Rem | |
| Equal | |
| Implies | |
| NotEqual | |
| LessThan | |
| GreaterThan | |
| LessEq | |
| GreaterEq | |
| Ite | |
| And | |
| Or | |
| XOr | |
| Not | |
| Shl | |
| Shr | |
| Rol Int | |
| Ror Int | |
| Divides Integer | |
| Extract Int Int | |
| Join | |
| ZeroExtend Int | |
| SignExtend Int | |
| LkUp (Int, Kind, Kind, Int) !SV !SV | |
| KindCast Kind Kind | |
| Uninterpreted String | |
| QuantifiedBool String | |
| SpecialRelOp Kind SpecialRelOp | |
| Label String | |
| IEEEFP FPOp | |
| NonLinear NROp | |
| OverflowOp OvOp | |
| PseudoBoolean PBOp | |
| RegExOp RegExOp | |
| StrOp StrOp | |
| SeqOp SeqOp | |
| SetOp SetOp | |
| TupleConstructor Int | |
| TupleAccess Int Int | |
| EitherConstructor Kind Kind Bool | |
| EitherIs Kind Kind Bool | |
| EitherAccess Bool | |
| RationalConstructor | |
| MaybeConstructor Kind Bool | |
| MaybeIs Kind Bool | |
| MaybeAccess | |
| ArrayLambda SMTLambda | |
| ReadArray | |
| WriteArray |
Instances
| NFData Op Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data Op Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Op -> c Op # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Op # dataTypeOf :: Op -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Op) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Op) # gmapT :: (forall b. Data b => b -> b) -> Op -> Op # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r # gmapQ :: (forall d. Data d => d -> u) -> Op -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Op -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Op -> m Op # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op # | |
| Generic Op Source # | |
| Show Op Source # | |
| Eq Op Source # | |
| Ord Op Source # | |
| type Rep Op Source # | |
Defined in Data.SBV.Core.Symbolic | |
data OptimizeStyle Source #
Style of optimization. Note that in the pareto case the user is allowed
to specify a max number of fronts to query the solver for, since there might
potentially be an infinite number of them and there is no way to know exactly
how many ahead of time. If Nothing is given, SBV will possibly loop forever
if the number is really infinite.
Constructors
| Lexicographic | Objectives are optimized in the order given, earlier objectives have higher priority. |
| Independent | Each objective is optimized independently. |
| Pareto (Maybe Int) | Objectives are optimized according to pareto front: That is, no objective can be made better without making some other worse. |
Instances
| NFData OptimizeStyle Source # | |
Defined in Data.SBV.Core.Symbolic Methods rnf :: OptimizeStyle -> () # | |
| Show OptimizeStyle Source # | |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> OptimizeStyle -> ShowS # show :: OptimizeStyle -> String # showList :: [OptimizeStyle] -> ShowS # | |
| Eq OptimizeStyle Source # | |
Defined in Data.SBV.Core.Symbolic Methods (==) :: OptimizeStyle -> OptimizeStyle -> Bool # (/=) :: OptimizeStyle -> OptimizeStyle -> Bool # | |
Overflow operations
Constructors
| PlusOv Bool | Addition overflow. Bool is True if signed. |
| SubOv Bool | Subtraction overflow. Bool is True if signed. |
| MulOv Bool | Multiplication overflow. Bool is True if signed. |
| DivOv | Division overflow. Only signed, since unsigned division does not overflow. |
| NegOv | Unary negation overflow. Only signed, since unsigned negation does not overflow. |
Instances
| NFData OvOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data OvOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OvOp -> c OvOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OvOp # dataTypeOf :: OvOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OvOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OvOp) # gmapT :: (forall b. Data b => b -> b) -> OvOp -> OvOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OvOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OvOp -> r # gmapQ :: (forall d. Data d => d -> u) -> OvOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OvOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OvOp -> m OvOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OvOp -> m OvOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OvOp -> m OvOp # | |||||
| Generic OvOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show OvOp Source # | Show instance. It's important that these follow the SMTLib names. | ||||
| Eq OvOp Source # | |||||
| Ord OvOp Source # | |||||
| type Rep OvOp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep OvOp = D1 ('MetaData "OvOp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) ((C1 ('MetaCons "PlusOv" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "SubOv" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool))) :+: (C1 ('MetaCons "MulOv" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: (C1 ('MetaCons "DivOv" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NegOv" 'PrefixI 'False) (U1 :: Type -> Type)))) | |||||
Pseudo-boolean operations
Constructors
| PB_AtMost Int | At most k |
| PB_AtLeast Int | At least k |
| PB_Exactly Int | Exactly k |
| PB_Le [Int] Int | At most k, with coefficients given. Generalizes PB_AtMost |
| PB_Ge [Int] Int | At least k, with coefficients given. Generalizes PB_AtLeast |
| PB_Eq [Int] Int | Exactly k, with coefficients given. Generalized PB_Exactly |
Instances
| NFData PBOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data PBOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PBOp -> c PBOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PBOp # dataTypeOf :: PBOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PBOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PBOp) # gmapT :: (forall b. Data b => b -> b) -> PBOp -> PBOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PBOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PBOp -> r # gmapQ :: (forall d. Data d => d -> u) -> PBOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PBOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PBOp -> m PBOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PBOp -> m PBOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PBOp -> m PBOp # | |||||
| Generic PBOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show PBOp Source # | |||||
| Eq PBOp Source # | |||||
| Ord PBOp Source # | |||||
| type Rep PBOp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep PBOp = D1 ('MetaData "PBOp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) ((C1 ('MetaCons "PB_AtMost" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: (C1 ('MetaCons "PB_AtLeast" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "PB_Exactly" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))) :+: (C1 ('MetaCons "PB_Le" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: (C1 ('MetaCons "PB_Ge" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "PB_Eq" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) | |||||
Penalty for a soft-assertion. The default penalty is 1, with all soft-assertions belonging
to the same objective goal. A positive weight and an optional group can be provided by using
the Penalty constructor.
Constructors
| DefaultPenalty | Default: Penalty of |
| Penalty Rational (Maybe String) | Penalty with a weight and an optional group |
data Quantifier Source #
Quantifiers: forall or exists. Note that we allow arbitrary nestings.
Instances
| NFData Quantifier Source # | |
Defined in Data.SBV.Core.Symbolic Methods rnf :: Quantifier -> () # | |
| Data Quantifier Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Quantifier -> c Quantifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Quantifier # toConstr :: Quantifier -> Constr # dataTypeOf :: Quantifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Quantifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Quantifier) # gmapT :: (forall b. Data b => b -> b) -> Quantifier -> Quantifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Quantifier -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Quantifier -> r # gmapQ :: (forall d. Data d => d -> u) -> Quantifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Quantifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Quantifier -> m Quantifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Quantifier -> m Quantifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Quantifier -> m Quantifier # | |
| Show Quantifier Source # | Show instance for |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> Quantifier -> ShowS # show :: Quantifier -> String # showList :: [Quantifier] -> ShowS # | |
| Eq Quantifier Source # | |
Defined in Data.SBV.Core.Symbolic | |
data QueryState Source #
The state we keep track of as we interact with the solver
Constructors
| QueryState | |
Fields
| |
newtype QueryT (m :: Type -> Type) a Source #
A query is a user-guided mechanism to directly communicate and extract
results from the solver. A generalization of Query.
Instances
| MonadSymbolic Query Source # | |
Defined in Data.SBV.Core.Symbolic Methods symbolicEnv :: Query State Source # | |
| MonadTrans QueryT Source # | |
Defined in Data.SBV.Core.Symbolic | |
| MonadError e m => MonadError e (QueryT m) Source # | |
Defined in Data.SBV.Core.Symbolic | |
| MonadReader r m => MonadReader r (QueryT m) Source # | |
| MonadState s m => MonadState s (QueryT m) Source # | |
| MonadWriter w m => MonadWriter w (QueryT m) Source # | |
| Applicative m => Applicative (QueryT m) Source # | |
| Functor m => Functor (QueryT m) Source # | |
| Monad m => Monad (QueryT m) Source # | |
| MonadIO m => MonadIO (QueryT m) Source # | |
Defined in Data.SBV.Core.Symbolic | |
| MonadIO m => SolverContext (QueryT m) Source # |
|
Defined in Data.SBV.Control.Utils Methods constrain :: QuantifiedBool a => a -> QueryT m () Source # softConstrain :: QuantifiedBool a => a -> QueryT m () Source # namedConstraint :: QuantifiedBool a => String -> a -> QueryT m () Source # constrainWithAttribute :: QuantifiedBool a => [(String, String)] -> a -> QueryT m () Source # setInfo :: String -> [String] -> QueryT m () Source # setOption :: SMTOption -> QueryT m () Source # setLogic :: Logic -> QueryT m () Source # setTimeOut :: Integer -> QueryT m () Source # contextState :: QueryT m State Source # | |
| Monad m => MonadQuery (QueryT m) Source # | |
Defined in Data.SBV.Core.Symbolic Methods queryState :: QueryT m State Source # | |
Regular-expression operators. The only thing we can do is to compare for equality/disequality.
Instances
| NFData RegExOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data RegExOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RegExOp -> c RegExOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RegExOp # toConstr :: RegExOp -> Constr # dataTypeOf :: RegExOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RegExOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RegExOp) # gmapT :: (forall b. Data b => b -> b) -> RegExOp -> RegExOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RegExOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RegExOp -> r # gmapQ :: (forall d. Data d => d -> u) -> RegExOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RegExOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RegExOp -> m RegExOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RegExOp -> m RegExOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RegExOp -> m RegExOp # | |||||
| Generic RegExOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show RegExOp Source # | Show instance for | ||||
| Eq RegExOp Source # | |||||
| Ord RegExOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| type Rep RegExOp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep RegExOp = D1 ('MetaData "RegExOp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) (C1 ('MetaCons "RegExEq" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)) :+: C1 ('MetaCons "RegExNEq" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp))) | |||||
Regular expressions. Note that regular expressions themselves are
concrete, but the match function from the RegExpMatchable class
can check membership against a symbolic string/character. Also, we
are preferring a datatype approach here, as opposed to coming up with
some string-representation; there are way too many alternatives
already so inventing one isn't a priority. Please get in touch if you
would like a parser for this type as it might be easier to use.
Constructors
| Literal String | Precisely match the given string |
| All | Accept every string |
| AllChar | Accept every single character |
| None | Accept no strings |
| Range Char Char | Accept range of characters |
| Conc [RegExp] | Concatenation |
| KStar RegExp | Kleene Star: Zero or more |
| KPlus RegExp | Kleene Plus: One or more |
| Opt RegExp | Zero or one |
| Comp RegExp | Complement of regular expression |
| Diff RegExp RegExp | Difference of regular expressions |
| Loop Int Int RegExp | From |
| Power Int RegExp | Exactly |
| Union [RegExp] | Union of regular expressions |
| Inter RegExp RegExp | Intersection of regular expressions |
Instances
| NFData RegExp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data RegExp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RegExp -> c RegExp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RegExp # toConstr :: RegExp -> Constr # dataTypeOf :: RegExp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RegExp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RegExp) # gmapT :: (forall b. Data b => b -> b) -> RegExp -> RegExp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RegExp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RegExp -> r # gmapQ :: (forall d. Data d => d -> u) -> RegExp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RegExp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RegExp -> m RegExp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RegExp -> m RegExp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RegExp -> m RegExp # | |||||
| IsString RegExp Source # | With overloaded strings, we can have direct literal regular expressions. | ||||
Defined in Data.SBV.Core.Symbolic Methods fromString :: String -> RegExp # | |||||
| Generic RegExp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Num RegExp Source # | Regular expressions as a | ||||
| Show RegExp Source # | Convert a reg-exp to a Haskell-like string | ||||
| Eq RegExp Source # | |||||
| Ord RegExp Source # | |||||
| EqSymbolic RegExp Source # | Regular expressions can be compared for equality. Note that we diverge here from the equality in the concrete sense; i.e., the Eq instance does not match the symbolic case. This is a bit unfortunate, but unavoidable with the current design of how we "distinguish" operators. Hopefully shouldn't be a big deal, though one should be careful. | ||||
Defined in Data.SBV.Core.Model Methods (.==) :: RegExp -> RegExp -> SBool Source # (./=) :: RegExp -> RegExp -> SBool Source # (.===) :: RegExp -> RegExp -> SBool Source # (./==) :: RegExp -> RegExp -> SBool Source # distinct :: [RegExp] -> SBool Source # distinctExcept :: [RegExp] -> [RegExp] -> SBool Source # allEqual :: [RegExp] -> SBool Source # | |||||
| type Rep RegExp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep RegExp = D1 ('MetaData "RegExp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) (((C1 ('MetaCons "Literal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: (C1 ('MetaCons "All" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AllChar" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "None" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Range" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char))) :+: (C1 ('MetaCons "Conc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RegExp])) :+: C1 ('MetaCons "KStar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp))))) :+: (((C1 ('MetaCons "KPlus" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)) :+: C1 ('MetaCons "Opt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp))) :+: (C1 ('MetaCons "Comp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)) :+: C1 ('MetaCons "Diff" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)))) :+: ((C1 ('MetaCons "Loop" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp))) :+: C1 ('MetaCons "Power" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp))) :+: (C1 ('MetaCons "Union" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [RegExp])) :+: C1 ('MetaCons "Inter" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)))))) | |||||
Result of running a symbolic computation
Constructors
| Result | |
Fields
| |
Instances
| NFData Result Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data Result Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Result -> c Result # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Result # toConstr :: Result -> Constr # dataTypeOf :: Result -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Result) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Result) # gmapT :: (forall b. Data b => b -> b) -> Result -> Result # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Result -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Result -> r # gmapQ :: (forall d. Data d => d -> u) -> Result -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Result -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Result -> m Result # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Result -> m Result # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Result -> m Result # | |
| Show Result Source # | |
A symbolic expression
Instances
| NFData SBVExpr Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data SBVExpr Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SBVExpr -> c SBVExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SBVExpr # toConstr :: SBVExpr -> Constr # dataTypeOf :: SBVExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SBVExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SBVExpr) # gmapT :: (forall b. Data b => b -> b) -> SBVExpr -> SBVExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SBVExpr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SBVExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> SBVExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SBVExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SBVExpr -> m SBVExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVExpr -> m SBVExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVExpr -> m SBVExpr # | |
| Show SBVExpr Source # | |
| Eq SBVExpr Source # | |
| Ord SBVExpr Source # | |
Defined in Data.SBV.Core.Symbolic | |
A program is a sequence of assignments
Constructors
| SBVPgm | |
Fields
| |
Instances
| NFData SBVPgm Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data SBVPgm Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SBVPgm -> c SBVPgm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SBVPgm # toConstr :: SBVPgm -> Constr # dataTypeOf :: SBVPgm -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SBVPgm) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SBVPgm) # gmapT :: (forall b. Data b => b -> b) -> SBVPgm -> SBVPgm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SBVPgm -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SBVPgm -> r # gmapQ :: (forall d. Data d => d -> u) -> SBVPgm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SBVPgm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SBVPgm -> m SBVPgm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVPgm -> m SBVPgm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVPgm -> m SBVPgm # | |
data SBVRunMode Source #
Different means of running a symbolic piece of code
Constructors
| SMTMode QueryContext IStage Bool SMTConfig | In regular mode, with a stage. Bool is True if this is SAT. |
| CodeGen | Code generation mode. |
| LambdaGen (Maybe Int) | Inside a lambda-expression at level. If Nothing, then closed lambda. |
| Concrete (Maybe (Bool, [(NamedSymVar, CV)])) | Concrete simulation mode, with given environment if any. If Nothing: Random. |
Instances
| Show SBVRunMode Source # | |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> SBVRunMode -> ShowS # show :: SBVRunMode -> String # showList :: [SBVRunMode] -> ShowS # | |
A simple type for SBV computations, used mainly for uninterpreted constants. We keep track of the signedness/size of the arguments. A non-function will have just one entry in the list.
Instances
| NFData SBVType Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data SBVType Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SBVType -> c SBVType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SBVType # toConstr :: SBVType -> Constr # dataTypeOf :: SBVType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SBVType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SBVType) # gmapT :: (forall b. Data b => b -> b) -> SBVType -> SBVType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SBVType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SBVType -> r # gmapQ :: (forall d. Data d => d -> u) -> SBVType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SBVType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SBVType -> m SBVType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVType -> m SBVType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SBVType -> m SBVType # | |
| Show SBVType Source # | |
| Eq SBVType Source # | |
| Ord SBVType Source # | |
Defined in Data.SBV.Core.Symbolic | |
Solver configuration. See also z3, yices, cvc4, boolector, mathSAT, etc.
which are instantiations of this type for those solvers, with reasonable defaults. In particular, custom configuration can be
created by varying those values. (Such as z3{verbose=True}.)
Most fields are self explanatory. The notion of precision for printing algebraic reals stems from the fact that such values does
not necessarily have finite decimal representations, and hence we have to stop printing at some depth. It is important to
emphasize that such values always have infinite precision internally. The issue is merely with how we print such an infinite
precision value on the screen. The field printRealPrec controls the printing precision, by specifying the number of digits after
the decimal point. The default value is 16, but it can be set to any positive integer.
When printing, SBV will add the suffix ... at the end of a real-value, if the given bound is not sufficient to represent the real-value
exactly. Otherwise, the number will be written out in standard decimal notation. Note that SBV will always print the whole value if it
is precise (i.e., if it fits in a finite number of digits), regardless of the precision limit. The limit only applies if the representation
of the real value is not finite, i.e., if it is not rational.
The printBase field can be used to print numbers in base 2, 10, or 16.
The crackNum field can be used to display numbers in detail, all its bits and how they are laid out in memory. Works with all bounded number types
(i.e., SWord and SInt), but also with floats. It is particularly useful with floating-point numbers, as it shows you how they are laid out in
memory following the IEEE754 rules.
Constructors
| SMTConfig | |
Fields
| |
Representation of an SMT-Lib program. The second [String] are the function definitions, which is *replicated* in the first one. There are cases where that we need the second part on its own.
Constructors
| SMTLibPgm SMTLibVersion [String] [String] |
data SMTLibVersion Source #
Representation of SMTLib Program versions. As of June 2015, we're dropping support for SMTLib1, and supporting SMTLib2 only. We keep this data-type around in case SMTLib3 comes along and we want to support 2 and 3 simultaneously.
Constructors
| SMTLib2 |
Instances
| NFData SMTLibVersion Source # | |
Defined in Data.SBV.Core.Symbolic Methods rnf :: SMTLibVersion -> () # | |
| Bounded SMTLibVersion Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Enum SMTLibVersion Source # | |
Defined in Data.SBV.Core.Symbolic Methods succ :: SMTLibVersion -> SMTLibVersion # pred :: SMTLibVersion -> SMTLibVersion # toEnum :: Int -> SMTLibVersion # fromEnum :: SMTLibVersion -> Int # enumFrom :: SMTLibVersion -> [SMTLibVersion] # enumFromThen :: SMTLibVersion -> SMTLibVersion -> [SMTLibVersion] # enumFromTo :: SMTLibVersion -> SMTLibVersion -> [SMTLibVersion] # enumFromThenTo :: SMTLibVersion -> SMTLibVersion -> SMTLibVersion -> [SMTLibVersion] # | |
| Show SMTLibVersion Source # | |
Defined in Data.SBV.Core.Symbolic Methods showsPrec :: Int -> SMTLibVersion -> ShowS # show :: SMTLibVersion -> String # showList :: [SMTLibVersion] -> ShowS # | |
| Eq SMTLibVersion Source # | |
Defined in Data.SBV.Core.Symbolic Methods (==) :: SMTLibVersion -> SMTLibVersion -> Bool # (/=) :: SMTLibVersion -> SMTLibVersion -> Bool # | |
A model, as returned by a solver
Constructors
| SMTModel | |
Fields
| |
The result of an SMT solver call. Each constructor is tagged with
the SMTConfig that created it so that further tools can inspect it
and build layers of results, if needed. For ordinary uses of the library,
this type should not be needed, instead use the accessor functions on
it. (Custom Show instances and model extractors.)
Constructors
| Unsatisfiable SMTConfig (Maybe [String]) | Unsatisfiable. If unsat-cores are enabled, they will be returned in the second parameter. |
| Satisfiable SMTConfig SMTModel | Satisfiable with model |
| DeltaSat SMTConfig (Maybe String) SMTModel | Delta satisfiable with queried string if available and model |
| SatExtField SMTConfig SMTModel | Prover returned a model, but in an extension field containing Infinite/epsilon |
| Unknown SMTConfig SMTReasonUnknown | Prover returned unknown, with the given reason |
| ProofError SMTConfig [String] (Maybe SMTResult) | Prover errored out, with possibly a bogus result |
Instances
| NFData SMTResult Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Modelable SMTResult Source # |
|
Defined in Data.SBV.SMT.SMT Methods modelExists :: SMTResult -> Bool Source # getModelAssignment :: SatModel b => SMTResult -> Either String (Bool, b) Source # getModelDictionary :: SMTResult -> Map String CV Source # getModelValue :: SymVal b => String -> SMTResult -> Maybe b Source # getModelUninterpretedValue :: String -> SMTResult -> Maybe String Source # extractModel :: SatModel b => SMTResult -> Maybe b Source # getModelObjectives :: SMTResult -> Map String GeneralizedCV Source # getModelObjectiveValue :: String -> SMTResult -> Maybe GeneralizedCV Source # getModelUIFuns :: SMTResult -> Map String (Bool, SBVType, Either String ([([CV], CV)], CV)) Source # getModelUIFunValue :: String -> SMTResult -> Maybe (Bool, SBVType, Either String ([([CV], CV)], CV)) Source # | |
A script, to be passed to the solver.
Constructors
| SMTScript | |
Fields
| |
An SMT solver
Constructors
| SMTSolver | |
Fields
| |
A symbolic word, tracking its kind and node representing it
Instances
| NFData SV Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data SV Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SV -> c SV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SV # dataTypeOf :: SV -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SV) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SV) # gmapT :: (forall b. Data b => b -> b) -> SV -> SV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SV -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SV -> r # gmapQ :: (forall d. Data d => d -> u) -> SV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SV -> m SV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SV -> m SV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SV -> m SV # | |
| Show SV Source # | |
| Eq SV Source # | For equality, we merely use the lambda-level/node-id |
| Ord SV Source # | Again, simply use the lambda-level/node-id for ordering |
| HasKind SV Source # | |
Defined in Data.SBV.Core.Symbolic Methods hasSign :: SV -> Bool Source # intSizeOf :: SV -> Int Source # isBoolean :: SV -> Bool Source # isBounded :: SV -> Bool Source # isFloat :: SV -> Bool Source # isDouble :: SV -> Bool Source # isRational :: SV -> Bool Source # isUnbounded :: SV -> Bool Source # isUserSort :: SV -> Bool Source # isString :: SV -> Bool Source # isTuple :: SV -> Bool Source # isMaybe :: SV -> Bool Source # isEither :: SV -> Bool Source # | |
The Symbolic value. Either a constant (Left) or a symbolic
value (Right Cached). Note that caching is essential for making
sure sharing is preserved.
Instances
| NFData SVal Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Show SVal Source # | |
| Eq SVal Source # | This instance is only defined so that we can define an instance for
|
| HasKind SVal Source # | |
Defined in Data.SBV.Core.Symbolic Methods kindOf :: SVal -> Kind Source # hasSign :: SVal -> Bool Source # intSizeOf :: SVal -> Int Source # isBoolean :: SVal -> Bool Source # isBounded :: SVal -> Bool Source # isReal :: SVal -> Bool Source # isFloat :: SVal -> Bool Source # isDouble :: SVal -> Bool Source # isRational :: SVal -> Bool Source # isUnbounded :: SVal -> Bool Source # isUserSort :: SVal -> Bool Source # isChar :: SVal -> Bool Source # isString :: SVal -> Bool Source # isList :: SVal -> Bool Source # isSet :: SVal -> Bool Source # isTuple :: SVal -> Bool Source # isMaybe :: SVal -> Bool Source # isEither :: SVal -> Bool Source # | |
| ArithOverflow SVal Source # | |
| Testable (Symbolic SVal) Source # | |
Sequence operations.
Constructors
| SeqConcat | See StrConcat |
| SeqLen | See StrLen |
| SeqUnit | See StrUnit |
| SeqNth | See StrNth |
| SeqSubseq | See StrSubseq |
| SeqIndexOf | See StrIndexOf |
| SeqContains | See StrContains |
| SeqPrefixOf | See StrPrefixOf |
| SeqSuffixOf | See StrSuffixOf |
| SeqReplace | See StrReplace Polymorphic and higher order functions |
| SBVReverse Kind | reverse k. Where k is either [a] or String. Reverses the argument, accordingly. |
| SBVZip Kind Kind | zip a b. Where we zip [a] and [b] to produce [(a, b)] |
| SBVZipWith Kind Kind Kind SMTLambda | zipWith a b c fun. Where fun :: a -> b -> c, and zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] |
| SBVPartition Kind SMTLambda | partition a fun. Where fun :: a -> SBool, and partition :: (a -> Bool) -> [a] -> ([a], [a]) |
| SBVMap Kind Kind SMTLambda | map a b fun. Where fun :: a -> b, and map :: (a -> b) -> [a] -> [b] |
| SBVFoldl Kind Kind SMTLambda | foldl a b fun. Where fun :: b -> a -> b, and foldl :: (b -> a -> b) -> b -> [a] -> b |
| SBVFoldr Kind Kind SMTLambda | foldr a b fun. Where fun :: a -> b -> b, and foldr :: (a -> b -> b) -> b -> [a] -> b |
| SBVFilter Kind SMTLambda | filter a fun. Where fun :: a -> Bool, and filter :: (a -> Bool) -> [a] -> [a] |
| SBVAll Kind SMTLambda | all a fun. Where fun :: a -> Bool, and all :: (a -> Bool) -> [a] -> Bool |
| SBVAny Kind SMTLambda | any a fun. Where fun :: a -> Bool, and any :: (a -> Bool) -> [a] -> Bool |
| SBVConcat Kind | concat a. Where we concat [[a]] to get [a] (a is the inside-element type) |
Instances
| NFData SeqOp Source # | |
Defined in Data.SBV.Core.Symbolic | |
| Data SeqOp Source # | |
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SeqOp -> c SeqOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SeqOp # dataTypeOf :: SeqOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SeqOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SeqOp) # gmapT :: (forall b. Data b => b -> b) -> SeqOp -> SeqOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SeqOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SeqOp -> r # gmapQ :: (forall d. Data d => d -> u) -> SeqOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SeqOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SeqOp -> m SeqOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SeqOp -> m SeqOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SeqOp -> m SeqOp # | |
| Generic SeqOp Source # | |
| Show SeqOp Source # | Show instance for SeqOp. Again, mapping is important. |
| Eq SeqOp Source # | |
| Ord SeqOp Source # | |
| type Rep SeqOp Source # | |
Defined in Data.SBV.Core.Symbolic | |
Solvers that SBV is aware of
data SolverCapabilities Source #
Translation tricks needed for specific capabilities afforded by each solver
Constructors
| SolverCapabilities | |
Fields
| |
The state of the symbolic interpreter
String operations. Note that we do not define StrAt as it translates to StrSubstr trivially.
Constructors
| StrConcat | Concatenation of one or more strings |
| StrLen | String length |
| StrUnit | Unit string |
| StrNth | Nth element |
| StrSubstr | Retrieves substring of |
| StrIndexOf | Retrieves first position of |
| StrContains | Does |
| StrPrefixOf | Is |
| StrSuffixOf | Is |
| StrReplace | Replace the first occurrence of |
| StrStrToNat | Retrieve integer encoded by string |
| StrNatToStr | Retrieve string encoded by integer |
| StrToCode | Equivalent to Haskell's ord |
| StrFromCode | Equivalent to Haskell's chr |
| StrInRe RegExp | Check if string is in the regular expression |
Instances
| NFData StrOp Source # | |||||
Defined in Data.SBV.Core.Symbolic | |||||
| Data StrOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StrOp -> c StrOp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c StrOp # dataTypeOf :: StrOp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c StrOp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StrOp) # gmapT :: (forall b. Data b => b -> b) -> StrOp -> StrOp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StrOp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StrOp -> r # gmapQ :: (forall d. Data d => d -> u) -> StrOp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> StrOp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> StrOp -> m StrOp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StrOp -> m StrOp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StrOp -> m StrOp # | |||||
| Generic StrOp Source # | |||||
Defined in Data.SBV.Core.Symbolic Associated Types
| |||||
| Show StrOp Source # | Show instance for | ||||
| Eq StrOp Source # | |||||
| Ord StrOp Source # | |||||
| type Rep StrOp Source # | |||||
Defined in Data.SBV.Core.Symbolic type Rep StrOp = D1 ('MetaData "StrOp" "Data.SBV.Core.Symbolic" "sbv-11.4-inplace" 'False) (((C1 ('MetaCons "StrConcat" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "StrLen" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrUnit" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "StrNth" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrSubstr" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StrIndexOf" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrContains" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "StrPrefixOf" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrSuffixOf" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StrReplace" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrStrToNat" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "StrNatToStr" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrToCode" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StrFromCode" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StrInRe" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RegExp)))))) | |||||
Is this name reserved?
isReserved :: String -> Bool Source #
Is this name reserved? Note that we'll ignore case in checking here. This is probably over-cautious.
Is the name given by the user for the uninterpreted constant a prefix or a full name?
Operations useful for instantiating SBV type classes
A CV represents a concrete word of a fixed size:
For signed words, the most significant digit is considered to be the sign.
Instances
| NFData CV Source # | |||||
Defined in Data.SBV.Core.Concrete | |||||
| Data CV Source # | |||||
Defined in Data.SBV.Core.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CV -> c CV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CV # dataTypeOf :: CV -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CV) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CV) # gmapT :: (forall b. Data b => b -> b) -> CV -> CV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CV -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CV -> r # gmapQ :: (forall d. Data d => d -> u) -> CV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CV -> m CV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CV -> m CV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CV -> m CV # | |||||
| Generic CV Source # | |||||
Defined in Data.SBV.Core.Concrete Associated Types
| |||||
| Show CV Source # | Show instance for | ||||
| Eq CV Source # | |||||
| Ord CV Source # | |||||
| HasKind CV Source # |
| ||||
Defined in Data.SBV.Core.Concrete Methods hasSign :: CV -> Bool Source # intSizeOf :: CV -> Int Source # isBoolean :: CV -> Bool Source # isBounded :: CV -> Bool Source # isFloat :: CV -> Bool Source # isDouble :: CV -> Bool Source # isRational :: CV -> Bool Source # isUnbounded :: CV -> Bool Source # isUserSort :: CV -> Bool Source # isString :: CV -> Bool Source # isTuple :: CV -> Bool Source # isMaybe :: CV -> Bool Source # isEither :: CV -> Bool Source # | |||||
| SDivisible CV Source # | |||||
| SatModel CV Source # |
| ||||
| PrettyNum CV Source # | |||||
| type Rep CV Source # | |||||
Defined in Data.SBV.Core.Concrete type Rep CV = D1 ('MetaData "CV" "Data.SBV.Core.Concrete" "sbv-11.4-inplace" 'False) (C1 ('MetaCons "CV" 'PrefixI 'True) (S1 ('MetaSel ('Just "_cvKind") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Kind) :*: S1 ('MetaSel ('Just "cvVal") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CVal))) | |||||
genMkSymVar :: MonadSymbolic m => Kind -> VarContext -> Maybe String -> m (SBV a) Source #
Generalization of genMkSymVar
genParse :: Integral a => Kind -> [CV] -> Maybe (a, [CV]) Source #
Parse a signed/sized value from a sequence of CVs
showModel :: SMTConfig -> SMTModel -> String Source #
Show a model in human readable form. Ignore bindings to those variables that start with "__internal_sbv_" and also those marked as "nonModelVar" in the config; as these are only for internal purposes
A model, as returned by a solver
Constructors
| SMTModel | |
Fields
| |
liftQRem :: (Eq a, SymVal a) => SBV a -> SBV a -> (SBV a, SBV a) Source #
Lift quotRem to symbolic words. Division by 0 is defined s.t. x/0 = 0; which
holds even when x is 0 itself.
liftDMod :: (Ord a, SymVal a, Num a, Num (SBV a), SDivisible (SBV a)) => SBV a -> SBV a -> (SBV a, SBV a) Source #
Lift divMod to symbolic words. Division by 0 is defined s.t. x/0 = 0; which
holds even when x is 0 itself. Essentially, this is conversion from quotRem
(truncate to 0) to divMod (truncate towards negative infinity)
registerKind :: State -> Kind -> IO () Source #
Register a new kind with the system, used for uninterpreted sorts.
NB: Is it safe to have new kinds in query mode? It could be that
the new kind might introduce a constraint that effects the logic. For
instance, if we're seeing Double for the first time and using a BV
logic, then things would fall apart. But this should be rare, and hopefully
the success-response checking mechanism will catch the rare cases where this
is an issue. In either case, the user can always arrange for the right
logic by calling setLogic appropriately, so it seems safe to just
allow for this.
class ExtractIO m => ProvableM (m :: Type -> Type) a Source #
A type a is provable if we can turn it into a predicate, i.e., it has to return a boolean.
This class captures essentially prove calls.
Minimal complete definition
Instances
| ExtractIO m => ProvableM m SBool Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: SBool -> SymbolicT m SBool Source # prove :: SBool -> m ThmResult Source # proveWith :: SMTConfig -> SBool -> m ThmResult Source # dprove :: SBool -> m ThmResult Source # dproveWith :: SMTConfig -> SBool -> m ThmResult Source # isVacuousProof :: SBool -> m Bool Source # isVacuousProofWith :: SMTConfig -> SBool -> m Bool Source # | |
| ExtractIO m => ProvableM m (SymbolicT m SBool) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: SymbolicT m SBool -> SymbolicT m SBool Source # prove :: SymbolicT m SBool -> m ThmResult Source # proveWith :: SMTConfig -> SymbolicT m SBool -> m ThmResult Source # dprove :: SymbolicT m SBool -> m ThmResult Source # dproveWith :: SMTConfig -> SymbolicT m SBool -> m ThmResult Source # isVacuousProof :: SymbolicT m SBool -> m Bool Source # isVacuousProofWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # isTheorem :: SymbolicT m SBool -> m Bool Source # isTheoremWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # | |
| (ExtractIO m, ProvableM m a) => ProvableM m (SymbolicT m a) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: SymbolicT m a -> SymbolicT m SBool Source # prove :: SymbolicT m a -> m ThmResult Source # proveWith :: SMTConfig -> SymbolicT m a -> m ThmResult Source # dprove :: SymbolicT m a -> m ThmResult Source # dproveWith :: SMTConfig -> SymbolicT m a -> m ThmResult Source # isVacuousProof :: SymbolicT m a -> m Bool Source # isVacuousProofWith :: SMTConfig -> SymbolicT m a -> m Bool Source # isTheorem :: SymbolicT m a -> m Bool Source # isTheoremWith :: SMTConfig -> SymbolicT m a -> m Bool Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, ProvableM m r) => ProvableM m (Exists nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (Exists nm a -> r) -> SymbolicT m SBool Source # prove :: (Exists nm a -> r) -> m ThmResult Source # proveWith :: SMTConfig -> (Exists nm a -> r) -> m ThmResult Source # dprove :: (Exists nm a -> r) -> m ThmResult Source # dproveWith :: SMTConfig -> (Exists nm a -> r) -> m ThmResult Source # isVacuousProof :: (Exists nm a -> r) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (Exists nm a -> r) -> m Bool Source # isTheorem :: (Exists nm a -> r) -> m Bool Source # isTheoremWith :: SMTConfig -> (Exists nm a -> r) -> m Bool Source # | |
| (KnownNat n, ExtractIO m, SymVal a, Constraint Symbolic r, ProvableM m r) => ProvableM m (ExistsN n nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (ExistsN n nm a -> r) -> SymbolicT m SBool Source # prove :: (ExistsN n nm a -> r) -> m ThmResult Source # proveWith :: SMTConfig -> (ExistsN n nm a -> r) -> m ThmResult Source # dprove :: (ExistsN n nm a -> r) -> m ThmResult Source # dproveWith :: SMTConfig -> (ExistsN n nm a -> r) -> m ThmResult Source # isVacuousProof :: (ExistsN n nm a -> r) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (ExistsN n nm a -> r) -> m Bool Source # isTheorem :: (ExistsN n nm a -> r) -> m Bool Source # isTheoremWith :: SMTConfig -> (ExistsN n nm a -> r) -> m Bool Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, ProvableM m r, EqSymbolic (SBV a)) => ProvableM m (ExistsUnique nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (ExistsUnique nm a -> r) -> SymbolicT m SBool Source # prove :: (ExistsUnique nm a -> r) -> m ThmResult Source # proveWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m ThmResult Source # dprove :: (ExistsUnique nm a -> r) -> m ThmResult Source # dproveWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m ThmResult Source # isVacuousProof :: (ExistsUnique nm a -> r) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m Bool Source # isTheorem :: (ExistsUnique nm a -> r) -> m Bool Source # isTheoremWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m Bool Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, ProvableM m r) => ProvableM m (Forall nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (Forall nm a -> r) -> SymbolicT m SBool Source # prove :: (Forall nm a -> r) -> m ThmResult Source # proveWith :: SMTConfig -> (Forall nm a -> r) -> m ThmResult Source # dprove :: (Forall nm a -> r) -> m ThmResult Source # dproveWith :: SMTConfig -> (Forall nm a -> r) -> m ThmResult Source # isVacuousProof :: (Forall nm a -> r) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (Forall nm a -> r) -> m Bool Source # isTheorem :: (Forall nm a -> r) -> m Bool Source # isTheoremWith :: SMTConfig -> (Forall nm a -> r) -> m Bool Source # | |
| (KnownNat n, ExtractIO m, SymVal a, Constraint Symbolic r, ProvableM m r) => ProvableM m (ForallN n nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (ForallN n nm a -> r) -> SymbolicT m SBool Source # prove :: (ForallN n nm a -> r) -> m ThmResult Source # proveWith :: SMTConfig -> (ForallN n nm a -> r) -> m ThmResult Source # dprove :: (ForallN n nm a -> r) -> m ThmResult Source # dproveWith :: SMTConfig -> (ForallN n nm a -> r) -> m ThmResult Source # isVacuousProof :: (ForallN n nm a -> r) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (ForallN n nm a -> r) -> m Bool Source # isTheorem :: (ForallN n nm a -> r) -> m Bool Source # isTheoremWith :: SMTConfig -> (ForallN n nm a -> r) -> m Bool Source # | |
| (SymVal a, ProvableM m p) => ProvableM m (SBV a -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: (SBV a -> p) -> SymbolicT m SBool Source # prove :: (SBV a -> p) -> m ThmResult Source # proveWith :: SMTConfig -> (SBV a -> p) -> m ThmResult Source # dprove :: (SBV a -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> (SBV a -> p) -> m ThmResult Source # isVacuousProof :: (SBV a -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # isTheorem :: (SBV a -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, ProvableM m p) => ProvableM m ((SBV a, SBV b) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, ProvableM m p) => ProvableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods proofArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> SymbolicT m SBool Source # prove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # proveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # dprove :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # dproveWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m ThmResult Source # isVacuousProof :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isVacuousProofWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isTheorem :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isTheoremWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # | |
class ExtractIO m => SatisfiableM (m :: Type -> Type) a Source #
A type a is satisfiable if it has constraints, potentially returning a boolean. This class
captures essentially sat and optimize calls.
Minimal complete definition
Instances
| ExtractIO m => SatisfiableM m SBool Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SBool -> SymbolicT m SBool Source # sat :: SBool -> m SatResult Source # satWith :: SMTConfig -> SBool -> m SatResult Source # dsat :: SBool -> m SatResult Source # dsatWith :: SMTConfig -> SBool -> m SatResult Source # allSat :: SBool -> m AllSatResult Source # allSatWith :: SMTConfig -> SBool -> m AllSatResult Source # isSatisfiable :: SBool -> m Bool Source # isSatisfiableWith :: SMTConfig -> SBool -> m Bool Source # optimize :: OptimizeStyle -> SBool -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SBool -> m OptimizeResult Source # | |
| ExtractIO m => SatisfiableM m (SymbolicT m SBool) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SymbolicT m SBool -> SymbolicT m SBool Source # sat :: SymbolicT m SBool -> m SatResult Source # satWith :: SMTConfig -> SymbolicT m SBool -> m SatResult Source # dsat :: SymbolicT m SBool -> m SatResult Source # dsatWith :: SMTConfig -> SymbolicT m SBool -> m SatResult Source # allSat :: SymbolicT m SBool -> m AllSatResult Source # allSatWith :: SMTConfig -> SymbolicT m SBool -> m AllSatResult Source # isSatisfiable :: SymbolicT m SBool -> m Bool Source # isSatisfiableWith :: SMTConfig -> SymbolicT m SBool -> m Bool Source # optimize :: OptimizeStyle -> SymbolicT m SBool -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SymbolicT m SBool -> m OptimizeResult Source # | |
| ExtractIO m => SatisfiableM m (SymbolicT m ()) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SymbolicT m () -> SymbolicT m SBool Source # sat :: SymbolicT m () -> m SatResult Source # satWith :: SMTConfig -> SymbolicT m () -> m SatResult Source # dsat :: SymbolicT m () -> m SatResult Source # dsatWith :: SMTConfig -> SymbolicT m () -> m SatResult Source # allSat :: SymbolicT m () -> m AllSatResult Source # allSatWith :: SMTConfig -> SymbolicT m () -> m AllSatResult Source # isSatisfiable :: SymbolicT m () -> m Bool Source # isSatisfiableWith :: SMTConfig -> SymbolicT m () -> m Bool Source # optimize :: OptimizeStyle -> SymbolicT m () -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SymbolicT m () -> m OptimizeResult Source # | |
| (ExtractIO m, SatisfiableM m a) => SatisfiableM m (SymbolicT m a) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: SymbolicT m a -> SymbolicT m SBool Source # sat :: SymbolicT m a -> m SatResult Source # satWith :: SMTConfig -> SymbolicT m a -> m SatResult Source # dsat :: SymbolicT m a -> m SatResult Source # dsatWith :: SMTConfig -> SymbolicT m a -> m SatResult Source # allSat :: SymbolicT m a -> m AllSatResult Source # allSatWith :: SMTConfig -> SymbolicT m a -> m AllSatResult Source # isSatisfiable :: SymbolicT m a -> m Bool Source # isSatisfiableWith :: SMTConfig -> SymbolicT m a -> m Bool Source # optimize :: OptimizeStyle -> SymbolicT m a -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> SymbolicT m a -> m OptimizeResult Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, SatisfiableM m r) => SatisfiableM m (Exists nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (Exists nm a -> r) -> SymbolicT m SBool Source # sat :: (Exists nm a -> r) -> m SatResult Source # satWith :: SMTConfig -> (Exists nm a -> r) -> m SatResult Source # dsat :: (Exists nm a -> r) -> m SatResult Source # dsatWith :: SMTConfig -> (Exists nm a -> r) -> m SatResult Source # allSat :: (Exists nm a -> r) -> m AllSatResult Source # allSatWith :: SMTConfig -> (Exists nm a -> r) -> m AllSatResult Source # isSatisfiable :: (Exists nm a -> r) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (Exists nm a -> r) -> m Bool Source # optimize :: OptimizeStyle -> (Exists nm a -> r) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (Exists nm a -> r) -> m OptimizeResult Source # | |
| (KnownNat n, ExtractIO m, SymVal a, Constraint Symbolic r, SatisfiableM m r) => SatisfiableM m (ExistsN n nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (ExistsN n nm a -> r) -> SymbolicT m SBool Source # sat :: (ExistsN n nm a -> r) -> m SatResult Source # satWith :: SMTConfig -> (ExistsN n nm a -> r) -> m SatResult Source # dsat :: (ExistsN n nm a -> r) -> m SatResult Source # dsatWith :: SMTConfig -> (ExistsN n nm a -> r) -> m SatResult Source # allSat :: (ExistsN n nm a -> r) -> m AllSatResult Source # allSatWith :: SMTConfig -> (ExistsN n nm a -> r) -> m AllSatResult Source # isSatisfiable :: (ExistsN n nm a -> r) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (ExistsN n nm a -> r) -> m Bool Source # optimize :: OptimizeStyle -> (ExistsN n nm a -> r) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (ExistsN n nm a -> r) -> m OptimizeResult Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, SatisfiableM m r, EqSymbolic (SBV a)) => SatisfiableM m (ExistsUnique nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (ExistsUnique nm a -> r) -> SymbolicT m SBool Source # sat :: (ExistsUnique nm a -> r) -> m SatResult Source # satWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m SatResult Source # dsat :: (ExistsUnique nm a -> r) -> m SatResult Source # dsatWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m SatResult Source # allSat :: (ExistsUnique nm a -> r) -> m AllSatResult Source # allSatWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m AllSatResult Source # isSatisfiable :: (ExistsUnique nm a -> r) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (ExistsUnique nm a -> r) -> m Bool Source # optimize :: OptimizeStyle -> (ExistsUnique nm a -> r) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (ExistsUnique nm a -> r) -> m OptimizeResult Source # | |
| (ExtractIO m, SymVal a, Constraint Symbolic r, SatisfiableM m r) => SatisfiableM m (Forall nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (Forall nm a -> r) -> SymbolicT m SBool Source # sat :: (Forall nm a -> r) -> m SatResult Source # satWith :: SMTConfig -> (Forall nm a -> r) -> m SatResult Source # dsat :: (Forall nm a -> r) -> m SatResult Source # dsatWith :: SMTConfig -> (Forall nm a -> r) -> m SatResult Source # allSat :: (Forall nm a -> r) -> m AllSatResult Source # allSatWith :: SMTConfig -> (Forall nm a -> r) -> m AllSatResult Source # isSatisfiable :: (Forall nm a -> r) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (Forall nm a -> r) -> m Bool Source # optimize :: OptimizeStyle -> (Forall nm a -> r) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (Forall nm a -> r) -> m OptimizeResult Source # | |
| (KnownNat n, ExtractIO m, SymVal a, Constraint Symbolic r, SatisfiableM m r) => SatisfiableM m (ForallN n nm a -> r) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (ForallN n nm a -> r) -> SymbolicT m SBool Source # sat :: (ForallN n nm a -> r) -> m SatResult Source # satWith :: SMTConfig -> (ForallN n nm a -> r) -> m SatResult Source # dsat :: (ForallN n nm a -> r) -> m SatResult Source # dsatWith :: SMTConfig -> (ForallN n nm a -> r) -> m SatResult Source # allSat :: (ForallN n nm a -> r) -> m AllSatResult Source # allSatWith :: SMTConfig -> (ForallN n nm a -> r) -> m AllSatResult Source # isSatisfiable :: (ForallN n nm a -> r) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (ForallN n nm a -> r) -> m Bool Source # optimize :: OptimizeStyle -> (ForallN n nm a -> r) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (ForallN n nm a -> r) -> m OptimizeResult Source # | |
| (SymVal a, SatisfiableM m p) => SatisfiableM m (SBV a -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: (SBV a -> p) -> SymbolicT m SBool Source # sat :: (SBV a -> p) -> m SatResult Source # satWith :: SMTConfig -> (SBV a -> p) -> m SatResult Source # dsat :: (SBV a -> p) -> m SatResult Source # dsatWith :: SMTConfig -> (SBV a -> p) -> m SatResult Source # allSat :: (SBV a -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> (SBV a -> p) -> m AllSatResult Source # isSatisfiable :: (SBV a -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> (SBV a -> p) -> m Bool Source # optimize :: OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SymVal j, SymVal k, SymVal l, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i, SBV j, SBV k, SBV l) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h) -> p) -> m OptimizeResult Source # | |
| (SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, SymVal h, SymVal i, SatisfiableM m p) => SatisfiableM m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) Source # | |
Defined in Data.SBV.Provers.Prover Methods satArgReduce :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> SymbolicT m SBool Source # sat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # satWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # dsat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # dsatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m SatResult Source # allSat :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m AllSatResult Source # allSatWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m AllSatResult Source # isSatisfiable :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m Bool Source # optimize :: OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m OptimizeResult Source # optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g, SBV h, SBV i) -> p) -> m OptimizeResult Source # | |
data UICodeKind Source #
Kind of code we have for uninterpretation
Compilation to C, extras
compileToC' :: String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle) Source #
Lower level version of compileToC, producing a CgPgmBundle
compileToCLib' :: String -> [(String, SBVCodeGen a)] -> IO ([a], CgConfig, CgPgmBundle) Source #
Lower level version of compileToCLib, producing a CgPgmBundle
Code generation primitives
cgAddDecl :: [String] -> SBVCodeGen () Source #
Adds the given lines to the program file generated, useful for generating programs with uninterpreted functions.
cgAddLDFlags :: [String] -> SBVCodeGen () Source #
Adds the given words to the compiler options in the generated Makefile, useful for linking extra stuff in.
cgAddPrototype :: [String] -> SBVCodeGen () Source #
Adds the given lines to the header file generated, useful for generating programs with uninterpreted functions.
cgGenerateDriver :: Bool -> SBVCodeGen () Source #
Should we generate a driver program? Default: True. When a library is generated, it will have
a driver if any of the constituent functions has a driver. (See compileToCLib.)
cgGenerateMakefile :: Bool -> SBVCodeGen () Source #
Should we generate a Makefile? Default: True.
cgIgnoreSAssert :: Bool -> SBVCodeGen () Source #
Ignore assertions (those generated by sAssert calls) in the generated C code
cgInput :: SymVal a => String -> SBVCodeGen (SBV a) Source #
Creates an atomic input in the generated code.
cgInputArr :: SymVal a => Int -> String -> SBVCodeGen [SBV a] Source #
Creates an array input in the generated code.
cgIntegerSize :: Int -> SBVCodeGen () Source #
Sets number of bits to be used for representing the SInteger type in the generated C code.
The argument must be one of 8, 16, 32, or 64. Note that this is essentially unsafe as
the semantics of unbounded Haskell integers becomes reduced to the corresponding bit size, as
typical in most C implementations.
cgOutput :: String -> SBV a -> SBVCodeGen () Source #
Creates an atomic output in the generated code.
cgOutputArr :: SymVal a => String -> [SBV a] -> SBVCodeGen () Source #
Creates an array output in the generated code.
cgOverwriteFiles :: Bool -> SBVCodeGen () Source #
If passed True, then we will not ask the user if we're overwriting files as we generate
the C code. Otherwise, we'll prompt.
cgPerformRTCs :: Bool -> SBVCodeGen () Source #
Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off. Default: False.
cgReturn :: SBV a -> SBVCodeGen () Source #
Creates a returned (unnamed) value in the generated code.
cgReturnArr :: SymVal a => [SBV a] -> SBVCodeGen () Source #
Creates a returned (unnamed) array value in the generated code.
cgSRealType :: CgSRealType -> SBVCodeGen () Source #
Sets the C type to be used for representing the SReal type in the generated C code.
The setting can be one of C's "float", "double", or "long double", types, depending
on the precision needed. Note that this is essentially unsafe as the semantics of
infinite precision SReal values becomes reduced to the corresponding floating point type in
C, and hence it is subject to rounding errors.
cgSetDriverValues :: [Integer] -> SBVCodeGen () Source #
Sets driver program run time values, useful for generating programs with fixed drivers for testing. Default: None, i.e., use random values.
cgShowU8UsingHex :: Bool -> SBVCodeGen () Source #
If passed True, then we will show 'SWord 8' type in hex. Otherwise we'll show it in decimal. All signed
types are shown decimal, and all unsigned larger types are shown hexadecimal otherwise.
cgSym :: Symbolic a -> SBVCodeGen a Source #
Reach into symbolic monad from code-generation
codeGen :: CgTarget l => l -> CgConfig -> String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle) Source #
Generate code for a symbolic program, returning a Code-gen bundle, i.e., collection of makefiles, source code, headers, etc.
defaultCgConfig :: CgConfig Source #
Default options for code generation. The run-time checks are turned-off, and the driver values are completely random.
initCgState :: CgState Source #
Initial configuration for code-generation
isCgDriver :: CgPgmKind -> Bool Source #
Is this a driver program?
isCgMakefile :: CgPgmKind -> Bool Source #
Is this a make file?
renderCgPgmBundle :: Maybe FilePath -> (CgConfig, CgPgmBundle) -> IO () Source #
Render a code-gen bundle to a directory or to stdout
svCgInput :: Kind -> String -> SBVCodeGen SVal Source #
Creates an atomic input in the generated code.
svCgInputArr :: Kind -> Int -> String -> SBVCodeGen [SVal] Source #
Creates an array input in the generated code.
svCgOutput :: String -> SVal -> SBVCodeGen () Source #
Creates an atomic output in the generated code.
svCgOutputArr :: String -> [SVal] -> SBVCodeGen () Source #
Creates an array output in the generated code.
svCgReturn :: SVal -> SBVCodeGen () Source #
Creates a returned (unnamed) value in the generated code.
svCgReturnArr :: [SVal] -> SBVCodeGen () Source #
Creates a returned (unnamed) array value in the generated code.
Options for code-generation.
Constructors
| CgConfig | |
Fields
| |
data CgPgmBundle Source #
Representation of a collection of generated programs.
Constructors
| CgPgmBundle (Maybe Int, Maybe CgSRealType) [(FilePath, (CgPgmKind, [Doc]))] |
Instances
| Show CgPgmBundle Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods showsPrec :: Int -> CgPgmBundle -> ShowS # show :: CgPgmBundle -> String # showList :: [CgPgmBundle] -> ShowS # | |
Different kinds of "files" we can produce. Currently this is quite C specific.
data CgSRealType Source #
Possible mappings for the SReal type when translated to C. Used in conjunction
with the function cgSRealType. Note that the particular characteristics of the
mapped types depend on the platform and the compiler used for compiling the generated
C program. See http://en.wikipedia.org/wiki/C_data_types for details.
Constructors
| CgFloat | float |
| CgDouble | double |
| CgLongDouble | long double |
Instances
| Show CgSRealType Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods showsPrec :: Int -> CgSRealType -> ShowS # show :: CgSRealType -> String # showList :: [CgSRealType] -> ShowS # | |
| Eq CgSRealType Source # | |
Defined in Data.SBV.Compilers.CodeGen | |
Code-generation state
Constructors
| CgState | |
Instances
| MonadState CgState SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods get :: SBVCodeGen CgState # put :: CgState -> SBVCodeGen () # state :: (CgState -> (a, CgState)) -> SBVCodeGen a # | |
newtype SBVCodeGen a Source #
The code-generation monad. Allows for precise layout of input values reference parameters (for returning composite values in languages such as C), and return values.
Constructors
| SBVCodeGen (StateT CgState Symbolic a) |
Instances
| Applicative SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods pure :: a -> SBVCodeGen a # (<*>) :: SBVCodeGen (a -> b) -> SBVCodeGen a -> SBVCodeGen b # liftA2 :: (a -> b -> c) -> SBVCodeGen a -> SBVCodeGen b -> SBVCodeGen c # (*>) :: SBVCodeGen a -> SBVCodeGen b -> SBVCodeGen b # (<*) :: SBVCodeGen a -> SBVCodeGen b -> SBVCodeGen a # | |
| Functor SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods fmap :: (a -> b) -> SBVCodeGen a -> SBVCodeGen b # (<$) :: a -> SBVCodeGen b -> SBVCodeGen a # | |
| Monad SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods (>>=) :: SBVCodeGen a -> (a -> SBVCodeGen b) -> SBVCodeGen b # (>>) :: SBVCodeGen a -> SBVCodeGen b -> SBVCodeGen b # return :: a -> SBVCodeGen a # | |
| MonadFail SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods fail :: String -> SBVCodeGen a # | |
| MonadIO SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods liftIO :: IO a -> SBVCodeGen a # | |
| MonadSymbolic SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods | |
| MonadState CgState SBVCodeGen Source # | |
Defined in Data.SBV.Compilers.CodeGen Methods get :: SBVCodeGen CgState # put :: CgState -> SBVCodeGen () # state :: (CgState -> (a, CgState)) -> SBVCodeGen a # | |
Various math utilities around floats
fp2fp :: (RealFloat a, RealFloat b) => a -> b Source #
Convert double to float and back. Essentially fromRational . toRational
except careful on NaN, Infinities, and -0.
fpCompareObjectH :: RealFloat a => a -> a -> Ordering Source #
Ordering for floats, avoiding the +0-0NaN issues. Note that this is essentially used for indexing into a map, so we need to be total. Thus, the order we pick is: NaN -oo -0 +0 +oo The placement of NaN here is questionable, but immaterial.
fpIsEqualObjectH :: RealFloat a => a -> a -> Bool Source #
Check that two floats are the exact same values, i.e., +0/-0 does not compare equal, and NaN's compare equal to themselves.
fpIsNormalizedH :: RealFloat a => a -> Bool Source #
Check if a number is "normal." Note that +0/-0 is not considered a normal-number and also this is not simply the negation of isDenormalized!
fpMaxH :: RealFloat a => a -> a -> a Source #
The SMT-Lib (in particular Z3) implementation for min/max for floats does not agree with Haskell's; and also it does not agree with what the hardware does. Sigh.. See: http://ghc.haskell.org/trac/ghc/ticket/10378 http://github.com/Z3Prover/z3/issues/68 So, we codify here what the Z3 (SMTLib) is implementing for fpMax. The discrepancy with Haskell is that the NaN propagation doesn't work in Haskell The discrepancy with x86 is that given +0/-0, x86 returns the second argument; SMTLib is non-deterministic
fpRemH :: RealFloat a => a -> a -> a Source #
Compute the "floating-point" remainder function, the float/double value that
remains from the division of x and y. There are strict rules around 0's, Infinities,
and NaN's as coded below.
fpRoundToIntegralH :: RealFloat a => a -> a Source #
Convert a float to the nearest integral representable in that type
Pretty number printing
smtRoundingMode :: RoundingMode -> String Source #
Convert a rounding mode to the format SMT-Lib2 understands.
chex :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String Source #
Show as hexadecimal, but for C programs. We have to be careful about printing min-bounds, since C does some funky casting, possibly losing the sign bit. In those cases, we use the defined constants in stdint.h. We also properly append the necessary suffixes as needed.
cvToSMTLib :: RoundingMode -> CV -> String Source #
Convert a CV to an SMTLib2 compliant value
readBin :: Num a => String -> a Source #
A more convenient interface for reading binary numbers, also supports negative numbers
sbin :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String Source #
Similar to shex; except in binary.
shex :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String Source #
Show as a hexadecimal value. First bool controls whether type info is printed while the second boolean controls whether 0x prefix is printed. The tuple is the signedness and the bit-length of the input. The length of the string will not depend on the value, but rather the bit-length.
shexI :: Bool -> Bool -> Integer -> String Source #
Show as a hexadecimal value, integer version. Almost the same as shex above except we don't have a bit-length so the length of the string will depend on the actual value.
showCDouble :: Double -> String Source #
A version of show for doubles that generates correct C literals for nan/infinite. NB. Requires "math.h" to be included.
showCFloat :: Float -> String Source #
A version of show for floats that generates correct C literals for nan/infinite. NB. Requires "math.h" to be included.
showFloatAtBase :: (Show a, RealFloat a) => Int -> a -> ShowS Source #
Like Haskell's showHFloat, but uses arbitrary base instead.
Note that the exponent is always written in decimal. Let the exponent value be d:
If base=10, then we use e to denote the exponent; meaning 10^d
If base is a power of 2, then we use p to denote the exponent; meaning 2^d
Otherwise, we use @ to denote the exponent, and it means base^d
showHDouble :: Double -> String Source #
A version of show for doubles that generates correct Haskell literals for nan/infinite
showHFloat :: Float -> String Source #
A version of show for floats that generates correct Haskell literals for nan/infinite
showNegativeNumber :: (Show a, Num a, Ord a) => a -> String Source #
When we show a negative number in SMTLib, we must properly parenthesize.
showSMTDouble :: RoundingMode -> Double -> String Source #
A version of show for doubles that generates correct SMTLib literals using the rounding mode
showSMTFloat :: RoundingMode -> Float -> String Source #
A version of show for floats that generates correct SMTLib literals using the rounding mode
class PrettyNum a where Source #
PrettyNum class captures printing of numbers in hex and binary formats; also supporting negative numbers.
Methods
Show a number in hexadecimal, starting with 0x and type.
Show a number in binary, starting with 0b and type.
Show a number in hexadecimal, starting with 0x but no type.
Show a number in binary, starting with 0b but no type.
Show a number in hex, without prefix, or types.
Show a number in bin, without prefix, or types.
Instances
| PrettyNum Int16 Source # | |
| PrettyNum Int32 Source # | |
| PrettyNum Int64 Source # | |
| PrettyNum Int8 Source # | |
| PrettyNum Word16 Source # | |
| PrettyNum Word32 Source # | |
| PrettyNum Word64 Source # | |
| PrettyNum Word8 Source # | |
| PrettyNum CV Source # | |
| PrettyNum Integer Source # | |
| PrettyNum String Source # | |
| PrettyNum Bool Source # | |
| (SymVal a, PrettyNum a) => PrettyNum (SBV a) Source # | |
Timing computations
getElapsedTime :: MonadIO m => Maybe UTCTime -> m (Maybe NominalDiffTime) Source #
Get elapsed time from the given beginning time, if any.
getTimeStampIf :: MonadIO m => Bool -> m (Maybe UTCTime) Source #
Get a time-stamp if we're asked to do so
showTDiff :: NominalDiffTime -> String Source #
Show NominalDiffTime in human readable form. NominalDiffTime is
essentially picoseconds (10^-12 seconds). We show it so that
it's represented at the day:hour:minute:second.XXX granularity.
timeIf :: MonadIO m => Bool -> m a -> m (Maybe NominalDiffTime, a) Source #
Run an action and measure how long it took. We reduce the result to weak-head-normal-form, so beware of the cases if the result is lazily computed; in which case we'll stop soon as the result is in WHNF, and not necessarily fully calculated.
timeIfRNF :: (NFData a, MonadIO m) => Bool -> m a -> m (Maybe NominalDiffTime, a) Source #
Same as timeIf, except we fully evaluate the result, via its the NFData instance.
Specify how to save timing information, if at all.
Constructors
| NoTiming | |
| PrintTiming | |
| SaveTiming (IORef NominalDiffTime) |
Coordinating with the solver
In rare cases it might be necessary to send an arbitrary string down to the solver. Needless to say, this
should be avoided if at all possible. Users should prefer the provided API. If you do find yourself
needing send and ask directly, please get in touch to see if SBV can support a typed API for your use case.
Similarly, the function retrieveResponseFromSolver might occasionally be necessary to clean-up the communication
buffer. We would like to hear if you do need these functions regularly so we can provide better support.
sendStringToSolver :: (MonadIO m, MonadQuery m) => String -> m () Source #
Send an arbitrary string to the solver in a query. Note that this is inherently dangerous as it can put the solver in an arbitrary state and confuse SBV. If you use this feature, you are on your own!
sendRequestToSolver :: (MonadIO m, MonadQuery m) => String -> m String Source #
Send an arbitrary string to the solver in a query, and return a response. Note that this is inherently dangerous as it can put the solver in an arbitrary state and confuse SBV.
retrieveResponseFromSolver :: (MonadIO m, MonadQuery m) => String -> Maybe Int -> m [String] Source #
Retrieve multiple responses from the solver, until it responds with a user given tag that we shall arrange for internally. The optional timeout is in milliseconds. If the time-out is exceeded, then we will raise an error. Note that this is inherently dangerous as it can put the solver in an arbitrary state and confuse SBV. If you use this feature, you are on your own!
Defining new metrics
addSValOptGoal :: MonadSymbolic m => Objective SVal -> m () Source #
Generalization of addSValOptGoal
sFloatAsComparableSWord32 :: SFloat -> SWord32 Source #
Convert a float to a comparable SWord32. The trick is to ignore the
sign of -0, and if it's a negative value flip all the bits, and otherwise
only flip the sign bit. This is known as the lexicographic ordering on floats
and it works as long as you do not have a NaN.
sDoubleAsComparableSWord64 :: SDouble -> SWord64 Source #
Convert a double to a comparable SWord64. The trick is to ignore the
sign of -0, and if it's a negative value flip all the bits, and otherwise
only flip the sign bit. This is known as the lexicographic ordering on doubles
and it works as long as you do not have a NaN.
sFloatingPointAsComparableSWord :: forall (eb :: Nat) (sb :: Nat). (ValidFloat eb sb, KnownNat (eb + sb), BVIsNonZero (eb + sb)) => SFloatingPoint eb sb -> SWord (eb + sb) Source #
Convert a float to the correct size word, that can be used in lexicographic ordering. Used in optimization.
sComparableSWord32AsSFloat :: SWord32 -> SFloat Source #
Inverse transformation to sFloatAsComparableSWord32. Note that this isn't a perfect inverse, since -0 maps to 0 and back to 0.
Otherwise, it's faithful:
>>>prove $ \x -> let f = sComparableSWord32AsSFloat x in fpIsNaN f .|| fpIsNegativeZero f .|| sFloatAsComparableSWord32 f .== xQ.E.D.>>>prove $ \x -> fpIsNegativeZero x .|| sComparableSWord32AsSFloat (sFloatAsComparableSWord32 x) `fpIsEqualObject` xQ.E.D.
sComparableSWord64AsSDouble :: SWord64 -> SDouble Source #
Inverse transformation to sDoubleAsComparableSWord64. Note that this isn't a perfect inverse, since -0 maps to 0 and back to 0.
Otherwise, it's faithful:
>>>prove $ \x -> let d = sComparableSWord64AsSDouble x in fpIsNaN d .|| fpIsNegativeZero d .|| sDoubleAsComparableSWord64 d .== xQ.E.D.>>>prove $ \x -> fpIsNegativeZero x .|| sComparableSWord64AsSDouble (sDoubleAsComparableSWord64 x) `fpIsEqualObject` xQ.E.D.
sComparableSWordAsSFloatingPoint :: forall (eb :: Natural) (sb :: Natural). (KnownNat (eb + sb), BVIsNonZero (eb + sb), ValidFloat eb sb) => SWord (eb + sb) -> SFloatingPoint eb sb Source #
Inverse transformation to sFloatingPointAsComparableSWord. Note that this isn't a perfect inverse, since -0 maps to 0 and back to 0.
Otherwise, it's faithful:
>>>prove $ \x -> let d :: SFPHalf = sComparableSWordAsSFloatingPoint x in fpIsNaN d .|| fpIsNegativeZero d .|| sFloatingPointAsComparableSWord d .== xQ.E.D.>>>prove $ \x -> fpIsNegativeZero x .|| sComparableSWordAsSFloatingPoint (sFloatingPointAsComparableSWord x) `fpIsEqualObject` (x :: SFPHalf)Q.E.D.
Generalized floats
svFloatingPointAsSWord :: SVal -> SVal Source #
Convert a float to the word containing the corresponding bit pattern
lambdas and axioms
lambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTDef Source #
Create an SMTLib lambda, in the given state.
lambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTLambda Source #
Create an anonymous lambda, rendered as n SMTLib string. The kind passed is the kind of the final result.
namedLambda :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> Kind -> a -> m SMTDef Source #
Create a named SMTLib function, in the given state.
namedLambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> State -> String -> SBVType -> a -> m String Source #
Create a named SMTLib function, in the given state, string version
constraint :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m SV Source #
Generate a constraint. We allow free variables here (first arg of constraintGen). This might prove to be not kosher!
constraintStr :: (MonadIO m, Constraint (SymbolicT m) a) => State -> a -> m String Source #
Generate a constraint, string version We allow free variables here (first arg of constraintGen). This might prove to be not kosher!
class MonadSymbolic m => Lambda (m :: Type -> Type) a where Source #
Values that we can turn into a lambda abstraction
class MonadSymbolic m => Constraint (m :: Type -> Type) a where Source #
Values that we can turn into a constraint
Methods
mkConstraint :: State -> a -> m () Source #
Instances
| MonadSymbolic m => Constraint m SBool Source # | Base case: simple booleans |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> SBool -> m () Source # | |
| (SymVal a, Constraint m r) => Constraint m (Exists nm a -> r) Source # | Functions of a single existential |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (Exists nm a -> r) -> m () Source # | |
| (KnownNat n, SymVal a, Constraint m r) => Constraint m (ExistsN n nm a -> r) Source # | Functions of a number of existentials |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ExistsN n nm a -> r) -> m () Source # | |
| (SymVal a, Constraint m r, EqSymbolic (SBV a), QuantifiedBool r) => Constraint m (ExistsUnique nm a -> r) Source # | Functions of a unique single existential |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ExistsUnique nm a -> r) -> m () Source # | |
| (SymVal a, Constraint m r) => Constraint m (Forall nm a -> r) Source # | Functions of a single universal |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (Forall nm a -> r) -> m () Source # | |
| (KnownNat n, SymVal a, Constraint m r) => Constraint m (ForallN n nm a -> r) Source # | Functions of a number of universals |
Defined in Data.SBV.Core.Data Methods mkConstraint :: State -> (ForallN n nm a -> r) -> m () Source # | |
data LambdaScope Source #
What's the scope of the generated lambda?
Constructors
| HigherOrderArg | |
| TopLevel |