The sbv package

[Tags: bsd3, library]

Express properties about bit-precise Haskell programs and automatically prove them using SMT solvers. The SBV library adds support for symbolic bit vectors, allowing formal models of bit-precise programs to be created.

   $ ghci -XScopedTypeVariables
   Prelude> :m Data.SBV
   Prelude Data.SBV> prove $ \(x::SWord8) -> x `shiftL` 2 .== 4*x
   Prelude Data.SBV> prove $ forAll ["x"] $ \(x::SWord8) -> x `shiftL` 2 .== x
   Falsifiable. Counter-example:
     x = 128 :: SWord8

The library introduces the following types and concepts:

Predicates (i.e., functions that return SBool) built out of these types can be:

In addition to the library, the installation will create the executable SBVUnitTests. You should run it once the installation is complete, to make sure the unit tests are run and all is well.

SBV is hosted at GitHub: Comments, bug reports, and patches are always welcome.

[Skip to ReadMe]


Versions0.9, 0.9.1, 0.9.2, 0.9.3, 0.9.4, 0.9.5, 0.9.6, 0.9.7, 0.9.8, 0.9.9, 0.9.10, 0.9.11, 0.9.12, 0.9.13, 0.9.14, 0.9.15, 0.9.16, 0.9.17, 0.9.18, 0.9.19, 0.9.20, 0.9.21, 0.9.22, 0.9.23, 0.9.24, 1.0, 1.1, 1.2, 1.3, 1.4, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 2.10, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 4.0, 4.1, 4.2, 4.3, 4.4, 5.0, 5.1, 5.2, 5.3, 5.4, 5.5 (info)
Change logNone available
Dependenciesarray (>=, base (>=3 && <5), containers (>=, deepseq (>=, directory (>=, filepath (>=, HUnit (>=, mtl (>=, old-time (>=, process (>=, QuickCheck (>=, strict-concurrency (>= [details]
CopyrightLevent Erkok, 2011
AuthorLevent Erkok
MaintainerLevent Erkok (
CategoryFormal Methods, Theorem Provers, Bit vectors, Symbolic Computation, Math
Home page
Source repositoryhead: git clone git://
UploadedSun Jan 23 08:34:51 UTC 2011 by LeventErkok
DistributionsLTSHaskell:4.4, NixOS:5.5, Stackage:4.4
Downloads8963 total (274 in last 30 days)
4 []
StatusDocs uploaded by user
Build status unknown [no reports yet]




testRun the unit-test suite after buildDisabledAutomatic

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainers' corner

For package maintainers and hackage trustees

Readme for sbv-0.9.8

SBV: Symbolic Bit Vectors in Haskell

Express properties about bit-precise Haskell programs and automatically prove
them using SMT solvers.

        $ ghci -XScopedTypeVariables
        Prelude> :m Data.SBV
        Prelude Data.SBV> prove $ \(x::SWord8) -> x `shiftL` 2 .== 4*x
        Prelude Data.SBV> prove $ forAll ["x"] $ \(x::SWord8) -> x `shiftL` 2 .== x
        Falsifiable. Counter-example:
          x = 128 :: SWord8

The function `prove` has the following type:
        prove :: Provable a => a -> IO ThmResult

The class `Provable` comes with instances for n-ary predicates, for arbitrary n.
The predicates are just regular Haskell functions over symbolic signed and unsigned
bit-vectors. Functions for checking satisfiability (`sat` and `allSat`) are also provided.

The sbv library is hosted at [](

The hackage site
[]( is the best place
for details on the API. Or, you can directly look at the
[Examples]( to get a jump start.

Comments, bug reports, and patches are always welcome.

The Haskell sbv library provides support for dealing with Symbolic Bit Vectors
in Haskell. It introduces the types:

  - `SBool`: Symbolic Booleans (bits)
  - `SWord8`, `SWord16`, `SWord32`, `SWord64`: Symbolic Words (unsigned)
  - `SInt8`,  `SInt16`,  `SInt32`,  `SInt64`: Symbolic Ints (signed)
  - Arrays of symbolic values
  - Symbolic polynomials over GF(2^n ), and polynomial arithmetic
  - Uninterpreted constants and functions over symbolic values

The user can construct ordinary Haskell programs using these types, which behave
very similar to their concrete counterparts. In particular these types belong to the
standard classes `Num`, `Bits`, (custom versions of) `Eq` and `Ord`, along with several
other custom classes for simplifying bit-precise programming with symbolic values. The
framework takes full advantage of Haskell's type inference to avoid many common mistakes.

Furthermore, predicates (i.e., functions that return `SBool`) built out of these types can also be:

  - proven correct via an external SMT solver (the `prove` function)
  - checked for satisfiability (the `sat` and `allSat` functions)
  - quick-checked

If a predicate is not valid, `prove` will return a counterexample: An 
assignment to inputs such that the predicate fails. The `sat` function will
return a satisfying assignment, if there is one. The `allSat` function returns
all satisfying assignments, lazily.

Use of SMT solvers
The sbv library uses third-party SMT solvers via the standard SMT-Lib interface: 

While the library is designed to work with any SMT-Lib compliant SMT-solver,
solver specific support is required for parsing counter-example/model data since
there is currently no agreed upon format for getting models from arbitrary SMT
solvers. (The SMT-Lib2 initiative will potentially address this issue in the
future, at which point the sbv library can be generalized as well.) Currently, we
only support the Yices SMT solver from SRI as far as the counter-example
and model generation support is concerned:
[]( However, other solvers can
be hooked up with relative ease.

You **should** download and install Yices (version 2.X) on your machine, and
make sure the "yices" executable is in your path before using the sbv library,
as it is the current default solver. Alternatively, you can specify the location
of yices executable in the environment variable `SBV_YICES` and the options to yices
in `SBV_YICES_OPTIONS`. (The default for the latter is `"-m -f"`.)

Please see the files under the
directory for a number of interesting applications and use cases. Amongst others,
it contains solvers for Sudoku and N-Queens puzzles as mandatory SMT solver examples in
the Puzzles directory.

The sbv library is cabalized. Assuming you have cabal/ghc installed, it should merely
be a matter of running 
         cabal install sbv
Please see [INSTALL]( for installation details.

Once the installation is done, you can run the executable `SBVUnitTests` which will
execute the regression test suite for sbv on your machine to ensure all is well.

Copyright, License
The sbv library is distributed with the BSD3 license. See [COPYRIGHT]( for
details. The [LICENSE]( file contains
the [BSD3]( verbiage.