sbv-8.12: SMT Based Verification: Symbolic Haskell theorem prover using SMT solving.
Copyright(c) Levent Erkok
LicenseBSD3
Maintainererkokl@gmail.com
Stabilityexperimental
Safe HaskellNone
LanguageHaskell2010

Data.SBV.Internals

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

Running symbolic programs manually

data Result Source #

Result of running a symbolic computation

Constructors

Result 

Fields

Instances

Instances details
Show Result Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData Result Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Result -> () #

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.

Concrete (Maybe (Bool, [((Quantifier, NamedSymVar), Maybe CV)]))

Concrete simulation mode, with given environment if any. If Nothing: Random.

Instances

Instances details
Show SBVRunMode Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

data IStage Source #

Stage of an interactive run

Constructors

ISetup 
ISafe 
IRun 

data QueryContext Source #

Query execution context

Constructors

QueryInternal

Triggered from inside SBV

QueryExternal

Triggered from user code

Instances

Instances details
Show QueryContext Source #

Show instance for QueryContext, for debugging purposes

Instance details

Defined in Data.SBV.Core.Symbolic

data VarContext Source #

Which context is this variable being created?

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

type SBool = SBV Bool Source #

A symbolic boolean/bit

type SWord8 = SBV Word8 Source #

8-bit unsigned symbolic value

type SWord16 = SBV Word16 Source #

16-bit unsigned symbolic value

type SWord32 = SBV Word32 Source #

32-bit unsigned symbolic value

type SWord64 = SBV Word64 Source #

64-bit unsigned symbolic value

type SInt8 = SBV Int8 Source #

8-bit signed symbolic value, 2's complement representation

type SInt16 = SBV Int16 Source #

16-bit signed symbolic value, 2's complement representation

type SInt32 = SBV Int32 Source #

32-bit signed symbolic value, 2's complement representation

type SInt64 = SBV Int64 Source #

64-bit signed symbolic value, 2's complement representation

type SInteger = SBV Integer Source #

Infinite precision signed symbolic value

type SReal = SBV AlgReal Source #

Infinite precision symbolic algebraic real value

type SFloat = SBV Float Source #

IEEE-754 single-precision floating point numbers

type SDouble = SBV Double Source #

IEEE-754 double-precision floating point numbers

type SFloatingPoint (eb :: Nat) (sb :: Nat) = SBV (FloatingPoint eb sb) Source #

A symbolic arbitrary precision floating point value

type SFPHalf = SBV FPHalf Source #

A symbolic half-precision float

type SFPSingle = SBV FPSingle Source #

A symbolic single-precision float

type SFPDouble = SBV FPDouble Source #

A symbolic double-precision float

type SFPQuad = SBV FPQuad Source #

A symbolic quad-precision float

type SChar = SBV Char Source #

A symbolic character. Note that this is the full unicode character set. see: http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml for details.

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.

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.

type SEither a b = SBV (Either a b) Source #

Symbolic Either

type SMaybe a = SBV (Maybe a) Source #

Symbolic Maybe

type STuple a b = SBV (a, b) Source #

Symbolic 2-tuple. NB. STuple and STuple2 are equivalent.

type STuple2 a b = SBV (a, b) Source #

Symbolic 2-tuple. NB. STuple and STuple2 are equivalent.

type STuple3 a b c = SBV (a, b, c) Source #

Symbolic 3-tuple.

type STuple4 a b c d = SBV (a, b, c, d) Source #

Symbolic 4-tuple.

type STuple5 a b c d e = SBV (a, b, c, d, e) Source #

Symbolic 5-tuple.

type STuple6 a b c d e f = SBV (a, b, c, d, e, f) Source #

Symbolic 6-tuple.

type STuple7 a b c d e f g = SBV (a, b, c, d, e, f, g) Source #

Symbolic 7-tuple.

type STuple8 a b c d e f g h = SBV (a, b, c, d, e, f, g, h) Source #

Symbolic 8-tuple.

data RCSet a 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

Instances details
Show a => Show (RCSet a) Source #

Show instance. Regular sets are shown as usual. Complements are shown "U -" notation.

Instance details

Defined in Data.SBV.Core.Concrete

Methods

showsPrec :: Int -> RCSet a -> ShowS #

show :: RCSet a -> String #

showList :: [RCSet a] -> ShowS #

HasKind a => HasKind (RCSet a) Source # 
Instance details

Defined in Data.SBV.Core.Concrete

(Ord a, SymVal a) => SymVal (RCSet a) Source # 
Instance details

Defined in Data.SBV.Core.Model

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.

nan :: Floating a => a Source #

Not-A-Number for Double and Float. Surprisingly, Haskell Prelude doesn't have this value defined, so we provide it here.

infinity :: Floating a => a Source #

Infinity for Double and Float. Surprisingly, Haskell Prelude doesn't have this value defined, so we provide it here.

sNaN :: (Floating a, SymVal a) => SBV a Source #

Symbolic variant of Not-A-Number. This value will inhabit SFloat, SDouble and SFloatingPoint. types.

sInfinity :: (Floating a, SymVal a) => SBV a Source #

Symbolic variant of infinity. This value will inhabit both SFloat, SDouble and SFloatingPoint. types.

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

Instances details
Bounded RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

Enum RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

Eq RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

Data RoundingMode Source # 
Instance details

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 #

Ord RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

Read RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

Show RoundingMode Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind RoundingMode Source #

RoundingMode kind

Instance details

Defined in Data.SBV.Core.Kind

SymVal RoundingMode Source #

RoundingMode can be used symbolically

Instance details

Defined in Data.SBV.Core.Data

SatModel RoundingMode Source #

A rounding mode, extracted from a model. (Default definition suffices)

Instance details

Defined in Data.SBV.SMT.SMT

Methods

parseCVs :: [CV] -> Maybe (RoundingMode, [CV]) Source #

cvtModel :: (RoundingMode -> Maybe b) -> Maybe (RoundingMode, [CV]) -> Maybe (b, [CV]) Source #

type SRoundingMode = SBV RoundingMode Source #

The symbolic variant of RoundingMode

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

default literal :: Show a => a -> SBV a Source #

fromCV :: CV -> a Source #

Extract a literal, from a CV representation

default fromCV :: Read a => CV -> a Source #

isConcretely :: SBV a -> (a -> Bool) -> Bool Source #

Does it concretely satisfy the given predicate?

forall :: MonadSymbolic m => String -> m (SBV a) Source #

Generalization of forall

forall_ :: MonadSymbolic m => m (SBV a) Source #

Generalization of forall_

mkForallVars :: MonadSymbolic m => Int -> m [SBV a] Source #

Generalization of mkForallVars

exists :: MonadSymbolic m => String -> m (SBV a) Source #

Generalization of exists

exists_ :: MonadSymbolic m => m (SBV a) Source #

Generalization of exists_

mkExistVars :: MonadSymbolic m => Int -> m [SBV a] Source #

Generalization of mkExistVars

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

Instances details
SymVal Bool Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Char Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Double Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Float Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Int8 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Int16 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Int32 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Int64 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Integer Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Word8 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Word16 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Word32 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal Word64 Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal () Source #

SymVal for 0-tuple (i.e., unit)

Instance details

Defined in Data.SBV.Core.Model

SymVal AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal RoundingMode Source #

RoundingMode can be used symbolically

Instance details

Defined in Data.SBV.Core.Data

SymVal State Source # 
Instance details

Defined in Documentation.SBV.Examples.Lists.BoundedMutex

SymVal E Source # 
Instance details

Defined in Documentation.SBV.Examples.Misc.Enumerate

SymVal HumanHeightInCm Source #

Similarly here, for the SymVal instance.

Instance details

Defined in Documentation.SBV.Examples.Misc.Newtypes

SymVal Metres Source #

The SymVal instance simply uses stock definitions. This is always possible for newtypes that simply wrap over an existing symbolic type.

Instance details

Defined in Documentation.SBV.Examples.Misc.Newtypes

SymVal Day Source # 
Instance details

Defined in Documentation.SBV.Examples.Optimization.Enumerate

SymVal Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

SymVal Nationality Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

SymVal Beverage Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

SymVal Pet Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

SymVal Sport Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

SymVal Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Garden

SymVal Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.HexPuzzle

SymVal Role Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

SymVal Sex Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

SymVal Location Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

SymVal U2Member Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.U2Bridge

SymVal Location Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.U2Bridge

SymVal Day Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.Enums

SymVal BinOp Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.FourFours

SymVal UnOp Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.FourFours

SymVal B Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.Deduce

SymVal Q Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.Sort

SymVal L Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.UISortAllSat

SymVal a => SymVal [a] Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

mkSymVal :: MonadSymbolic m => VarContext -> Maybe String -> m (SBV [a]) Source #

literal :: [a] -> SBV [a] Source #

fromCV :: CV -> [a] Source #

isConcretely :: SBV [a] -> ([a] -> Bool) -> Bool Source #

forall :: MonadSymbolic m => String -> m (SBV [a]) Source #

forall_ :: MonadSymbolic m => m (SBV [a]) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV [a]] Source #

exists :: MonadSymbolic m => String -> m (SBV [a]) Source #

exists_ :: MonadSymbolic m => m (SBV [a]) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV [a]] 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 (Maybe a) Source # 
Instance details

Defined in Data.SBV.Core.Model

(Ord a, SymVal a) => SymVal (RCSet a) Source # 
Instance details

Defined in Data.SBV.Core.Model

(KnownNat n, BVIsNonZero n) => SymVal (IntN n) Source #

SymVal instance for IntN

Instance details

Defined in Data.SBV.Core.Sized

(KnownNat n, BVIsNonZero n) => SymVal (WordN n) Source #

SymVal instance for WordN

Instance details

Defined in Data.SBV.Core.Sized

(SymVal a, SymVal b) => SymVal (Either a b) Source # 
Instance details

Defined in Data.SBV.Core.Model

(SymVal a, SymVal b) => SymVal (a, b) Source #

SymVal for 2-tuples

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b)] 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 #

ValidFloat eb sb => SymVal (FloatingPoint eb sb) Source # 
Instance details

Defined in Data.SBV.Core.Model

(SymVal a, SymVal b, SymVal c) => SymVal (a, b, c) Source #

SymVal for 3-tuples

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c)] 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

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c, d)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c, d)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c, d)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c, d)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d)] 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

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c, d, e)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c, d, e)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e)] 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

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f)] 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

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g)] 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

Instance details

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 #

forall :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g, h)) Source #

forall_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g, h)) Source #

mkForallVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g, h)] Source #

exists :: MonadSymbolic m => String -> m (SBV (a, b, c, d, e, f, g, h)) Source #

exists_ :: MonadSymbolic m => m (SBV (a, b, c, d, e, f, g, h)) Source #

mkExistVars :: MonadSymbolic m => Int -> m [SBV (a, b, c, d, e, f, g, h)] 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 #

data CV Source #

CV represents a concrete word of a fixed size: For signed words, the most significant digit is considered to be the sign.

Constructors

CV 

Fields

Instances

Instances details
Eq CV Source # 
Instance details

Defined in Data.SBV.Core.Concrete

Methods

(==) :: CV -> CV -> Bool #

(/=) :: CV -> CV -> Bool #

Ord CV Source # 
Instance details

Defined in Data.SBV.Core.Concrete

Methods

compare :: CV -> CV -> Ordering #

(<) :: CV -> CV -> Bool #

(<=) :: CV -> CV -> Bool #

(>) :: CV -> CV -> Bool #

(>=) :: CV -> CV -> Bool #

max :: CV -> CV -> CV #

min :: CV -> CV -> CV #

Show CV Source #

Show instance for CV.

Instance details

Defined in Data.SBV.Core.Concrete

Methods

showsPrec :: Int -> CV -> ShowS #

show :: CV -> String #

showList :: [CV] -> ShowS #

NFData CV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: CV -> () #

HasKind CV Source #

Kind instance for CV

Instance details

Defined in Data.SBV.Core.Concrete

PrettyNum CV Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

SatModel CV Source #

CV as extracted from a model; trivial definition

Instance details

Defined in Data.SBV.SMT.SMT

Methods

parseCVs :: [CV] -> Maybe (CV, [CV]) Source #

cvtModel :: (CV -> Maybe b) -> Maybe (CV, [CV]) -> Maybe (b, [CV]) Source #

SDivisible CV Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

sQuotRem :: CV -> CV -> (CV, CV) Source #

sDivMod :: CV -> CV -> (CV, CV) Source #

sQuot :: CV -> CV -> CV Source #

sRem :: CV -> CV -> CV Source #

sDiv :: CV -> CV -> CV Source #

sMod :: CV -> CV -> CV Source #

data CVal Source #

A constant value

Constructors

CAlgReal !AlgReal

Algebraic real

CInteger !Integer

Bit-vector/unbounded integer

CFloat !Float

Float

CDouble !Double

Double

CFP !FP

Arbitrary float

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

Instances

Instances details
Eq CVal Source #

Eq instance for CVVal. 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:

Instance details

Defined in Data.SBV.Core.Concrete

Methods

(==) :: CVal -> CVal -> Bool #

(/=) :: CVal -> CVal -> Bool #

Ord CVal Source #

Ord instance for VWVal. Same comments as the Eq instance why this cannot be derived.

Instance details

Defined in Data.SBV.Core.Concrete

Methods

compare :: CVal -> CVal -> Ordering #

(<) :: CVal -> CVal -> Bool #

(<=) :: CVal -> CVal -> Bool #

(>) :: CVal -> CVal -> Bool #

(>=) :: CVal -> CVal -> Bool #

max :: CVal -> CVal -> CVal #

min :: CVal -> CVal -> CVal #

data AlgReal Source #

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

Instances details
Eq AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Methods

(==) :: AlgReal -> AlgReal -> Bool #

(/=) :: AlgReal -> AlgReal -> Bool #

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.

Instance details

Defined in Data.SBV.Core.Model

Fractional AlgReal Source #

NB: Following the other types we have, we require `a/0` to be `0` for all a.

Instance details

Defined in Data.SBV.Core.AlgReals

Num AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Ord AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Real AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Show AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Arbitrary AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Random AlgReal Source # 
Instance details

Defined in Data.SBV.Core.AlgReals

Methods

randomR :: RandomGen g => (AlgReal, AlgReal) -> g -> (AlgReal, g) #

random :: RandomGen g => g -> (AlgReal, g) #

randomRs :: RandomGen g => (AlgReal, AlgReal) -> g -> [AlgReal] #

randoms :: RandomGen g => g -> [AlgReal] #

HasKind AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Kind

SymVal AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Model

SatModel AlgReal Source #

AlgReal as extracted from a model

Instance details

Defined in Data.SBV.SMT.SMT

Methods

parseCVs :: [CV] -> Maybe (AlgReal, [CV]) Source #

cvtModel :: (AlgReal -> Maybe b) -> Maybe (AlgReal, [CV]) -> Maybe (b, [CV]) Source #

Metric AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Model

Associated Types

type MetricSpace AlgReal Source #

IEEEFloatConvertible AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Floating

type MetricSpace AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Model

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)] 

data ExtCV Source #

A simple expression type over extended values, covering infinity, epsilon and intervals.

Instances

Instances details
Show ExtCV Source #

Show instance, shows with the kind

Instance details

Defined in Data.SBV.Core.Concrete

Methods

showsPrec :: Int -> ExtCV -> ShowS #

show :: ExtCV -> String #

showList :: [ExtCV] -> ShowS #

HasKind ExtCV Source #

Kind instance for Extended CV

Instance details

Defined in Data.SBV.Core.Concrete

isRegularCV :: GeneralizedCV -> Bool Source #

Is this a regular CV?

cvSameType :: CV -> CV -> Bool Source #

Are two CV's of the same type?

cvToBool :: CV -> Bool Source #

Convert a CV to a Haskell boolean (NB. Assumes input is well-kinded)

mkConstCV :: Integral a => Kind -> a -> CV Source #

Create a constant word from an integral.

liftCV2 :: (AlgReal -> AlgReal -> b) -> (Integer -> Integer -> b) -> (Float -> Float -> b) -> (Double -> Double -> b) -> (FP -> FP -> b) -> (Char -> Char -> b) -> (String -> String -> b) -> ([CVal] -> [CVal] -> b) -> ([CVal] -> [CVal] -> b) -> (Maybe CVal -> Maybe CVal -> b) -> (Either CVal CVal -> Either CVal CVal -> b) -> ((Maybe Int, String) -> (Maybe Int, String) -> b) -> CV -> CV -> b Source #

Lift a binary function through a CV.

mapCV :: (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> (FP -> FP) -> (Char -> Char) -> (String -> String) -> ((Maybe Int, String) -> (Maybe Int, String)) -> 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) -> (Char -> Char -> Char) -> (String -> String -> String) -> ((Maybe Int, String) -> (Maybe Int, String) -> (Maybe Int, String)) -> CV -> CV -> CV Source #

Map a binary function through a CV.

data SV Source #

A symbolic word, tracking it's signedness and size.

Constructors

SV !Kind !NodeId 

Instances

Instances details
Eq SV Source #

For equality, we merely use the node-id

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: SV -> SV -> Bool #

(/=) :: SV -> SV -> Bool #

Data SV Source # 
Instance details

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 #

toConstr :: SV -> Constr #

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 #

Ord SV Source #

Again, simply use the node-id for ordering

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: SV -> SV -> Ordering #

(<) :: SV -> SV -> Bool #

(<=) :: SV -> SV -> Bool #

(>) :: SV -> SV -> Bool #

(>=) :: SV -> SV -> Bool #

max :: SV -> SV -> SV #

min :: SV -> SV -> SV #

Show SV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> SV -> ShowS #

show :: SV -> String #

showList :: [SV] -> ShowS #

NFData SV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SV -> () #

HasKind SV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

trueSV :: SV Source #

Constant True as an SV. Note that this value always occupies slot -1.

falseSV :: SV Source #

Constant False as an SV. Note that this value always occupies slot -2.

trueCV :: CV Source #

Constant True as a CV. We represent it using the integer value 1.

falseCV :: CV Source #

Constant False as a CV. We represent it using the integer value 0.

normCV :: CV -> CV Source #

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.)

data SVal 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.

Constructors

SVal !Kind !(Either CV (Cached SV)) 

Instances

Instances details
Eq SVal Source #

This instance is only defined so that we can define an instance for Bits. == and /= simply throw an error. We really don't want an Eq instance for SBV or SVal. As it really makes no sense. But since we do want the Bits instance, we're forced to define equality. See http://github.com/LeventErkok/sbv/issues/301. We simply error out.

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: SVal -> SVal -> Bool #

(/=) :: SVal -> SVal -> Bool #

Show SVal Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> SVal -> ShowS #

show :: SVal -> String #

showList :: [SVal] -> ShowS #

NFData SVal Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SVal -> () #

HasKind SVal Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

ArithOverflow SVal Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

Testable (Symbolic SVal) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

property :: Symbolic SVal -> Property #

propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Symbolic SVal) -> Property #

sTrue :: SBool Source #

Symbolic True

sNot :: SBool -> SBool Source #

Symbolic boolean negation

(.&&) :: SBool -> SBool -> SBool infixr 3 Source #

Symbolic conjunction

(.||) :: SBool -> SBool -> SBool infixr 2 Source #

Symbolic disjunction

(.<+>) :: SBool -> SBool -> SBool infixl 6 Source #

Symbolic logical xor

(.~&) :: SBool -> SBool -> SBool infixr 3 Source #

Symbolic nand

(.~|) :: SBool -> SBool -> SBool infixr 2 Source #

Symbolic nor

(.=>) :: SBool -> SBool -> SBool infixr 1 Source #

Symbolic implication

(.<=>) :: SBool -> SBool -> SBool infixr 1 Source #

Symbolic boolean equivalence

sAnd :: [SBool] -> SBool Source #

Generalization of and

sOr :: [SBool] -> SBool Source #

Generalization of or

sAny :: (a -> SBool) -> [a] -> SBool Source #

Generalization of any

sAll :: (a -> SBool) -> [a] -> SBool Source #

Generalization of all

fromBool :: Bool -> SBool Source #

Conversion from Bool to SBool

newtype SBV a Source #

The Symbolic value. The parameter a is phantom, but is extremely important in keeping the user interface strongly typed.

Constructors

SBV 

Fields

Instances

Instances details
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.

Instance details

Defined in Data.SBV.Core.Model

IsString SString Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

fromString :: String -> SString #

Testable SBool Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

property :: SBool -> Property #

propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> SBool) -> Property #

SDivisible SInteger Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SInt64 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SInt32 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SInt16 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SInt8 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SWord64 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SWord32 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SWord16 Source # 
Instance details

Defined in Data.SBV.Core.Model

SDivisible SWord8 Source # 
Instance details

Defined in Data.SBV.Core.Model

Polynomial SWord64 Source # 
Instance details

Defined in Data.SBV.Tools.Polynomial

Polynomial SWord32 Source # 
Instance details

Defined in Data.SBV.Tools.Polynomial

Polynomial SWord16 Source # 
Instance details

Defined in Data.SBV.Tools.Polynomial

Polynomial SWord8 Source # 
Instance details

Defined in Data.SBV.Tools.Polynomial

ArithOverflow SInt64 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SInt32 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SInt16 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SInt8 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SWord64 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SWord32 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SWord16 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

ArithOverflow SWord8 Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

RegExpMatchable SString Source #

Matching symbolic strings.

Instance details

Defined in Data.SBV.RegExp

Methods

match :: SString -> RegExp -> SBool Source #

RegExpMatchable SChar Source #

Matching a character simply means the singleton string matches the regex.

Instance details

Defined in Data.SBV.RegExp

Methods

match :: SChar -> RegExp -> SBool Source #

ExtractIO m => MProvable m SBool Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Fresh IO (S SInteger) Source #

Fresh instance for our state

Instance details

Defined in Documentation.SBV.Examples.ProofTools.BMC

Fresh IO (S SInteger) Source #

Fresh instance for our state

Instance details

Defined in Documentation.SBV.Examples.ProofTools.Fibonacci

Fresh IO (S SInteger) Source #

Fresh instance for our state

Instance details

Defined in Documentation.SBV.Examples.ProofTools.Strengthen

Fresh IO (S SInteger) Source #

Fresh instance for our state

Instance details

Defined in Documentation.SBV.Examples.ProofTools.Sum

SymVal a => Fresh IO (IncS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Basics

Methods

fresh :: QueryT IO (IncS (SBV a)) Source #

SymVal a => Fresh IO (FibS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Fib

Methods

fresh :: QueryT IO (FibS (SBV a)) Source #

SymVal a => Fresh IO (GCDS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.GCD

Methods

fresh :: QueryT IO (GCDS (SBV a)) Source #

SymVal a => Fresh IO (DivS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.IntDiv

Methods

fresh :: QueryT IO (DivS (SBV a)) Source #

SymVal a => Fresh IO (SqrtS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.IntSqrt

Methods

fresh :: QueryT IO (SqrtS (SBV a)) Source #

SymVal a => Fresh IO (SumS (SBV a)) Source #

Fresh instance for the program state

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Sum

Methods

fresh :: QueryT IO (SumS (SBV a)) Source #

ExtractIO m => SExecutable m [SBV a] Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: [SBV a] -> SymbolicT m () Source #

sName :: [String] -> [SBV a] -> SymbolicT m () Source #

safe :: [SBV a] -> m [SafeResult] Source #

safeWith :: SMTConfig -> [SBV a] -> m [SafeResult] Source #

ExtractIO m => SExecutable m (SBV a) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: SBV a -> SymbolicT m () Source #

sName :: [String] -> SBV a -> SymbolicT m () Source #

safe :: SBV a -> m [SafeResult] Source #

safeWith :: SMTConfig -> SBV a -> m [SafeResult] Source #

(MonadIO m, SymVal a) => Queriable m (SBV a) a Source #

Generic Queriable instance for SymVal values

Instance details

Defined in Data.SBV.Control.Utils

Methods

create :: QueryT m (SBV a) Source #

project :: SBV a -> QueryT m a Source #

embed :: a -> QueryT m (SBV a) Source #

(MonadIO m, SymVal a, Foldable t, Traversable t, Fresh m (t (SBV a))) => Queriable m (t (SBV a)) (t a) Source #

Generic Queriable instance for things that are Fresh and look like containers:

Instance details

Defined in Data.SBV.Control.Utils

Methods

create :: QueryT m (t (SBV a)) Source #

project :: t (SBV a) -> QueryT m (t a) Source #

embed :: t a -> QueryT m (t (SBV a)) Source #

(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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m [SafeResult] Source #

(SymVal a, SymVal b, SymVal c, SymVal d, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> m [SafeResult] Source #

(SymVal a, SymVal b, SymVal c, SExecutable m p) => SExecutable m ((SBV a, SBV b, SBV c) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b, SBV c) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m [SafeResult] Source #

(SymVal a, SymVal b, SExecutable m p) => SExecutable m ((SBV a, SBV b) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: ((SBV a, SBV b) -> p) -> SymbolicT m () Source #

sName :: [String] -> ((SBV a, SBV b) -> p) -> SymbolicT m () Source #

safe :: ((SBV a, SBV b) -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m [SafeResult] Source #

(SymVal a, SExecutable m p) => SExecutable m (SBV a -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a -> p) -> SymbolicT m () Source #

sName :: [String] -> (SBV a -> p) -> SymbolicT m () Source #

safe :: (SBV a -> p) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a -> p) -> m [SafeResult] Source #

(ExtractIO m, NFData a, SymVal a, NFData b, SymVal b) => SExecutable m (SBV a, SBV b) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b) -> SymbolicT m () Source #

safe :: (SBV a, SBV b) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b) -> m [SafeResult] Source #

(SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, SymVal g, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

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 #

isVacuous :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> m Bool Source #

isVacuousWith :: 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 #

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 #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, SymVal f, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

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 #

isVacuous :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> m Bool Source #

isVacuousWith :: 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 #

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 #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, SymVal b, SymVal c, SymVal d, SymVal e, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

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 #

isVacuous :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> m Bool Source #

isVacuousWith :: 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 #

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 #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, SymVal b, SymVal c, SymVal d, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c, SBV d) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

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 #

isVacuous :: ((SBV a, SBV b, SBV c, SBV d) -> p) -> m Bool Source #

isVacuousWith :: 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 #

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 #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b, SBV c, SBV d) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, SymVal b, SymVal c, MProvable m p) => MProvable m ((SBV a, SBV b, SBV c) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b, SBV c) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

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 #

isVacuous :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source #

isVacuousWith :: 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 #

isSatisfiable :: ((SBV a, SBV b, SBV c) -> p) -> m Bool Source #

isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> m Bool Source #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b, SBV c) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, SymVal b, MProvable m p) => MProvable m ((SBV a, SBV b) -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source #

forSome_ :: ((SBV a, SBV b) -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> ((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 #

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 #

optimize :: OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source #

optimizeWith :: SMTConfig -> OptimizeStyle -> ((SBV a, SBV b) -> p) -> m OptimizeResult Source #

isVacuous :: ((SBV a, SBV b) -> p) -> m Bool Source #

isVacuousWith :: 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 #

isSatisfiable :: ((SBV a, SBV b) -> p) -> m Bool Source #

isSatisfiableWith :: SMTConfig -> ((SBV a, SBV b) -> p) -> m Bool Source #

validate :: Bool -> SMTConfig -> ((SBV a, SBV b) -> p) -> SMTResult -> m SMTResult Source #

(SymVal a, MProvable m p) => MProvable m (SBV a -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: (SBV a -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> (SBV a -> p) -> SymbolicT m SBool Source #

forSome_ :: (SBV a -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> (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 #

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 #

optimize :: OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source #

optimizeWith :: SMTConfig -> OptimizeStyle -> (SBV a -> p) -> m OptimizeResult Source #

isVacuous :: (SBV a -> p) -> m Bool Source #

isVacuousWith :: SMTConfig -> (SBV a -> p) -> m Bool Source #

isTheorem :: (SBV a -> p) -> m Bool Source #

isTheoremWith :: SMTConfig -> (SBV a -> p) -> m Bool Source #

isSatisfiable :: (SBV a -> p) -> m Bool Source #

isSatisfiableWith :: SMTConfig -> (SBV a -> p) -> m Bool Source #

validate :: Bool -> SMTConfig -> (SBV a -> p) -> SMTResult -> m SMTResult Source #

ExtractIO m => MProvable m (SymbolicT m SBool) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

(ExtractIO m, NFData a, SymVal a, NFData b, SymVal b, NFData c, SymVal c) => SExecutable m (SBV a, SBV b, SBV c) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b, SBV c) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b, SBV c) -> SymbolicT m () Source #

safe :: (SBV a, SBV b, SBV c) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b, SBV c) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b, SBV c, SBV d) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b, SBV c, SBV d) -> SymbolicT m () Source #

safe :: (SBV a, SBV b, SBV c, SBV d) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b, SBV c, SBV d) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b, SBV c, SBV d, SBV e) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b, SBV c, SBV d, SBV e) -> SymbolicT m () Source #

safe :: (SBV a, SBV b, SBV c, SBV d, SBV e) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b, SBV c, SBV d, SBV e) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> SymbolicT m () Source #

safe :: (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> m [SafeResult] 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 # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

sName_ :: (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> SymbolicT m () Source #

sName :: [String] -> (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> SymbolicT m () Source #

safe :: (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> m [SafeResult] Source #

safeWith :: SMTConfig -> (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> m [SafeResult] Source #

SymVal [a] => IsList (SList a) Source #

IsList instance allows list literals to be written compactly.

Instance details

Defined in Data.SBV.Core.Data

Associated Types

type Item (SList a) #

Methods

fromList :: [Item (SList a)] -> SList a #

fromListN :: Int -> [Item (SList a)] -> SList a #

toList :: SList a -> [Item (SList a)] #

(SymVal a, Bounded a) => Bounded (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

minBound :: SBV a #

maxBound :: SBV a #

(Show a, Bounded a, Integral a, Num a, SymVal a) => Enum (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

succ :: SBV a -> SBV a #

pred :: SBV a -> SBV a #

toEnum :: Int -> SBV a #

fromEnum :: SBV a -> Int #

enumFrom :: SBV a -> [SBV a] #

enumFromThen :: SBV a -> SBV a -> [SBV a] #

enumFromTo :: SBV a -> SBV a -> [SBV a] #

enumFromThenTo :: SBV a -> SBV a -> SBV a -> [SBV a] #

Eq (SBV a) Source #

This instance is only defined so that we can define an instance for Bits. == and /= simply throw an error. Use EqSymbolic instead.

Instance details

Defined in Data.SBV.Core.Data

Methods

(==) :: SBV a -> SBV a -> Bool #

(/=) :: SBV a -> SBV a -> Bool #

(Ord 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., SFloat, SDouble, and SReal. (See the separate definition below for SFloatingPoint.) Note that unless you use delta-sat via dReal on SReal, most of the fields are "undefined" for symbolic values. We will add methods as they are supported by SMTLib. Currently, the only symbolically available function in this class is sqrt for SFloat, SDouble and SFloatingPoint.

Instance details

Defined in Data.SBV.Core.Model

Methods

pi :: SBV a #

exp :: SBV a -> SBV a #

log :: SBV a -> SBV a #

sqrt :: SBV a -> SBV a #

(**) :: SBV a -> SBV a -> SBV a #

logBase :: SBV a -> SBV a -> SBV a #

sin :: SBV a -> SBV a #

cos :: SBV a -> SBV a #

tan :: SBV a -> SBV a #

asin :: SBV a -> SBV a #

acos :: SBV a -> SBV a #

atan :: SBV a -> SBV a #

sinh :: SBV a -> SBV a #

cosh :: SBV a -> SBV a #

tanh :: SBV a -> SBV a #

asinh :: SBV a -> SBV a #

acosh :: SBV a -> SBV a #

atanh :: SBV a -> SBV a #

log1p :: SBV a -> SBV a #

expm1 :: SBV a -> SBV a #

log1pexp :: SBV a -> SBV a #

log1mexp :: SBV a -> SBV a #

(Ord a, SymVal a, Fractional a) => Fractional (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(/) :: SBV a -> SBV a -> SBV a #

recip :: SBV a -> SBV a #

fromRational :: Rational -> SBV a #

(Ord a, Num a, SymVal a) => Num (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(+) :: SBV a -> SBV a -> SBV a #

(-) :: SBV a -> SBV a -> SBV a #

(*) :: SBV a -> SBV a -> SBV a #

negate :: SBV a -> SBV a #

abs :: SBV a -> SBV a #

signum :: SBV a -> SBV a #

fromInteger :: Integer -> SBV a #

Show (SBV a) Source #

A Show instance is not particularly "desirable," when the value is symbolic, but we do need this instance as otherwise we cannot simply evaluate Haskell functions that return symbolic values and have their constant values printed easily!

Instance details

Defined in Data.SBV.Core.Data

Methods

showsPrec :: Int -> SBV a -> ShowS #

show :: SBV a -> String #

showList :: [SBV a] -> ShowS #

(SymVal a, Show a) => Show (IncS (SBV a)) Source #

Show instance for IncS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Basics

Methods

showsPrec :: Int -> IncS (SBV a) -> ShowS #

show :: IncS (SBV a) -> String #

showList :: [IncS (SBV a)] -> ShowS #

(SymVal a, Show a) => Show (FibS (SBV a)) Source #

Show instance for FibS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Fib

Methods

showsPrec :: Int -> FibS (SBV a) -> ShowS #

show :: FibS (SBV a) -> String #

showList :: [FibS (SBV a)] -> ShowS #

(SymVal a, Show a) => Show (GCDS (SBV a)) Source #

Show instance for GCDS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.GCD

Methods

showsPrec :: Int -> GCDS (SBV a) -> ShowS #

show :: GCDS (SBV a) -> String #

showList :: [GCDS (SBV a)] -> ShowS #

(SymVal a, Show a) => Show (DivS (SBV a)) Source #

Show instance for DivS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.IntDiv

Methods

showsPrec :: Int -> DivS (SBV a) -> ShowS #

show :: DivS (SBV a) -> String #

showList :: [DivS (SBV a)] -> ShowS #

(SymVal a, Show a) => Show (SqrtS (SBV a)) Source #

Show instance for SqrtS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.IntSqrt

Methods

showsPrec :: Int -> SqrtS (SBV a) -> ShowS #

show :: SqrtS (SBV a) -> String #

showList :: [SqrtS (SBV a)] -> ShowS #

(SymVal a, Show a) => Show (SumS (SBV a)) Source #

Show instance for SumS. The above deriving clause would work just as well, but we want it to be a little prettier here, and hence the OVERLAPS directive.

Instance details

Defined in Documentation.SBV.Examples.WeakestPreconditions.Sum

Methods

showsPrec :: Int -> SumS (SBV a) -> ShowS #

show :: SumS (SBV a) -> String #

showList :: [SumS (SBV a)] -> ShowS #

Generic (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Associated Types

type Rep (SBV a) :: Type -> Type #

Methods

from :: SBV a -> Rep (SBV a) x #

to :: Rep (SBV a) x -> SBV a #

Testable (Symbolic SBool) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

property :: Symbolic SBool -> Property #

propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Symbolic SBool) -> Property #

(SymVal a, Arbitrary a) => Arbitrary (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

arbitrary :: Gen (SBV a) #

shrink :: SBV a -> [SBV a] #

(Ord a, Num a, Bits a, SymVal a) => Bits (SBV a) Source #

Using popCount or testBit on non-concrete values will result in an error. Use sPopCount or sTestBit instead.

Instance details

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 #

zeroBits :: SBV a #

bit :: 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 #

bitSize :: SBV a -> Int #

isSigned :: SBV a -> Bool #

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 #

rotateR :: SBV a -> Int -> SBV a #

popCount :: SBV a -> Int #

NFData (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

rnf :: SBV a -> () #

(Random a, SymVal a) => Random (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

randomR :: RandomGen g => (SBV a, SBV a) -> g -> (SBV a, g) #

random :: RandomGen g => g -> (SBV a, g) #

randomRs :: RandomGen g => (SBV a, SBV a) -> g -> [SBV a] #

randoms :: RandomGen g => g -> [SBV a] #

HasKind a => HasKind (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Outputtable (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

output :: MonadSymbolic m => SBV a -> m (SBV a) Source #

(SymVal a, PrettyNum a) => PrettyNum (SBV a) Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

Methods

hexS :: SBV a -> String Source #

binS :: SBV a -> String Source #

hexP :: SBV a -> String Source #

binP :: SBV a -> String Source #

hex :: SBV a -> String Source #

bin :: SBV a -> String Source #

HasKind a => Uninterpreted (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

SymVal a => Mergeable (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

symbolicMerge :: Bool -> SBool -> SBV a -> SBV a -> SBV a Source #

select :: (Ord b, SymVal b, Num b) => [SBV a] -> SBV a -> SBV b -> SBV a Source #

(KnownNat n, BVIsNonZero n) => SDivisible (SInt n) Source #

SDivisible instance for SInt

Instance details

Defined in Data.SBV.Core.Sized

Methods

sQuotRem :: SInt n -> SInt n -> (SInt n, SInt n) Source #

sDivMod :: SInt n -> SInt n -> (SInt n, SInt n) Source #

sQuot :: SInt n -> SInt n -> SInt n Source #

sRem :: SInt n -> SInt n -> SInt n Source #

sDiv :: SInt n -> SInt n -> SInt n Source #

sMod :: SInt n -> SInt n -> SInt n Source #

(KnownNat n, BVIsNonZero n) => SDivisible (SWord n) Source #

SDivisible instance for SWord

Instance details

Defined in Data.SBV.Core.Sized

Methods

sQuotRem :: SWord n -> SWord n -> (SWord n, SWord n) Source #

sDivMod :: SWord n -> SWord n -> (SWord n, SWord n) Source #

sQuot :: SWord n -> SWord n -> SWord n Source #

sRem :: SWord n -> SWord n -> SWord n Source #

sDiv :: SWord n -> SWord n -> SWord n Source #

sMod :: SWord n -> SWord n -> SWord n Source #

(Ord a, SymVal a) => OrdSymbolic (SBV a) Source #

If comparison is over something SMTLib can handle, just translate it. Otherwise desugar.

Instance details

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 #

smin :: SBV a -> SBV a -> SBV a Source #

smax :: SBV a -> SBV a -> SBV a Source #

inRange :: SBV a -> (SBV a, SBV a) -> SBool Source #

EqSymbolic (SBV a) Source # 
Instance details

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 #

sElem :: SBV a -> [SBV a] -> SBool Source #

sNotElem :: SBV a -> [SBV a] -> SBool Source #

ByteConverter (SWord 8) Source #

SWord 8 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 8 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 8 Source #

ByteConverter (SWord 16) Source #

SWord 16 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 16 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 16 Source #

ByteConverter (SWord 32) Source #

SWord 32 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 32 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 32 Source #

ByteConverter (SWord 64) Source #

SWord 64 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 64 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 64 Source #

ByteConverter (SWord 128) Source #

SWord 128 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 128 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 128 Source #

ByteConverter (SWord 256) Source #

SWord 256 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 256 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 256 Source #

ByteConverter (SWord 512) Source #

SWord 512 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 512 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 512 Source #

ByteConverter (SWord 1024) Source #

SWord 1024 instance for ByteConverter

Instance details

Defined in Data.SBV.Core.Sized

Methods

toBytes :: SWord 1024 -> [SWord 8] Source #

fromBytes :: [SWord 8] -> SWord 1024 Source #

(KnownNat n, BVIsNonZero n) => Polynomial (SWord n) Source # 
Instance details

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 #

showPoly :: SWord n -> String Source #

showPolynomial :: Bool -> SWord n -> String Source #

(KnownNat n, BVIsNonZero n) => ArithOverflow (SInt n) Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

Methods

bvAddO :: SInt n -> SInt n -> (SBool, SBool) Source #

bvSubO :: SInt n -> SInt n -> (SBool, SBool) Source #

bvMulO :: SInt n -> SInt n -> (SBool, SBool) Source #

bvMulOFast :: SInt n -> SInt n -> (SBool, SBool) Source #

bvDivO :: SInt n -> SInt n -> (SBool, SBool) Source #

bvNegO :: SInt n -> (SBool, SBool) Source #

(KnownNat n, BVIsNonZero n) => ArithOverflow (SWord n) Source # 
Instance details

Defined in Data.SBV.Tools.Overflow

Methods

bvAddO :: SWord n -> SWord n -> (SBool, SBool) Source #

bvSubO :: SWord n -> SWord n -> (SBool, SBool) Source #

bvMulO :: SWord n -> SWord n -> (SBool, SBool) Source #

bvMulOFast :: SWord n -> SWord n -> (SBool, SBool) Source #

bvDivO :: SWord n -> SWord n -> (SBool, SBool) Source #

bvNegO :: SWord n -> (SBool, SBool) Source #

ValidFloat eb sb => Floating (SFloatingPoint eb sb) Source #

We give a specific instance for SFloatingPoint, because the underlying floating-point type doesn't support fromRational directly. The overlap with the above instance is unfortunate.

Instance details

Defined in Data.SBV.Core.Model

(SymVal a, SymVal b, EqSymbolic z) => Equality ((SBV a, SBV b) -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b) -> z) -> ((SBV a, SBV b) -> z) -> IO ThmResult Source #

(SymVal a, SymVal b, SymVal c, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c) -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b, SBV c) -> z) -> ((SBV a, SBV b, SBV c) -> z) -> IO ThmResult Source #

(SymVal a, SymVal b, SymVal c, SymVal d, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d) -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b, SBV c, SBV d) -> z) -> ((SBV a, SBV b, SBV c, SBV d) -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b, SBV c, SBV d, SBV e) -> z) -> ((SBV a, SBV b, SBV c, SBV d, SBV e) -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> z) -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> z) -> ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> z) -> (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> z) -> (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> z) -> IO ThmResult 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 # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) -> (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) -> IO ThmResult Source #

(SymVal a, SymVal b, SymVal c, SymVal d, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> SBV c -> SBV d -> z) -> (SBV a -> SBV b -> SBV c -> SBV d -> z) -> IO ThmResult Source #

(SymVal a, SymVal b, SymVal c, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> SBV c -> z) -> (SBV a -> SBV b -> SBV c -> z) -> IO ThmResult Source #

(SymVal a, SymVal b, EqSymbolic z) => Equality (SBV a -> SBV b -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> SBV b -> z) -> (SBV a -> SBV b -> z) -> IO ThmResult Source #

(SymVal a, EqSymbolic z) => Equality (SBV a -> z) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(===) :: (SBV a -> z) -> (SBV a -> z) -> IO ThmResult Source #

(SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: String -> (SBV c, SBV b) -> SBV a Source #

cgUninterpret :: String -> [String] -> ((SBV c, SBV b) -> SBV a) -> (SBV c, SBV b) -> SBV a Source #

sbvUninterpret :: Maybe ([String], (SBV c, SBV b) -> SBV a) -> String -> (SBV c, SBV b) -> SBV a Source #

sym :: String -> (SBV c, SBV b) -> SBV a Source #

(SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV d, SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], (SBV d, SBV c, SBV b) -> SBV a) -> String -> (SBV d, SBV c, SBV b) -> SBV a Source #

sym :: String -> (SBV d, SBV c, SBV b) -> SBV a Source #

(SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], (SBV e, SBV d, SBV c, SBV b) -> SBV a) -> String -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source #

sym :: String -> (SBV e, SBV d, SBV c, SBV b) -> SBV a Source #

(SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], (SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> String -> (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 #

(SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], (SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> String -> (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 #

(SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], (SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) -> String -> (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 #

(SymVal h, SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> String -> 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 #

(SymVal g, SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> String -> 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 #

(SymVal f, SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> String -> 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 #

(SymVal e, SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], SBV e -> SBV d -> SBV c -> SBV b -> SBV a) -> String -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source #

sym :: String -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a Source #

(SymVal d, SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV d -> SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: 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 #

sbvUninterpret :: Maybe ([String], SBV d -> SBV c -> SBV b -> SBV a) -> String -> SBV d -> SBV c -> SBV b -> SBV a Source #

sym :: String -> SBV d -> SBV c -> SBV b -> SBV a Source #

(SymVal c, SymVal b, HasKind a) => Uninterpreted (SBV c -> SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: String -> SBV c -> SBV b -> SBV a Source #

cgUninterpret :: String -> [String] -> (SBV c -> SBV b -> SBV a) -> SBV c -> SBV b -> SBV a Source #

sbvUninterpret :: Maybe ([String], SBV c -> SBV b -> SBV a) -> String -> SBV c -> SBV b -> SBV a Source #

sym :: String -> SBV c -> SBV b -> SBV a Source #

(SymVal b, HasKind a) => Uninterpreted (SBV b -> SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

uninterpret :: String -> SBV b -> SBV a Source #

cgUninterpret :: String -> [String] -> (SBV b -> SBV a) -> SBV b -> SBV a Source #

sbvUninterpret :: Maybe ([String], SBV b -> SBV a) -> String -> SBV b -> SBV a Source #

sym :: String -> SBV b -> SBV a Source #

SymVal e => Mergeable (STree i e) Source # 
Instance details

Defined in Data.SBV.Tools.STree

Methods

symbolicMerge :: Bool -> SBool -> STree i e -> STree i e -> STree i e Source #

select :: (Ord b, SymVal b, Num b) => [STree i e] -> STree i e -> SBV b -> STree i e Source #

type Rep (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

type Rep (SBV a) = D1 ('MetaData "SBV" "Data.SBV.Core.Data" "sbv-8.12-86sGFtUuaUAKiWFK6rsFH6" 'True) (C1 ('MetaCons "SBV" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSBV") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SVal)))
type Item (SList a) Source # 
Instance details

Defined in Data.SBV.Core.Data

type Item (SList a) = a

newtype NodeId Source #

A symbolic node id

Constructors

NodeId 

Fields

Instances

Instances details
Eq NodeId Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: NodeId -> NodeId -> Bool #

(/=) :: NodeId -> NodeId -> Bool #

Data NodeId Source # 
Instance details

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 #

Ord NodeId Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

mkSymSBV :: forall a m. MonadSymbolic m => VarContext -> Kind -> Maybe String -> m (SBV a) Source #

Generalization of mkSymSBV

data ArrayContext Source #

The context of a symbolic array as created

Constructors

ArrayFree (Maybe SV)

A new array, the contents are initialized with the given value, if any

ArrayMutate ArrayIndex SV SV

An array created by mutating another array at a given cell

ArrayMerge SV ArrayIndex ArrayIndex

An array created by symbolically merging two other arrays

Instances

Instances details
Show ArrayContext Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData ArrayContext Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: ArrayContext -> () #

type ArrayInfo = (String, (Kind, Kind), ArrayContext) Source #

Representation for symbolic arrays

class SymArray array where Source #

Flat arrays of symbolic values An array a b is an array indexed by the type SBV a, with elements of type SBV b.

If a default value is supplied, then all the array elements will be initialized to this value. Otherwise, they will be left unspecified, i.e., a read from an unwritten location will produce an uninterpreted constant.

While it's certainly possible for user to create instances of SymArray, the SArray and SFunArray instances already provided should cover most use cases in practice. Note that there are a few differences between these two models in terms of use models:

  • SArray produces SMTLib arrays, and requires a solver that understands the array theory. SFunArray is internally handled, and thus can be used with any solver. (Note that all solvers except abc support arrays, so this isn't a big decision factor.)
  • For both arrays, if a default value is supplied, then reading from uninitialized cell will return that value. If the default is not given, then reading from uninitialized cells is still OK for both arrays, and will produce an uninterpreted constant in both cases.
  • Only SArray supports checking equality of arrays. (That is, checking if an entire array is equivalent to another.) SFunArrays cannot be checked for equality. In general, checking wholesale equality of arrays is a difficult decision problem and should be avoided if possible.
  • Only SFunArray supports compilation to C. Programs using SArray will not be accepted by the C-code generator.
  • You cannot use quickcheck on programs that contain these arrays. (Neither SArray nor SFunArray.)
  • With SArray, SBV transfers all array-processing to the SMT-solver. So, it can generate programs more quickly, but they might end up being too hard for the solver to handle. With SFunArray, SBV only generates code for individual elements and the array itself never shows up in the resulting SMTLib program. This puts more onus on the SBV side and might have some performance impacts, but it might generate problems that are easier for the SMT solvers to handle.

As a rule of thumb, try SArray first. These should generate compact code. However, if the backend solver has hard time solving the generated problems, switch to SFunArray. If you still have issues, please report so we can see what the problem might be!

NB. sListArray insists on a concrete initializer, because not having one would break referential transparency. See https://github.com/LeventErkok/sbv/issues/553 for details.

Methods

newArray_ :: (MonadSymbolic m, HasKind a, HasKind b) => Maybe (SBV b) -> m (array a b) Source #

Generalization of newArray_

newArray :: (MonadSymbolic m, HasKind a, HasKind b) => String -> Maybe (SBV b) -> m (array a b) Source #

Generalization of newArray

sListArray :: (HasKind a, SymVal b) => b -> [(SBV a, SBV b)] -> array a b Source #

Create a literal array

readArray :: array a b -> SBV a -> SBV b Source #

Read the array element at a

writeArray :: SymVal b => array a b -> SBV a -> SBV b -> array a b Source #

Update the element at a to be b

mergeArrays :: SymVal b => SBV Bool -> array a b -> array a b -> array a b Source #

Merge two given arrays on the symbolic condition Intuitively: mergeArrays cond a b = if cond then a else b. Merging pushes the if-then-else choice down on to elements

newArrayInState :: (HasKind a, HasKind b) => Maybe String -> Maybe (SBV b) -> State -> IO (array a b) Source #

Internal function, not exported to the user

Instances

Instances details
SymArray SFunArray Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

newArray_ :: (MonadSymbolic m, HasKind a, HasKind b) => Maybe (SBV b) -> m (SFunArray a b) Source #

newArray :: (MonadSymbolic m, HasKind a, HasKind b) => String -> Maybe (SBV b) -> m (SFunArray a b) Source #

sListArray :: (HasKind a, SymVal b) => b -> [(SBV a, SBV b)] -> SFunArray a b Source #

readArray :: SFunArray a b -> SBV a -> SBV b Source #

writeArray :: SymVal b => SFunArray a b -> SBV a -> SBV b -> SFunArray a b Source #

mergeArrays :: SymVal b => SBV Bool -> SFunArray a b -> SFunArray a b -> SFunArray a b Source #

newArrayInState :: (HasKind a, HasKind b) => Maybe String -> Maybe (SBV b) -> State -> IO (SFunArray a b) Source #

SymArray SArray Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

newArray_ :: (MonadSymbolic m, HasKind a, HasKind b) => Maybe (SBV b) -> m (SArray a b) Source #

newArray :: (MonadSymbolic m, HasKind a, HasKind b) => String -> Maybe (SBV b) -> m (SArray a b) Source #

sListArray :: (HasKind a, SymVal b) => b -> [(SBV a, SBV b)] -> SArray a b Source #

readArray :: SArray a b -> SBV a -> SBV b Source #

writeArray :: SymVal b => SArray a b -> SBV a -> SBV b -> SArray a b Source #

mergeArrays :: SymVal b => SBV Bool -> SArray a b -> SArray a b -> SArray a b Source #

newArrayInState :: (HasKind a, HasKind b) => Maybe String -> Maybe (SBV b) -> State -> IO (SArray a b) Source #

newtype SFunArray a b Source #

Arrays implemented internally, without translating to SMT-Lib functions:

  • Internally handled by the library and not mapped to SMT-Lib, hence can be used with solvers that don't support arrays. (Such as abc.)
  • Reading from an unintialized value is OK. If the default value is given in newArray, it will be the result. Otherwise, the read yields an uninterpreted constant.
  • Cannot check for equality of arrays.
  • Can be used in code-generation (i.e., compilation to C).
  • Can not quick-check theorems using SFunArray values
  • Typically faster as it gets compiled away during translation.

Constructors

SFunArray 

Fields

Instances

Instances details
SymArray SFunArray Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

newArray_ :: (MonadSymbolic m, HasKind a, HasKind b) => Maybe (SBV b) -> m (SFunArray a b) Source #

newArray :: (MonadSymbolic m, HasKind a, HasKind b) => String -> Maybe (SBV b) -> m (SFunArray a b) Source #

sListArray :: (HasKind a, SymVal b) => b -> [(SBV a, SBV b)] -> SFunArray a b Source #

readArray :: SFunArray a b -> SBV a -> SBV b Source #

writeArray :: SymVal b => SFunArray a b -> SBV a -> SBV b -> SFunArray a b Source #

mergeArrays :: SymVal b => SBV Bool -> SFunArray a b -> SFunArray a b -> SFunArray a b Source #

newArrayInState :: (HasKind a, HasKind b) => Maybe String -> Maybe (SBV b) -> State -> IO (SFunArray a b) Source #

(HasKind a, HasKind b, MProvable m p) => MProvable m (SFunArray a b -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: (SFunArray a b -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> (SFunArray a b -> p) -> SymbolicT m SBool Source #

forSome_ :: (SFunArray a b -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> (SFunArray a b -> p) -> SymbolicT m SBool Source #

prove :: (SFunArray a b -> p) -> m ThmResult Source #

proveWith :: SMTConfig -> (SFunArray a b -> p) -> m ThmResult Source #

dprove :: (SFunArray a b -> p) -> m ThmResult Source #

dproveWith :: SMTConfig -> (SFunArray a b -> p) -> m ThmResult Source #

sat :: (SFunArray a b -> p) -> m SatResult Source #

satWith :: SMTConfig -> (SFunArray a b -> p) -> m SatResult Source #

dsat :: (SFunArray a b -> p) -> m SatResult Source #

dsatWith :: SMTConfig -> (SFunArray a b -> p) -> m SatResult Source #

allSat :: (SFunArray a b -> p) -> m AllSatResult Source #

allSatWith :: SMTConfig -> (SFunArray a b -> p) -> m AllSatResult Source #

optimize :: OptimizeStyle -> (SFunArray a b -> p) -> m OptimizeResult Source #

optimizeWith :: SMTConfig -> OptimizeStyle -> (SFunArray a b -> p) -> m OptimizeResult Source #

isVacuous :: (SFunArray a b -> p) -> m Bool Source #

isVacuousWith :: SMTConfig -> (SFunArray a b -> p) -> m Bool Source #

isTheorem :: (SFunArray a b -> p) -> m Bool Source #

isTheoremWith :: SMTConfig -> (SFunArray a b -> p) -> m Bool Source #

isSatisfiable :: (SFunArray a b -> p) -> m Bool Source #

isSatisfiableWith :: SMTConfig -> (SFunArray a b -> p) -> m Bool Source #

validate :: Bool -> SMTConfig -> (SFunArray a b -> p) -> SMTResult -> m SMTResult Source #

(HasKind a, HasKind b) => Show (SFunArray a b) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

showsPrec :: Int -> SFunArray a b -> ShowS #

show :: SFunArray a b -> String #

showList :: [SFunArray a b] -> ShowS #

SymVal b => Mergeable (SFunArray a b) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

symbolicMerge :: Bool -> SBool -> SFunArray a b -> SFunArray a b -> SFunArray a b Source #

select :: (Ord b0, SymVal b0, Num b0) => [SFunArray a b] -> SFunArray a b -> SBV b0 -> SFunArray a b Source #

newtype SArray a b Source #

Arrays implemented in terms of SMT-arrays: http://smtlib.cs.uiowa.edu/theories-ArraysEx.shtml

  • Maps directly to SMT-lib arrays
  • Reading from an unintialized value is OK. If the default value is given in newArray, it will be the result. Otherwise, the read yields an uninterpreted constant.
  • Can check for equality of these arrays
  • Cannot be used in code-generation (i.e., compilation to C)
  • Cannot quick-check theorems using SArray values
  • Typically slower as it heavily relies on SMT-solving for the array theory

Constructors

SArray 

Fields

Instances

Instances details
SymArray SArray Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

newArray_ :: (MonadSymbolic m, HasKind a, HasKind b) => Maybe (SBV b) -> m (SArray a b) Source #

newArray :: (MonadSymbolic m, HasKind a, HasKind b) => String -> Maybe (SBV b) -> m (SArray a b) Source #

sListArray :: (HasKind a, SymVal b) => b -> [(SBV a, SBV b)] -> SArray a b Source #

readArray :: SArray a b -> SBV a -> SBV b Source #

writeArray :: SymVal b => SArray a b -> SBV a -> SBV b -> SArray a b Source #

mergeArrays :: SymVal b => SBV Bool -> SArray a b -> SArray a b -> SArray a b Source #

newArrayInState :: (HasKind a, HasKind b) => Maybe String -> Maybe (SBV b) -> State -> IO (SArray a b) Source #

(HasKind a, HasKind b, MProvable m p) => MProvable m (SArray a b -> p) Source # 
Instance details

Defined in Data.SBV.Provers.Prover

Methods

forAll_ :: (SArray a b -> p) -> SymbolicT m SBool Source #

forAll :: [String] -> (SArray a b -> p) -> SymbolicT m SBool Source #

forSome_ :: (SArray a b -> p) -> SymbolicT m SBool Source #

forSome :: [String] -> (SArray a b -> p) -> SymbolicT m SBool Source #

prove :: (SArray a b -> p) -> m ThmResult Source #

proveWith :: SMTConfig -> (SArray a b -> p) -> m ThmResult Source #

dprove :: (SArray a b -> p) -> m ThmResult Source #

dproveWith :: SMTConfig -> (SArray a b -> p) -> m ThmResult Source #

sat :: (SArray a b -> p) -> m SatResult Source #

satWith :: SMTConfig -> (SArray a b -> p) -> m SatResult Source #

dsat :: (SArray a b -> p) -> m SatResult Source #

dsatWith :: SMTConfig -> (SArray a b -> p) -> m SatResult Source #

allSat :: (SArray a b -> p) -> m AllSatResult Source #

allSatWith :: SMTConfig -> (SArray a b -> p) -> m AllSatResult Source #

optimize :: OptimizeStyle -> (SArray a b -> p) -> m OptimizeResult Source #

optimizeWith :: SMTConfig -> OptimizeStyle -> (SArray a b -> p) -> m OptimizeResult Source #

isVacuous :: (SArray a b -> p) -> m Bool Source #

isVacuousWith :: SMTConfig -> (SArray a b -> p) -> m Bool Source #

isTheorem :: (SArray a b -> p) -> m Bool Source #

isTheoremWith :: SMTConfig -> (SArray a b -> p) -> m Bool Source #

isSatisfiable :: (SArray a b -> p) -> m Bool Source #

isSatisfiableWith :: SMTConfig -> (SArray a b -> p) -> m Bool Source #

validate :: Bool -> SMTConfig -> (SArray a b -> p) -> SMTResult -> m SMTResult Source #

(HasKind a, HasKind b) => Show (SArray a b) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

showsPrec :: Int -> SArray a b -> ShowS #

show :: SArray a b -> String #

showList :: [SArray a b] -> ShowS #

SymVal b => Mergeable (SArray a b) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

symbolicMerge :: Bool -> SBool -> SArray a b -> SArray a b -> SArray a b Source #

select :: (Ord b0, SymVal b0, Num b0) => [SArray a b] -> SArray a b -> SBV b0 -> SArray a b Source #

EqSymbolic (SArray a b) Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

(.==) :: SArray a b -> SArray a b -> SBool Source #

(./=) :: SArray a b -> SArray a b -> SBool Source #

(.===) :: SArray a b -> SArray a b -> SBool Source #

(./==) :: SArray a b -> SArray a b -> SBool Source #

distinct :: [SArray a b] -> SBool Source #

distinctExcept :: [SArray a b] -> [SArray a b] -> SBool Source #

allEqual :: [SArray a b] -> SBool Source #

sElem :: SArray a b -> [SArray a b] -> SBool Source #

sNotElem :: SArray a b -> [SArray a b] -> SBool Source #

sbvToSV :: State -> SBV a -> IO SV Source #

Convert a symbolic value to a symbolic-word

sbvToSymSV :: MonadSymbolic m => SBV a -> m SV Source #

Generalization of sbvToSymSW

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

data SBVExpr Source #

A symbolic expression

Constructors

SBVApp !Op ![SV] 

Instances

Instances details
Eq SBVExpr Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: SBVExpr -> SBVExpr -> Bool #

(/=) :: SBVExpr -> SBVExpr -> Bool #

Data SBVExpr Source # 
Instance details

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 #

Ord SBVExpr Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show SBVExpr Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData SBVExpr Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SBVExpr -> () #

newExpr :: State -> Kind -> SBVExpr -> IO SV Source #

Create a new expression; hash-cons as necessary

cache :: (State -> IO a) -> Cached a Source #

Cache a state-based computation

data Cached a Source #

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!

Instances

Instances details
NFData (Cached a) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Cached a -> () #

uncache :: Cached SV -> State -> IO SV Source #

Uncache a previously cached computation

uncacheAI :: Cached ArrayIndex -> State -> IO ArrayIndex Source #

Uncache, retrieving SMT array indexes

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

Instances

Instances details
HasKind Bool Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Char Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Double Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Float Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Int8 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Int16 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Int32 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Int64 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Integer Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Word8 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Word16 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Word32 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind Word64 Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind () Source # 
Instance details

Defined in Data.SBV.Core.Kind

Methods

kindOf :: () -> Kind Source #

hasSign :: () -> Bool Source #

intSizeOf :: () -> Int Source #

isBoolean :: () -> Bool Source #

isBounded :: () -> Bool Source #

isReal :: () -> Bool Source #

isFloat :: () -> Bool Source #

isDouble :: () -> Bool Source #

isFP :: () -> Bool Source #

isUnbounded :: () -> Bool Source #

isUserSort :: () -> Bool Source #

isChar :: () -> Bool Source #

isString :: () -> Bool Source #

isList :: () -> Bool Source #

isSet :: () -> Bool Source #

isTuple :: () -> Bool Source #

isMaybe :: () -> Bool Source #

isEither :: () -> Bool Source #

showType :: () -> String Source #

HasKind AlgReal Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind RoundingMode Source #

RoundingMode kind

Instance details

Defined in Data.SBV.Core.Kind

HasKind Kind Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind ExtCV Source #

Kind instance for Extended CV

Instance details

Defined in Data.SBV.Core.Concrete

HasKind GeneralizedCV Source #

Kind instance for generalized CV

Instance details

Defined in Data.SBV.Core.Concrete

HasKind CV Source #

Kind instance for CV

Instance details

Defined in Data.SBV.Core.Concrete

HasKind SVal Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

HasKind SV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

HasKind State Source # 
Instance details

Defined in Documentation.SBV.Examples.Lists.BoundedMutex

HasKind E Source # 
Instance details

Defined in Documentation.SBV.Examples.Misc.Enumerate

HasKind HumanHeightInCm Source #

Symbolic instance simply follows the underlying type, just like Metres.

Instance details

Defined in Documentation.SBV.Examples.Misc.Newtypes

HasKind Metres Source #

To use Metres symbolically, we associate it with the underlying symbolic type's kind.

Instance details

Defined in Documentation.SBV.Examples.Misc.Newtypes

HasKind Day Source # 
Instance details

Defined in Documentation.SBV.Examples.Optimization.Enumerate

HasKind Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

HasKind Nationality Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

HasKind Beverage Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

HasKind Pet Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

HasKind Sport Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Fish

HasKind Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Garden

HasKind Color Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.HexPuzzle

HasKind Role Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

HasKind Sex Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

HasKind Location Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.Murder

HasKind U2Member Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.U2Bridge

HasKind Location Source # 
Instance details

Defined in Documentation.SBV.Examples.Puzzles.U2Bridge

HasKind Day Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.Enums

HasKind BinOp Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.FourFours

HasKind UnOp Source # 
Instance details

Defined in Documentation.SBV.Examples.Queries.FourFours

HasKind B Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.Deduce

HasKind Q Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.Sort

HasKind L Source # 
Instance details

Defined in Documentation.SBV.Examples.Uninterpreted.UISortAllSat

(Typeable a, HasKind a) => HasKind [a] Source # 
Instance details

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 #

isFP :: [a] -> Bool Source #

isUnbounded :: [a] -> Bool Source #

isUserSort :: [a] -> Bool Source #

isChar :: [a] -> Bool Source #

isString :: [a] -> Bool Source #

isList :: [a] -> Bool Source #

isSet :: [a] -> Bool Source #

isTuple :: [a] -> Bool Source #

isMaybe :: [a] -> Bool Source #

isEither :: [a] -> Bool Source #

showType :: [a] -> String Source #

HasKind a => HasKind (Maybe a) Source # 
Instance details

Defined in Data.SBV.Core.Kind

HasKind a => HasKind (RCSet a) Source # 
Instance details

Defined in Data.SBV.Core.Concrete

HasKind a => HasKind (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

(KnownNat n, BVIsNonZero n) => HasKind (IntN n) Source #

IntN has a kind

Instance details

Defined in Data.SBV.Core.Sized

(KnownNat n, BVIsNonZero n) => HasKind (WordN n) Source #

WordN has a kind

Instance details

Defined in Data.SBV.Core.Sized

(HasKind a, HasKind b) => HasKind (Either a b) Source # 
Instance details

Defined in Data.SBV.Core.Kind

(HasKind a, HasKind b) => HasKind (a, b) Source # 
Instance details

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 #

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 #

showType :: (a, b) -> String 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.

Instance details

Defined in Data.SBV.Core.Kind

ValidFloat eb sb => HasKind (FloatingPoint eb sb) Source # 
Instance details

Defined in Data.SBV.Core.Model

(HasKind a, HasKind b, HasKind c) => HasKind (a, b, c) Source # 
Instance details

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 #

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 #

showType :: (a, b, c) -> String Source #

(HasKind a, HasKind b, HasKind c, HasKind d) => HasKind (a, b, c, d) Source # 
Instance details

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 #

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 #

showType :: (a, b, c, d) -> String Source #

(HasKind a, HasKind b, HasKind c, HasKind d, HasKind e) => HasKind (a, b, c, d, e) Source # 
Instance details

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 #

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 #

showType :: (a, b, c, d, e) -> String Source #

(HasKind a, HasKind b, HasKind c, HasKind d, HasKind e, HasKind f) => HasKind (a, b, c, d, e, f) Source # 
Instance details

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 #

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 #

showType :: (a, b, c, d, e, f) -> String Source #

(HasKind a, HasKind b, HasKind c, HasKind d, HasKind e, HasKind f, HasKind g) => HasKind (a, b, c, d, e, f, g) Source # 
Instance details

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 #

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 #

showType :: (a, b, c, d, e, f, g) -> String 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 # 
Instance details

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 #

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 #

showType :: (a, b, c, d, e, f, g, h) -> String Source #

data Op Source #

Symbolic operations

Instances

Instances details
Eq Op Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: Op -> Op -> Bool #

(/=) :: Op -> Op -> Bool #

Data Op Source # 
Instance details

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 #

toConstr :: Op -> Constr #

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 #

Ord Op Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: Op -> Op -> Ordering #

(<) :: Op -> Op -> Bool #

(<=) :: Op -> Op -> Bool #

(>) :: Op -> Op -> Bool #

(>=) :: Op -> Op -> Bool #

max :: Op -> Op -> Op #

min :: Op -> Op -> Op #

Show Op Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> Op -> ShowS #

show :: Op -> String #

showList :: [Op] -> ShowS #

data PBOp Source #

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

Instances details
Eq PBOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: PBOp -> PBOp -> Bool #

(/=) :: PBOp -> PBOp -> Bool #

Data PBOp Source # 
Instance details

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 #

toConstr :: PBOp -> Constr #

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 #

Ord PBOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: PBOp -> PBOp -> Ordering #

(<) :: PBOp -> PBOp -> Bool #

(<=) :: PBOp -> PBOp -> Bool #

(>) :: PBOp -> PBOp -> Bool #

(>=) :: PBOp -> PBOp -> Bool #

max :: PBOp -> PBOp -> PBOp #

min :: PBOp -> PBOp -> PBOp #

Show PBOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> PBOp -> ShowS #

show :: PBOp -> String #

showList :: [PBOp] -> ShowS #

data FPOp Source #

Floating point operations

Instances

Instances details
Eq FPOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: FPOp -> FPOp -> Bool #

(/=) :: FPOp -> FPOp -> Bool #

Data FPOp Source # 
Instance details

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 #

toConstr :: FPOp -> Constr #

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 #

Ord FPOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: FPOp -> FPOp -> Ordering #

(<) :: FPOp -> FPOp -> Bool #

(<=) :: FPOp -> FPOp -> Bool #

(>) :: FPOp -> FPOp -> Bool #

(>=) :: FPOp -> FPOp -> Bool #

max :: FPOp -> FPOp -> FPOp #

min :: FPOp -> FPOp -> FPOp #

Show FPOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> FPOp -> ShowS #

show :: FPOp -> String #

showList :: [FPOp] -> ShowS #

data StrOp Source #

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 s at offset

StrIndexOf

Retrieves first position of sub in s, -1 if there are no occurrences

StrContains

Does s contain the substring sub?

StrPrefixOf

Is pre a prefix of s?

StrSuffixOf

Is suf a suffix of s?

StrReplace

Replace the first occurrence of src by dst in s

StrStrToNat

Retrieve integer encoded by string s (ground rewriting only)

StrNatToStr

Retrieve string encoded by integer i (ground rewriting only)

StrToCode

Equivalent to Haskell's ord

StrFromCode

Equivalent to Haskell's chr

StrInRe RegExp

Check if string is in the regular expression

Instances

Instances details
Eq StrOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: StrOp -> StrOp -> Bool #

(/=) :: StrOp -> StrOp -> Bool #

Data StrOp Source # 
Instance details

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 #

toConstr :: StrOp -> Constr #

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 #

Ord StrOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: StrOp -> StrOp -> Ordering #

(<) :: StrOp -> StrOp -> Bool #

(<=) :: StrOp -> StrOp -> Bool #

(>) :: StrOp -> StrOp -> Bool #

(>=) :: StrOp -> StrOp -> Bool #

max :: StrOp -> StrOp -> StrOp #

min :: StrOp -> StrOp -> StrOp #

Show StrOp Source #

Show instance for StrOp. Note that the mapping here is important to match the SMTLib equivalents, see here: http://rise4fun.com/z3/tutorialcontent/sequences

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> StrOp -> ShowS #

show :: StrOp -> String #

showList :: [StrOp] -> ShowS #

data SeqOp 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

Instances

Instances details
Eq SeqOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: SeqOp -> SeqOp -> Bool #

(/=) :: SeqOp -> SeqOp -> Bool #

Data SeqOp Source # 
Instance details

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 #

toConstr :: SeqOp -> Constr #

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 #

Ord SeqOp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

compare :: SeqOp -> SeqOp -> Ordering #

(<) :: SeqOp -> SeqOp -> Bool #

(<=) :: SeqOp -> SeqOp -> Bool #

(>) :: SeqOp -> SeqOp -> Bool #

(>=) :: SeqOp -> SeqOp -> Bool #

max :: SeqOp -> SeqOp -> SeqOp #

min :: SeqOp -> SeqOp -> SeqOp #

Show SeqOp Source #

Show instance for SeqOp. Again, mapping is important.

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

showsPrec :: Int -> SeqOp -> ShowS #

show :: SeqOp -> String #

showList :: [SeqOp] -> ShowS #

data RegExp Source #

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

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

Loop Int Int RegExp

From n repetitions to m repetitions

Union [RegExp]

Union of regular expressions

Inter RegExp RegExp

Intersection of regular expressions

Instances

Instances details
Eq RegExp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: RegExp -> RegExp -> Bool #

(/=) :: RegExp -> RegExp -> Bool #

Data RegExp Source # 
Instance details

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 #

Num RegExp Source #

Regular expressions as a Num instance. Note that only + (union) and * (concatenation) make sense.

Instance details

Defined in Data.SBV.Core.Symbolic

Ord RegExp Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show RegExp Source #

Convert a reg-exp to a Haskell-like string

Instance details

Defined in Data.SBV.Core.Symbolic

IsString RegExp Source #

With overloaded strings, we can have direct literal regular expressions.

Instance details

Defined in Data.SBV.Core.Symbolic

Methods

fromString :: String -> RegExp #

data NamedSymVar Source #

NamedSymVar pairs symbolic values and user given/automatically generated names

Constructors

NamedSymVar !SV !Name 

Instances

Instances details
Eq NamedSymVar Source #

For comparison purposes, we simply use the SV and ignore the name

Instance details

Defined in Data.SBV.Core.Symbolic

Ord NamedSymVar Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show NamedSymVar Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Generic NamedSymVar Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Associated Types

type Rep NamedSymVar :: Type -> Type #

NFData NamedSymVar Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: NamedSymVar -> () #

type Rep NamedSymVar Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

getTableIndex :: State -> Kind -> Kind -> [SV] -> IO Int Source #

Create a new table; hash-cons as necessary

newtype SBVPgm Source #

A program is a sequence of assignments

Constructors

SBVPgm 

Instances

Instances details
NFData SBVPgm Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SBVPgm -> () #

type Symbolic = SymbolicT IO Source #

Symbolic is specialization of SymbolicT to the IO monad. Unless you are using transformers explicitly, this is the type you should prefer.

runSymbolic :: MonadIO m => SBVRunMode -> SymbolicT m a -> m (a, Result) Source #

Generalization of runSymbolic

data State Source #

The state of the symbolic interpreter

Instances

Instances details
NFData State Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: State -> () #

getPathCondition :: State -> SBool Source #

Get the current path condition

extendPathCondition :: State -> (SBool -> SBool) -> State Source #

Extend the path condition with the given test value.

inSMTMode :: State -> IO Bool Source #

Are we running in proof mode?

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.

Concrete (Maybe (Bool, [((Quantifier, NamedSymVar), Maybe CV)]))

Concrete simulation mode, with given environment if any. If Nothing: Random.

Instances

Instances details
Show SBVRunMode Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

data Kind Source #

Kind of symbolic value

Instances

Instances details
Eq Kind Source # 
Instance details

Defined in Data.SBV.Core.Kind

Methods

(==) :: Kind -> Kind -> Bool #

(/=) :: Kind -> Kind -> Bool #

Data Kind Source # 
Instance details

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 #

toConstr :: Kind -> Constr #

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 #

Ord Kind Source # 
Instance details

Defined in Data.SBV.Core.Kind

Methods

compare :: Kind -> Kind -> Ordering #

(<) :: Kind -> Kind -> Bool #

(<=) :: Kind -> Kind -> Bool #

(>) :: Kind -> Kind -> Bool #

(>=) :: Kind -> Kind -> Bool #

max :: Kind -> Kind -> Kind #

min :: Kind -> Kind -> Kind #

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 KUserSort, we make sure we don't use any of the reserved names; see constructUKind for details.

Instance details

Defined in Data.SBV.Core.Kind

Methods

showsPrec :: Int -> Kind -> ShowS #

show :: Kind -> String #

showList :: [Kind] -> ShowS #

NFData Kind Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Kind -> () #

HasKind Kind Source # 
Instance details

Defined in Data.SBV.Core.Kind

class Outputtable a where Source #

A class representing what can be returned from a symbolic computation.

Methods

output :: MonadSymbolic m => a -> m a Source #

Generalization of output

Instances

Instances details
Outputtable () Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

output :: MonadSymbolic m => () -> m () Source #

Outputtable a => Outputtable [a] Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

output :: MonadSymbolic m => [a] -> m [a] Source #

Outputtable (SBV a) Source # 
Instance details

Defined in Data.SBV.Core.Data

Methods

output :: MonadSymbolic m => SBV a -> m (SBV a) Source #

(Outputtable a, Outputtable b) => Outputtable (a, b) Source # 
Instance details

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 # 
Instance details

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 # 
Instance details

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 # 
Instance details

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 # 
Instance details

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 # 
Instance details

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 # 
Instance details

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 #

data Result Source #

Result of running a symbolic computation

Constructors

Result 

Fields

Instances

Instances details
Show Result Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData Result Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Result -> () #

class SolverContext m 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.

Methods

constrain :: SBool -> m () Source #

Add a constraint, any satisfying instance must satisfy this condition.

softConstrain :: SBool -> m () Source #

Add a soft constraint. The solver will try to satisfy this condition if possible, but won't if it cannot.

namedConstraint :: String -> SBool -> m () Source #

Add a named constraint. The name is used in unsat-core extraction.

constrainWithAttribute :: [(String, String)] -> SBool -> 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.

addAxiom :: String -> [String] -> m () Source #

Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere string, use for commenting purposes. The second argument is intended to hold the multiple-lines of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom itself, to see whether it's actually well-formed or is sensible by any means. A separate formalization of SMT-Lib would be very useful here.

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 :: State -> Kind -> IO SV Source #

Create an internal variable, which acts as an input but isn't visible to the user. Such variables are existentially quantified in a SAT context, and universally quantified in a proof context.

internalConstraint :: State -> Bool -> [(String, String)] -> SVal -> IO () Source #

Require a boolean condition to be true in the state. Only used for internal purposes.

isCodeGenMode :: State -> IO Bool Source #

Is this a CodeGen run? (i.e., generating code)

newtype SBVType Source #

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.

Constructors

SBVType [Kind] 

Instances

Instances details
Eq SBVType Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(==) :: SBVType -> SBVType -> Bool #

(/=) :: SBVType -> SBVType -> Bool #

Ord SBVType Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show SBVType Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData SBVType Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SBVType -> () #

newUninterpreted :: State -> String -> SBVType -> Maybe [String] -> IO () Source #

Create a new uninterpreted symbol, possibly with user given code

data Quantifier Source #

Quantifiers: forall or exists. Note that we allow arbitrary nestings.

Constructors

ALL 
EX 

Instances

Instances details
Eq Quantifier Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show Quantifier Source #

Show instance for Quantifier

Instance details

Defined in Data.SBV.Core.Symbolic

NFData Quantifier Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Quantifier -> () #

needsExistentials :: [Quantifier] -> Bool Source #

Are there any existential quantifiers?

data SMTLibPgm Source #

Representation of an SMT-Lib program. In between pre and post goes the refuted models

Instances

Instances details
Show SMTLibPgm Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData SMTLibPgm Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SMTLibPgm -> () #

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 

smtLibVersionExtension :: SMTLibVersion -> String Source #

The extension associated with the version

smtLibReservedNames :: [String] Source #

Names reserved by SMTLib. This list is current as of Dec 6 2015; but of course there's no guarantee it'll stay that way.

data SolverCapabilities Source #

Translation tricks needed for specific capabilities afforded by each solver

Constructors

SolverCapabilities 

Fields

extractSymbolicSimulationState :: State -> IO Result Source #

Grab the program from a running symbolic simulation state.

data SMTScript Source #

A script, to be passed to the solver.

Constructors

SMTScript 

Fields

Instances

Instances details
NFData SMTScript Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SMTScript -> () #

data Solver Source #

Solvers that SBV is aware of

Constructors

ABC 
Boolector 
CVC4 
DReal 
MathSAT 
Yices 
Z3 

Instances

Instances details
Bounded Solver Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Enum Solver Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show Solver Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

data SMTSolver Source #

An SMT solver

Constructors

SMTSolver 

Fields

data SMTResult Source #

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

data SMTModel Source #

A model, as returned by a solver

Constructors

SMTModel 

Fields

Instances

Instances details
Show SMTModel Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData SMTModel Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SMTModel -> () #

data SMTConfig Source #

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 and 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

Instances

Instances details
Show SMTConfig Source #

We show the name of the solver for the config. Arguably this is misleading, but better than nothing.

Instance details

Defined in Data.SBV.Core.Symbolic

NFData SMTConfig Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SMTConfig -> () #

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

Instances details
Eq OptimizeStyle Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Show OptimizeStyle Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData OptimizeStyle Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: OptimizeStyle -> () #

data Penalty Source #

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 1 and no group attached

Penalty Rational (Maybe String)

Penalty with a weight and an optional group

Instances

Instances details
Show Penalty Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData Penalty Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Penalty -> () #

data Objective a 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

Instances

Instances details
Functor Objective Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

fmap :: (a -> b) -> Objective a -> Objective b #

(<$) :: a -> Objective b -> Objective a #

Show a => Show (Objective a) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData a => NFData (Objective a) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: Objective a -> () #

data QueryState Source #

The state we keep track of as we interact with the solver

newtype QueryT m a Source #

A query is a user-guided mechanism to directly communicate and extract results from the solver. A generalization of Query.

Constructors

QueryT 

Fields

Instances

Instances details
MonadTrans QueryT Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

lift :: Monad m => m a -> QueryT m a #

MonadSymbolic Query Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

MonadWriter w m => MonadWriter w (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

writer :: (a, w) -> QueryT m a #

tell :: w -> QueryT m () #

listen :: QueryT m a -> QueryT m (a, w) #

pass :: QueryT m (a, w -> w) -> QueryT m a #

MonadState s m => MonadState s (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

get :: QueryT m s #

put :: s -> QueryT m () #

state :: (s -> (a, s)) -> QueryT m a #

MonadReader r m => MonadReader r (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

ask :: QueryT m r #

local :: (r -> r) -> QueryT m a -> QueryT m a #

reader :: (r -> a) -> QueryT m a #

MonadError e m => MonadError e (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

throwError :: e -> QueryT m a #

catchError :: QueryT m a -> (e -> QueryT m a) -> QueryT m a #

Monad m => Monad (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

(>>=) :: QueryT m a -> (a -> QueryT m b) -> QueryT m b #

(>>) :: QueryT m a -> QueryT m b -> QueryT m b #

return :: a -> QueryT m a #

Functor m => Functor (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

fmap :: (a -> b) -> QueryT m a -> QueryT m b #

(<$) :: a -> QueryT m b -> QueryT m a #

Applicative m => Applicative (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

pure :: a -> QueryT m a #

(<*>) :: QueryT m (a -> b) -> QueryT m a -> QueryT m b #

liftA2 :: (a -> b -> c) -> QueryT m a -> QueryT m b -> QueryT m c #

(*>) :: QueryT m a -> QueryT m b -> QueryT m b #

(<*) :: QueryT m a -> QueryT m b -> QueryT m a #

MonadIO m => MonadIO (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

liftIO :: IO a -> QueryT m a #

Monad m => MonadQuery (QueryT m) Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

MonadIO m => SolverContext (QueryT m) Source #

QueryT as a SolverContext.

Instance details

Defined in Data.SBV.Control.Utils

newtype SMTProblem Source #

Internal representation of a symbolic simulation result

Constructors

SMTProblem

SMTLib representation, given the config

Operations useful for instantiating SBV type classes

genLiteral :: Integral a => Kind -> a -> SBV b Source #

Generate a finite constant bitvector

genFromCV :: Integral a => CV -> a Source #

Convert a constant to an integral value

data CV Source #

CV represents a concrete word of a fixed size: For signed words, the most significant digit is considered to be the sign.

Constructors

CV 

Fields

Instances

Instances details
Eq CV Source # 
Instance details

Defined in Data.SBV.Core.Concrete

Methods

(==) :: CV -> CV -> Bool #

(/=) :: CV -> CV -> Bool #

Ord CV Source # 
Instance details

Defined in Data.SBV.Core.Concrete

Methods

compare :: CV -> CV -> Ordering #

(<) :: CV -> CV -> Bool #

(<=) :: CV -> CV -> Bool #

(>) :: CV -> CV -> Bool #

(>=) :: CV -> CV -> Bool #

max :: CV -> CV -> CV #

min :: CV -> CV -> CV #

Show CV Source #

Show instance for CV.

Instance details

Defined in Data.SBV.Core.Concrete

Methods

showsPrec :: Int -> CV -> ShowS #

show :: CV -> String #

showList :: [CV] -> ShowS #

NFData CV Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: CV -> () #

HasKind CV Source #

Kind instance for CV

Instance details

Defined in Data.SBV.Core.Concrete

PrettyNum CV Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

SatModel CV Source #

CV as extracted from a model; trivial definition

Instance details

Defined in Data.SBV.SMT.SMT

Methods

parseCVs :: [CV] -> Maybe (CV, [CV]) Source #

cvtModel :: (CV -> Maybe b) -> Maybe (CV, [CV]) -> Maybe (b, [CV]) Source #

SDivisible CV Source # 
Instance details

Defined in Data.SBV.Core.Model

Methods

sQuotRem :: CV -> CV -> (CV, CV) Source #

sDivMod :: CV -> CV -> (CV, CV) Source #

sQuot :: CV -> CV -> CV Source #

sRem :: CV -> CV -> CV Source #

sDiv :: CV -> CV -> CV Source #

sMod :: CV -> CV -> CV Source #

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

data SMTModel Source #

A model, as returned by a solver

Constructors

SMTModel 

Fields

Instances

Instances details
Show SMTModel Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

NFData SMTModel Source # 
Instance details

Defined in Data.SBV.Core.Symbolic

Methods

rnf :: SMTModel -> () #

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, 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.

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

The codegen monad

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

Instances details
Monad SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Methods

(>>=) :: SBVCodeGen a -> (a -> SBVCodeGen b) -> SBVCodeGen b #

(>>) :: SBVCodeGen a -> SBVCodeGen b -> SBVCodeGen b #

return :: a -> SBVCodeGen a #

Functor SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Methods

fmap :: (a -> b) -> SBVCodeGen a -> SBVCodeGen b #

(<$) :: a -> SBVCodeGen b -> SBVCodeGen a #

MonadFail SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Methods

fail :: String -> SBVCodeGen a #

Applicative SBVCodeGen Source # 
Instance details

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 #

MonadIO SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Methods

liftIO :: IO a -> SBVCodeGen a #

MonadSymbolic SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

MonadState CgState SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

cgSym :: Symbolic a -> SBVCodeGen a Source #

Reach into symbolic monad from code-generation

Specifying inputs, SBV variants

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.

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.

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.

Specifying inputs, SVal variants

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.

Settings

cgPerformRTCs :: Bool -> SBVCodeGen () Source #

Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off. Default: False.

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.

cgAddPrototype :: [String] -> SBVCodeGen () Source #

Adds the given lines to the header file generated, useful for generating programs with uninterpreted functions.

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.

cgIgnoreSAssert :: Bool -> SBVCodeGen () Source #

Ignore assertions (those generated by sAssert calls) in the generated C 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.

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.

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.

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.

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

Instances details
Eq CgSRealType Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Show CgSRealType Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

Infrastructure

class CgTarget a where Source #

Abstract over code generation for different languages

data CgConfig Source #

Options for code-generation.

Constructors

CgConfig 

Fields

data CgState Source #

Code-generation state

Instances

Instances details
MonadState CgState SBVCodeGen Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

data CgPgmBundle Source #

Representation of a collection of generated programs.

Instances

Instances details
Show CgPgmBundle Source # 
Instance details

Defined in Data.SBV.Compilers.CodeGen

data CgPgmKind Source #

Different kinds of "files" we can produce. Currently this is quite C specific.

data CgVal Source #

Abstraction of target language values

Constructors

CgAtomic SV 
CgArray [SV] 

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?

Generating collateral

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.

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.

renderCgPgmBundle :: Maybe FilePath -> (CgConfig, CgPgmBundle) -> IO () Source #

Render a code-gen bundle to a directory or to stdout

Various math utilities around floats

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

fpMinH :: RealFloat a => a -> a -> a Source #

SMTLib compliant definition for fpMin. See the comments for fpMax.

fp2fp :: (RealFloat a, RealFloat b) => a -> b Source #

Convert double to float and back. Essentially fromRational . toRational except careful on NaN, Infinities, and -0.

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, See http://smt-lib.org/papers/BTRW14.pdf, towards the end of section 4.c.

fpRoundToIntegralH :: RealFloat a => a -> a Source #

Convert a float to the nearest integral representable in that type

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.

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.

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!

floatToWord :: Float -> Word32 Source #

Reinterpret-casts a Float to a Word32.

wordToFloat :: Word32 -> Float Source #

Reinterpret-casts a Word32 to a Float.

doubleToWord :: Double -> Word64 Source #

Reinterpret-casts a Double to a Word64.

wordToDouble :: Word64 -> Double Source #

Reinterpret-casts a Word64 to a Double.

Pretty number printing

class PrettyNum a where Source #

PrettyNum class captures printing of numbers in hex and binary formats; also supporting negative numbers.

Methods

hexS :: a -> String Source #

Show a number in hexadecimal, starting with 0x and type.

binS :: a -> String Source #

Show a number in binary, starting with 0b and type.

hexP :: a -> String Source #

Show a number in hexadecimal, starting with 0x but no type.

binP :: a -> String Source #

Show a number in binary, starting with 0b but no type.

hex :: a -> String Source #

Show a number in hex, without prefix, or types.

bin :: a -> String Source #

Show a number in bin, without prefix, or types.

Instances

Instances details
PrettyNum Bool Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Int8 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Int16 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Int32 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Int64 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Integer Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Word8 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Word16 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Word32 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum Word64 Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum String Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

PrettyNum CV Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

(SymVal a, PrettyNum a) => PrettyNum (SBV a) Source # 
Instance details

Defined in Data.SBV.Utils.PrettyNum

Methods

hexS :: SBV a -> String Source #

binS :: SBV a -> String Source #

hexP :: SBV a -> String Source #

binP :: SBV a -> String Source #

hex :: SBV a -> String Source #

bin :: SBV a -> String Source #

readBin :: Num a => String -> a Source #

A more convenient interface for reading binary numbers, also supports negative numbers

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 wether 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.

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.

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.

sbin :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String Source #

Similar to shex; except in binary.

sbinI :: Bool -> Bool -> Integer -> String Source #

Similar to shexI; except in binary.

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.

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.

showHFloat :: Float -> String Source #

A version of show for floats that generates correct Haskell literals for nan/infinite

showHDouble :: Double -> String Source #

A version of show for doubles that generates correct Haskell literals for nan/infinite

showBFloat :: (Show a, RealFloat a) => a -> ShowS Source #

Show a float as a binary

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.

showSMTFloat :: RoundingMode -> Float -> String Source #

A version of show for floats that generates correct SMTLib literals using the rounding mode

showSMTDouble :: RoundingMode -> Double -> String Source #

A version of show for doubles that generates correct SMTLib literals using the rounding mode

smtRoundingMode :: RoundingMode -> String Source #

Convert a rounding mode to the format SMT-Lib2 understands.

cvToSMTLib :: RoundingMode -> CV -> String Source #

Convert a CV to an SMTLib2 compliant value

mkSkolemZero :: RoundingMode -> Kind -> String Source #

Create a skolem 0 for the kind

Timing computations

data Timing Source #

Specify how to save timing information, if at all.

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.

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

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 sb. (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 .== x
Q.E.D.
>>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord32AsSFloat (sFloatAsComparableSWord32 x) `fpIsEqualObject` x
Q.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 .== x
Q.E.D.
>>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWord64AsSDouble (sDoubleAsComparableSWord64 x) `fpIsEqualObject` x
Q.E.D.

sComparableSWordAsSFloatingPoint :: forall eb sb. (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 = sComparableSWordAsSFloatingPoint x in fpIsNaN d .|| fpIsNegativeZero d .|| sFloatingPointAsComparableSWord (d :: SFPHalf) .== x
Q.E.D.
>>> prove $ \x -> fpIsNegativeZero x .|| sComparableSWordAsSFloatingPoint (sFloatingPointAsComparableSWord x) `fpIsEqualObject` (x :: SFPHalf)
Q.E.D.