{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- |
-- Module    : Z3.Monad
-- Copyright : (c) Iago Abal, 2013-2015
--             (c) David Castro, 2013-2015
-- License   : BSD3
-- Maintainer: Iago Abal <mail@iagoabal.eu>,
--             David Castro <david.castro.dcp@gmail.com>
--
-- A simple monadic interface to Z3 API.
--
-- Examples: <https://bitbucket.org/iago/z3-haskell/src/tip/examples/Example/Monad>

module Z3.Monad
  ( -- * Z3 monad
    MonadZ3(..)
  , Z3
  , module Z3.Opts
  , Logic(..)
  , evalZ3
  , evalZ3With
    -- ** Z3 enviroments
  , Z3Env
  , newEnv
  , evalZ3WithEnv

  -- * Types
  , Symbol
  , AST
  , Sort
  , FuncDecl
  , App
  , Pattern
  , Constructor
  , Model
  , Base.Context
  , FuncInterp
  , FuncEntry
  , Params
  , Solver
  , SortKind(..)
  , ASTKind(..)
  -- ** Satisfiability result
  , Result(..)

  -- * Parameters
  , mkParams
  , paramsSetBool
  , paramsSetUInt
  , paramsSetDouble
  , paramsSetSymbol
  , paramsToString

  -- * Symbols
  , mkIntSymbol
  , mkStringSymbol

  -- * Sorts
  , mkUninterpretedSort
  , mkBoolSort
  , mkIntSort
  , mkRealSort
  , mkBvSort
  , mkFiniteDomainSort
  , mkArraySort
  , mkTupleSort
  , mkConstructor
  , mkDatatype
  , mkDatatypes
  , mkSetSort

  -- * Constants and Applications
  , mkFuncDecl
  , mkApp
  , mkConst
  , mkFreshConst
  , mkFreshFuncDecl
  , mkRecFuncDecl
  , addRecDef
  -- ** Helpers
  , mkVar
  , mkBoolVar
  , mkRealVar
  , mkIntVar
  , mkBvVar
  , mkFreshVar
  , mkFreshBoolVar
  , mkFreshRealVar
  , mkFreshIntVar
  , mkFreshBvVar

  -- * Propositional Logic and Equality
  , mkTrue
  , mkFalse
  , mkEq
  , mkNot
  , mkIte
  , mkIff
  , mkImplies
  , mkXor
  , mkAnd
  , mkOr
  , mkDistinct
  , mkDistinct1
  -- ** Helpers
  , mkBool

  -- * Arithmetic: Integers and Reals
  , mkAdd
  , mkMul
  , mkSub
  , mkSub1
  , mkUnaryMinus
  , mkDiv
  , mkMod
  , mkRem
  , mkPower
  , mkLt
  , mkLe
  , mkGt
  , mkGe
  , mkInt2Real
  , mkReal2Int
  , mkIsInt

  -- * Bit-vectors
  , mkBvnot
  , mkBvredand
  , mkBvredor
  , mkBvand
  , mkBvor
  , mkBvxor
  , mkBvnand
  , mkBvnor
  , mkBvxnor
  , mkBvneg
  , mkBvadd
  , mkBvsub
  , mkBvmul
  , mkBvudiv
  , mkBvsdiv
  , mkBvurem
  , mkBvsrem
  , mkBvsmod
  , mkBvult
  , mkBvslt
  , mkBvule
  , mkBvsle
  , mkBvuge
  , mkBvsge
  , mkBvugt
  , mkBvsgt
  , mkConcat
  , mkExtract
  , mkSignExt
  , mkZeroExt
  , mkRepeat
  , mkBvshl
  , mkBvlshr
  , mkBvashr
  , mkRotateLeft
  , mkRotateRight
  , mkExtRotateLeft
  , mkExtRotateRight
  , mkInt2bv
  , mkBv2int
  , mkBvnegNoOverflow
  , mkBvaddNoOverflow
  , mkBvaddNoUnderflow
  , mkBvsubNoOverflow
  , mkBvsubNoUnderflow
  , mkBvmulNoOverflow
  , mkBvmulNoUnderflow
  , mkBvsdivNoOverflow

  -- * Arrays
  , mkSelect
  , mkStore
  , mkConstArray
  , mkMap
  , mkArrayDefault

  -- * Sets
  , mkEmptySet
  , mkFullSet
  , mkSetAdd
  , mkSetDel
  , mkSetUnion
  , mkSetIntersect
  , mkSetDifference
  , mkSetComplement
  , mkSetMember
  , mkSetSubset

  -- * Numerals
  , mkNumeral
  , mkInt
  , mkReal
  , mkUnsignedInt
  , mkInt64
  , mkUnsignedInt64
  -- ** Helpers
  , mkIntegral
  , mkRational
  , mkFixed
  , mkRealNum
  , mkInteger
  , mkIntNum
  , mkBitvector
  , mkBvNum

  -- * Sequences and regular expressions
  , mkSeqSort
  , isSeqSort
  , mkReSort
  , isReSort
  , mkStringSort
  , isStringSort
  , mkString
  , isString
  , getString
  , mkSeqEmpty
  , mkSeqUnit
  , mkSeqConcat
  , mkSeqPrefix
  , mkSeqSuffix
  , mkSeqContains
  , mkStrLt
  , mkStrLe
  , mkSeqExtract
  , mkSeqReplace
  , mkSeqAt
  , mkSeqLength
  , mkSeqIndex
  , mkStrToInt
  , mkIntToStr
  , mkSeqToRe
  , mkSeqInRe
  , mkRePlus
  , mkReStar
  , mkReOption
  , mkReUnion
  , mkReConcat
  , mkReRange
  , mkReLoop
  , mkReIntersect
  , mkReComplement
  , mkReEmpty
  , mkReFull

  -- * Quantifiers
  , mkPattern
  , mkBound
  , mkForall
  , mkForallW
  , mkExists
  , mkExistsW
  , mkForallConst
  , mkForallWConst
  , mkExistsConst
  , mkExistsWConst

  -- * Accessors
  , getSymbolString
  , getSortName
  , getSortId
  , sortToAst
  , isEqSort
  , getSortKind
  , getBvSortSize
  , getTupleSortMkDecl
  , getTupleSortNumFields
  , getTupleSortFieldDecl
  , getDatatypeSortConstructors
  , getDatatypeSortRecognizers
  , getDatatypeSortConstructorAccessors
  , mkAtMost
  , mkAtLeast
  , getDeclName
  , getArity
  , getDomain
  , getRange
  , appToAst
  , getAppDecl
  , getAppNumArgs
  , getAppArg
  , getAppArgs
  , getSort
  , getArraySortDomain
  , getArraySortRange
  , getBoolValue
  , getAstKind
  , isApp
  , toApp
  , getNumeralString
  , getNumerator
  , getDenominator
  , simplify
  , simplifyEx
  , getIndexValue
  , isQuantifierForall
  , isQuantifierExists
  , getQuantifierWeight
  , getQuantifierNumPatterns
  , getQuantifierPatternAST
  , getQuantifierPatterns
  , getQuantifierNumNoPatterns
  , getQuantifierNoPatternAST
  , getQuantifierNoPatterns
  , getQuantifierNumBound
  , getQuantifierBoundName
  , getQuantifierBoundSort
  , getQuantifierBoundVars
  , getQuantifierBody
  -- ** Helpers
  , getBool
  , getInt
  , getReal

  -- * Modifiers
  , substituteVars
  , substitute

  -- * Models
  , modelTranslate
  , modelEval
  , evalArray
  , getConstInterp
  , getFuncInterp
  , hasInterp
  , numConsts
  , numFuncs
  , getConstDecl
  , getFuncDecl
  , getConsts
  , getFuncs
  , isAsArray
  , isEqAST
  , addFuncInterp
  , addConstInterp
  , getAsArrayFuncDecl
  , funcInterpGetNumEntries
  , funcInterpGetEntry
  , funcInterpGetElse
  , funcInterpGetArity
  , funcEntryGetValue
  , funcEntryGetNumArgs
  , funcEntryGetArg
  , modelToString
  , showModel
  -- ** Helpers
  , EvalAst
  , eval
  , evalBool
  , evalInt
  , evalReal
  , evalBv
  , evalT
  , mapEval
  , FuncModel(..)
  , evalFunc

  -- * Tactics
  , mkTactic
  , andThenTactic
  , orElseTactic
  , skipTactic
  , tryForTactic
  , tacticUsingParams
  , repeatTactic
  , mkQuantifierEliminationTactic
  , mkAndInverterGraphTactic
  , applyTactic
  , applyResultToString
  , getApplyResultNumSubgoals
  , getApplyResultSubgoal
  , getApplyResultSubgoals
  , mkGoal
  , goalAssert
  , getGoalSize
  , getGoalFormula
  , getGoalFormulas
  , goalToString
  , convertModel

  -- * String Conversion
  , ASTPrintMode(..)
  , setASTPrintMode
  , astToString
  , patternToString
  , sortToString
  , funcDeclToString
  , benchmarkToSMTLibString

  -- * Parser interface
  , parseSMTLib2String
  , parseSMTLib2File
  , evalSMTLib2String

  -- * Error Handling
  , Base.Z3Error(..)
  , Base.Z3ErrorCode(..)

  -- * Miscellaneous
  , Version(..)
  , getVersion

  -- * Fixedpoint
  , MonadFixedpoint(..)
  , Fixedpoint
  , fixedpointAddRule
  , fixedpointSetParams
  , fixedpointRegisterRelation
  , fixedpointQueryRelations
  , fixedpointGetAnswer
  , fixedpointGetAssertions

  -- * Floating-Point Arithmetic
  , mkFpaRoundingModeSort
  , mkFpaRoundNearestTiesToEven
  , mkFpaRne
  , mkFpaRoundNearestTiesToAway
  , mkFpaRna
  , mkFpaRoundTowardPositive
  , mkFpaRtp
  , mkFpaRoundTowardNegative
  , mkFpaRtn
  , mkFpaRoundTowardZero
  , mkFpaRtz
  , mkFpaSort
  , mkFpaSortHalf
  , mkFpaSort16
  , mkFpaSortSingle
  , mkFpaSort32
  , mkFpaSortDouble
  , mkFpaSort64
  , mkFpaSortQuadruple
  , mkFpaSort128
  , mkFpaNaN
  , mkFpaInf
  , mkFpaZero
  , mkFpaFp
  , mkFpaNumeralFloat
  , mkFpaNumeralDouble
  , mkFpaNumeralInt
  , mkFpaNumeralIntUInt
  , mkFpaNumeralInt64UInt64
  , mkFpaAbs
  , mkFpaNeg
  , mkFpaAdd
  , mkFpaSub
  , mkFpaMul
  , mkFpaDiv
  , mkFpaFma
  , mkFpaSqrt
  , mkFpaRem
  , mkFpaRoundToIntegral
  , mkFpaMin
  , mkFpaMax
  , mkFpaLeq
  , mkFpaLt
  , mkFpaGeq
  , mkFpaGt
  , mkFpaEq
  , mkFpaIsNormal
  , mkFpaIsSubnormal
  , mkFpaIsZero
  , mkFpaIsInfinite
  , mkFpaIsNaN
  , mkFpaIsNegative
  , mkFpaIsPositive
  , mkFpaToFpBv
  , mkFpaToFpFloat
  , mkFpaToFpReal
  , mkFpaToFpSigned
  , mkFpaToFpUnsigned
  , mkFpaToUbv
  , mkFpaToSbv
  , mkFpaToReal

  -- * Z3-specific floating-point extensions
  , fpaGetEbits
  , fpaGetSbits
  , fpaIsNumeralNaN
  , fpaIsNumeralInf
  , fpaIsNumeralZero
  , fpaIsNumeralNormal
  , fpaIsNumeralSubnormal
  , fpaIsNumeralPositive
  , fpaIsNumeralNegative
  , fpaGetNumeralSignBv
  , fpaGetNumeralSignificandBv
  , fpaGetNumeralSignificandString
  , fpaGetNumeralExponentString
  , fpaGetNumeralExponentBv
  , mkFpaToIEEEBv
  , mkFpaToFpIntReal

  -- * Optimization
  , MonadOptimize(..)
  , Optimize
  , optimizeAssert
  , optimizeAssertAndTrack
  , optimizeAssertSoft
  , optimizeMaximize
  , optimizeMinimize
  , optimizePush
  , optimizePop
  , optimizeCheck
  , optimizeGetReasonUnknown
  , optimizeGetModel
  , optimizeGetUnsatCore
  , optimizeSetParams
  , optimizeGetLower
  , optimizeGetUpper
  , optimizeGetUpperAsVector
  , optimizeGetLowerAsVector
  , optimizeToString
  , optimizeFromString
  , optimizeFromFile
  , optimizeGetHelp
  , optimizeGetAssertions
  , optimizeGetObjectives

  -- * Solvers
  , solverGetHelp
  , solverSetParams
  , solverPush
  , solverPop
  , solverReset
  , solverGetNumScopes
  , solverAssertCnstr
  , solverAssertAndTrack
  , solverGetAssertions
  , solverCheck
  , solverCheckAssumptions
  , solverGetModel
  , solverGetProof
  , solverGetUnsatCore
  , solverGetReasonUnknown
  , solverToString
  , solverFromString
  -- ** Helpers
  , assert
  , check
  , checkAssumptions
  , solverCheckAndGetModel
  , getModel
  , withModel
  , getUnsatCore
  , push
  , pop
  , local
  , reset
  , getNumScopes
  )
  where

import Z3.Opts
import Z3.Base
  ( Symbol
  , AST
  , Sort
  , TupleType
  , FuncDecl
  , App
  , Pattern
  , Constructor
  , Model
  , FuncInterp
  , FuncEntry
  , FuncModel(..)
  , Result(..)
  , Logic(..)
  , ASTPrintMode(..)
  , Version(..)
  , Params
  , Solver
  , Fixedpoint
  , Optimize
  , SortKind(..)
  , ASTKind(..)
  , Tactic
  , ApplyResult
  , Goal
  )
import qualified Z3.Base as Base

import Control.Applicative ( Applicative )
import Data.Fixed ( Fixed, HasResolution )
import Control.Monad.Trans.Except (ExceptT)
import Control.Monad.Fail
import Control.Monad.IO.Class ( MonadIO, liftIO )
import Control.Monad.Trans.Class ( lift )
import Control.Monad.Trans.Reader ( ReaderT(..), runReaderT, asks )
import Control.Monad.Trans.State.Lazy as StLazy ( StateT(..) )
import Control.Monad.Trans.State.Strict as StStrict ( StateT(..) )
import Control.Monad.Fix ( MonadFix )
import Data.Int ( Int64 )
import Data.List.NonEmpty (NonEmpty)
import Data.Word ( Word, Word64 )
import Data.Traversable ( Traversable )
import qualified Data.Traversable as T


---------------------------------------------------------------------
-- The Z3 monad-class

class (Applicative m, Monad m, MonadIO m) => MonadZ3 m where
  getSolver  :: m Base.Solver
  getContext :: m Base.Context

instance MonadZ3 m => MonadZ3 (ReaderT r m) where
  getSolver :: ReaderT r m Solver
getSolver = m Solver -> ReaderT r m Solver
forall (m :: * -> *) a. Monad m => m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver
  getContext :: ReaderT r m Context
getContext = m Context -> ReaderT r m Context
forall (m :: * -> *) a. Monad m => m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext

instance MonadZ3 m => MonadZ3 (ExceptT e m) where
  getSolver :: ExceptT e m Solver
getSolver = m Solver -> ExceptT e m Solver
forall (m :: * -> *) a. Monad m => m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver
  getContext :: ExceptT e m Context
getContext = m Context -> ExceptT e m Context
forall (m :: * -> *) a. Monad m => m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext

instance MonadZ3 m => MonadZ3 (StLazy.StateT s m) where
  getSolver :: StateT s m Solver
getSolver = m Solver -> StateT s m Solver
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver
  getContext :: StateT s m Context
getContext = m Context -> StateT s m Context
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext

instance MonadZ3 m => MonadZ3 (StStrict.StateT s m) where
  getSolver :: StateT s m Solver
getSolver = m Solver -> StateT s m Solver
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver
  getContext :: StateT s m Context
getContext = m Context -> StateT s m Context
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext

-------------------------------------------------
-- Lifting

-- TODO: Rename to liftFun0 for consistency
liftScalar :: MonadZ3 z3 => (Base.Context -> IO b) -> z3 b
liftScalar :: forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO b
f = IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Context -> IO b) -> Context -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context -> IO b
f (Context -> z3 b) -> z3 Context -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext

liftFun1 :: MonadZ3 z3 => (Base.Context -> a -> IO b) -> a -> z3 b
liftFun1 :: forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> a -> IO b
f a
a = z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 b) -> z3 b
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a -> IO b
f Context
ctx a
a)

liftFun2 :: MonadZ3 z3 => (Base.Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 :: forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> a -> b -> IO c
f a
a b
b = z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 c) -> z3 c
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO c -> z3 c
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a -> b -> IO c
f Context
ctx a
a b
b)

liftFun3 :: MonadZ3 z3 => (Base.Context -> a -> b -> c -> IO d)
                              -> a -> b -> c -> z3 d
liftFun3 :: forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> a -> b -> c -> IO d
f a
a b
b c
c = z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 d) -> z3 d
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO d -> z3 d
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a -> b -> c -> IO d
f Context
ctx a
a b
b c
c)

liftFun4 :: MonadZ3 z3 => (Base.Context -> a -> b -> c -> d -> IO e)
                -> a -> b -> c -> d -> z3 e
liftFun4 :: forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> a -> b -> c -> d -> IO e
f a
a b
b c
c d
d = z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 e) -> z3 e
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO e -> z3 e
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a -> b -> c -> d -> IO e
f Context
ctx a
a b
b c
c d
d)

liftFun5 :: MonadZ3 z3 =>
              (Base.Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
                -> a1 -> a2 -> a3 -> a4 -> a5-> z3 b
liftFun5 :: forall (z3 :: * -> *) a1 a2 a3 a4 a5 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> z3 b
liftFun5 Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b
f a1
x1 a2
x2 a3
x3 a4
x4 a5
x5 =
  z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 b) -> z3 b
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b
f Context
ctx a1
x1 a2
x2 a3
x3 a4
x4 a5
x5)

liftFun6 :: MonadZ3 z3 =>
              (Base.Context -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> IO b)
                -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> z3 b
liftFun6 :: forall (z3 :: * -> *) a1 a2 a3 a4 a5 a6 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> z3 b
liftFun6 Context -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> IO b
f a1
x1 a2
x2 a3
x3 a4
x4 a5
x5 a6
x6 =
  z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext z3 Context -> (Context -> z3 b) -> z3 b
forall a b. z3 a -> (a -> z3 b) -> z3 b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context
ctx -> IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Context -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> IO b
f Context
ctx a1
x1 a2
x2 a3
x3 a4
x4 a5
x5 a6
x6)

liftSolver0 :: MonadZ3 z3 =>
       (Base.Context -> Base.Solver -> IO b)
    -> z3 b
liftSolver0 :: forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO b
f_s =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Solver -> IO b) -> Solver -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context -> Solver -> IO b
f_s Context
ctx (Solver -> z3 b) -> z3 Solver -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver

liftSolver1 :: MonadZ3 z3 =>
       (Base.Context -> Base.Solver -> a -> IO b)
    -> a -> z3 b
liftSolver1 :: forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> a -> IO b
f_s a
a =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Solver -> IO b) -> Solver -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Solver
s -> Context -> Solver -> a -> IO b
f_s Context
ctx Solver
s a
a) (Solver -> z3 b) -> z3 Solver -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver

liftSolver2 :: MonadZ3 z3 => (Base.Context -> Base.Solver -> a -> b -> IO c)
                             -> a -> b -> z3 c
liftSolver2 :: forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> Solver -> a -> b -> IO c) -> a -> b -> z3 c
liftSolver2 Context -> Solver -> a -> b -> IO c
f a
a b
b = do
  Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
  Solver
slv <- z3 Solver
forall (m :: * -> *). MonadZ3 m => m Solver
getSolver
  IO c -> z3 c
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO c -> z3 c) -> IO c -> z3 c
forall a b. (a -> b) -> a -> b
$ Context -> Solver -> a -> b -> IO c
f Context
ctx Solver
slv a
a b
b

liftFixedpoint0 :: MonadFixedpoint z3 =>
       (Base.Context -> Base.Fixedpoint -> IO b)
    -> z3 b
liftFixedpoint0 :: forall (z3 :: * -> *) b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> IO b) -> z3 b
liftFixedpoint0 Context -> Fixedpoint -> IO b
f_s =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Fixedpoint -> IO b) -> Fixedpoint -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context -> Fixedpoint -> IO b
f_s Context
ctx (Fixedpoint -> z3 b) -> z3 Fixedpoint -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Fixedpoint
forall (m :: * -> *). MonadFixedpoint m => m Fixedpoint
getFixedpoint

liftFixedpoint1 :: MonadFixedpoint z3 =>
       (Base.Context -> Base.Fixedpoint -> a -> IO b)
    -> a -> z3 b
liftFixedpoint1 :: forall (z3 :: * -> *) a b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> IO b) -> a -> z3 b
liftFixedpoint1 Context -> Fixedpoint -> a -> IO b
f_s a
a =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Fixedpoint -> IO b) -> Fixedpoint -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Fixedpoint
s -> Context -> Fixedpoint -> a -> IO b
f_s Context
ctx Fixedpoint
s a
a) (Fixedpoint -> z3 b) -> z3 Fixedpoint -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Fixedpoint
forall (m :: * -> *). MonadFixedpoint m => m Fixedpoint
getFixedpoint

liftFixedpoint2 :: MonadFixedpoint z3 => (Base.Context -> Base.Fixedpoint -> a -> b -> IO c)
                             -> a -> b -> z3 c
liftFixedpoint2 :: forall (z3 :: * -> *) a b c.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> b -> IO c) -> a -> b -> z3 c
liftFixedpoint2 Context -> Fixedpoint -> a -> b -> IO c
f a
a b
b = do
  Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
  Fixedpoint
slv <- z3 Fixedpoint
forall (m :: * -> *). MonadFixedpoint m => m Fixedpoint
getFixedpoint
  IO c -> z3 c
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO c -> z3 c) -> IO c -> z3 c
forall a b. (a -> b) -> a -> b
$ Context -> Fixedpoint -> a -> b -> IO c
f Context
ctx Fixedpoint
slv a
a b
b

liftOptimize0 :: MonadOptimize z3 =>
       (Base.Context -> Base.Optimize -> IO b)
    -> z3 b
liftOptimize0 :: forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO b
f_s =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Optimize -> IO b) -> Optimize -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context -> Optimize -> IO b
f_s Context
ctx (Optimize -> z3 b) -> z3 Optimize -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Optimize
forall (m :: * -> *). MonadOptimize m => m Optimize
getOptimize

liftOptimize1 :: MonadOptimize z3 =>
       (Base.Context -> Base.Optimize -> a -> IO b)
    -> a -> z3 b
liftOptimize1 :: forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> a -> IO b
f_s a
a =
  do Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
     IO b -> z3 b
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO b -> z3 b) -> (Optimize -> IO b) -> Optimize -> z3 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Optimize
s -> Context -> Optimize -> a -> IO b
f_s Context
ctx Optimize
s a
a) (Optimize -> z3 b) -> z3 Optimize -> z3 b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< z3 Optimize
forall (m :: * -> *). MonadOptimize m => m Optimize
getOptimize

liftOptimize2 :: MonadOptimize z3 => (Base.Context -> Base.Optimize -> a -> b -> IO c)
                             -> a -> b -> z3 c
liftOptimize2 :: forall (z3 :: * -> *) a b c.
MonadOptimize z3 =>
(Context -> Optimize -> a -> b -> IO c) -> a -> b -> z3 c
liftOptimize2 Context -> Optimize -> a -> b -> IO c
f a
a b
b = do
  Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
  Optimize
slv <- z3 Optimize
forall (m :: * -> *). MonadOptimize m => m Optimize
getOptimize
  IO c -> z3 c
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO c -> z3 c) -> IO c -> z3 c
forall a b. (a -> b) -> a -> b
$ Context -> Optimize -> a -> b -> IO c
f Context
ctx Optimize
slv a
a b
b

liftOptimize3 :: MonadOptimize z3 => (Base.Context -> Base.Optimize -> a -> b -> c -> IO d)
                             -> a -> b -> c -> z3 d
liftOptimize3 :: forall (z3 :: * -> *) a b c d.
MonadOptimize z3 =>
(Context -> Optimize -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftOptimize3 Context -> Optimize -> a -> b -> c -> IO d
f a
a b
b c
c = do
  Context
ctx <- z3 Context
forall (m :: * -> *). MonadZ3 m => m Context
getContext
  Optimize
slv <- z3 Optimize
forall (m :: * -> *). MonadOptimize m => m Optimize
getOptimize
  IO d -> z3 d
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO d -> z3 d) -> IO d -> z3 d
forall a b. (a -> b) -> a -> b
$ Context -> Optimize -> a -> b -> c -> IO d
f Context
ctx Optimize
slv a
a b
b c
c

-------------------------------------------------
-- A simple Z3 monad.

newtype Z3 a = Z3 { forall a. Z3 a -> ReaderT Z3Env IO a
_unZ3 :: ReaderT Z3Env IO a }
    deriving ((forall a b. (a -> b) -> Z3 a -> Z3 b)
-> (forall a b. a -> Z3 b -> Z3 a) -> Functor Z3
forall a b. a -> Z3 b -> Z3 a
forall a b. (a -> b) -> Z3 a -> Z3 b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Z3 a -> Z3 b
fmap :: forall a b. (a -> b) -> Z3 a -> Z3 b
$c<$ :: forall a b. a -> Z3 b -> Z3 a
<$ :: forall a b. a -> Z3 b -> Z3 a
Functor, Functor Z3
Functor Z3
-> (forall a. a -> Z3 a)
-> (forall a b. Z3 (a -> b) -> Z3 a -> Z3 b)
-> (forall a b c. (a -> b -> c) -> Z3 a -> Z3 b -> Z3 c)
-> (forall a b. Z3 a -> Z3 b -> Z3 b)
-> (forall a b. Z3 a -> Z3 b -> Z3 a)
-> Applicative Z3
forall a. a -> Z3 a
forall a b. Z3 a -> Z3 b -> Z3 a
forall a b. Z3 a -> Z3 b -> Z3 b
forall a b. Z3 (a -> b) -> Z3 a -> Z3 b
forall a b c. (a -> b -> c) -> Z3 a -> Z3 b -> Z3 c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Z3 a
pure :: forall a. a -> Z3 a
$c<*> :: forall a b. Z3 (a -> b) -> Z3 a -> Z3 b
<*> :: forall a b. Z3 (a -> b) -> Z3 a -> Z3 b
$cliftA2 :: forall a b c. (a -> b -> c) -> Z3 a -> Z3 b -> Z3 c
liftA2 :: forall a b c. (a -> b -> c) -> Z3 a -> Z3 b -> Z3 c
$c*> :: forall a b. Z3 a -> Z3 b -> Z3 b
*> :: forall a b. Z3 a -> Z3 b -> Z3 b
$c<* :: forall a b. Z3 a -> Z3 b -> Z3 a
<* :: forall a b. Z3 a -> Z3 b -> Z3 a
Applicative, Applicative Z3
Applicative Z3
-> (forall a b. Z3 a -> (a -> Z3 b) -> Z3 b)
-> (forall a b. Z3 a -> Z3 b -> Z3 b)
-> (forall a. a -> Z3 a)
-> Monad Z3
forall a. a -> Z3 a
forall a b. Z3 a -> Z3 b -> Z3 b
forall a b. Z3 a -> (a -> Z3 b) -> Z3 b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. Z3 a -> (a -> Z3 b) -> Z3 b
>>= :: forall a b. Z3 a -> (a -> Z3 b) -> Z3 b
$c>> :: forall a b. Z3 a -> Z3 b -> Z3 b
>> :: forall a b. Z3 a -> Z3 b -> Z3 b
$creturn :: forall a. a -> Z3 a
return :: forall a. a -> Z3 a
Monad, Monad Z3
Monad Z3 -> (forall a. IO a -> Z3 a) -> MonadIO Z3
forall a. IO a -> Z3 a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall a. IO a -> Z3 a
liftIO :: forall a. IO a -> Z3 a
MonadIO, Monad Z3
Monad Z3 -> (forall a. (a -> Z3 a) -> Z3 a) -> MonadFix Z3
forall a. (a -> Z3 a) -> Z3 a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
$cmfix :: forall a. (a -> Z3 a) -> Z3 a
mfix :: forall a. (a -> Z3 a) -> Z3 a
MonadFix, Monad Z3
Monad Z3 -> (forall a. String -> Z3 a) -> MonadFail Z3
forall a. String -> Z3 a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
$cfail :: forall a. String -> Z3 a
fail :: forall a. String -> Z3 a
MonadFail)

-- | Z3 environment.
data Z3Env
  = Z3Env {
      Z3Env -> Solver
envSolver     :: Base.Solver
    , Z3Env -> Context
envContext    :: Base.Context
    , Z3Env -> Fixedpoint
envFixedpoint :: Base.Fixedpoint
    , Z3Env -> Optimize
envOptimize   :: Base.Optimize
    }

instance MonadZ3 Z3 where
  getSolver :: Z3 Solver
getSolver  = ReaderT Z3Env IO Solver -> Z3 Solver
forall a. ReaderT Z3Env IO a -> Z3 a
Z3 (ReaderT Z3Env IO Solver -> Z3 Solver)
-> ReaderT Z3Env IO Solver -> Z3 Solver
forall a b. (a -> b) -> a -> b
$ (Z3Env -> Solver) -> ReaderT Z3Env IO Solver
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks Z3Env -> Solver
envSolver
  getContext :: Z3 Context
getContext = ReaderT Z3Env IO Context -> Z3 Context
forall a. ReaderT Z3Env IO a -> Z3 a
Z3 (ReaderT Z3Env IO Context -> Z3 Context)
-> ReaderT Z3Env IO Context -> Z3 Context
forall a b. (a -> b) -> a -> b
$ (Z3Env -> Context) -> ReaderT Z3Env IO Context
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks Z3Env -> Context
envContext

instance MonadFixedpoint Z3 where
  getFixedpoint :: Z3 Fixedpoint
getFixedpoint = ReaderT Z3Env IO Fixedpoint -> Z3 Fixedpoint
forall a. ReaderT Z3Env IO a -> Z3 a
Z3 (ReaderT Z3Env IO Fixedpoint -> Z3 Fixedpoint)
-> ReaderT Z3Env IO Fixedpoint -> Z3 Fixedpoint
forall a b. (a -> b) -> a -> b
$ (Z3Env -> Fixedpoint) -> ReaderT Z3Env IO Fixedpoint
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks Z3Env -> Fixedpoint
envFixedpoint

instance MonadOptimize Z3 where
  getOptimize :: Z3 Optimize
getOptimize = ReaderT Z3Env IO Optimize -> Z3 Optimize
forall a. ReaderT Z3Env IO a -> Z3 a
Z3 (ReaderT Z3Env IO Optimize -> Z3 Optimize)
-> ReaderT Z3Env IO Optimize -> Z3 Optimize
forall a b. (a -> b) -> a -> b
$ (Z3Env -> Optimize) -> ReaderT Z3Env IO Optimize
forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks Z3Env -> Optimize
envOptimize

-- | Eval a Z3 script.
evalZ3With :: Maybe Logic -> Opts -> Z3 a -> IO a
evalZ3With :: forall a. Maybe Logic -> Opts -> Z3 a -> IO a
evalZ3With Maybe Logic
mbLogic Opts
opts (Z3 ReaderT Z3Env IO a
s) = do
  Z3Env
env <- Maybe Logic -> Opts -> IO Z3Env
newEnv Maybe Logic
mbLogic Opts
opts
  ReaderT Z3Env IO a -> Z3Env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT Z3Env IO a
s Z3Env
env

-- | Eval a Z3 script with default configuration options.
evalZ3 :: Z3 a -> IO a
evalZ3 :: forall a. Z3 a -> IO a
evalZ3 = Maybe Logic -> Opts -> Z3 a -> IO a
forall a. Maybe Logic -> Opts -> Z3 a -> IO a
evalZ3With Maybe Logic
forall a. Maybe a
Nothing Opts
stdOpts


newEnvWith :: (Base.Config -> IO Base.Context) -> Maybe Logic -> Opts -> IO Z3Env
newEnvWith :: (Config -> IO Context) -> Maybe Logic -> Opts -> IO Z3Env
newEnvWith Config -> IO Context
mkContext Maybe Logic
mbLogic Opts
opts =
  (Config -> IO Z3Env) -> IO Z3Env
forall a. (Config -> IO a) -> IO a
Base.withConfig ((Config -> IO Z3Env) -> IO Z3Env)
-> (Config -> IO Z3Env) -> IO Z3Env
forall a b. (a -> b) -> a -> b
$ \Config
cfg -> do
    Config -> Opts -> IO ()
setOpts Config
cfg Opts
opts
    Context
ctx <- Config -> IO Context
mkContext Config
cfg
    Solver
solver <- IO Solver -> (Logic -> IO Solver) -> Maybe Logic -> IO Solver
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Context -> IO Solver
Base.mkSolver Context
ctx) (Context -> Logic -> IO Solver
Base.mkSolverForLogic Context
ctx) Maybe Logic
mbLogic
    Fixedpoint
fixedpoint <- Context -> IO Fixedpoint
Base.mkFixedpoint Context
ctx
    Optimize
optimize <- Context -> IO Optimize
Base.mkOptimize Context
ctx
    Z3Env -> IO Z3Env
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Z3Env -> IO Z3Env) -> Z3Env -> IO Z3Env
forall a b. (a -> b) -> a -> b
$ Solver -> Context -> Fixedpoint -> Optimize -> Z3Env
Z3Env Solver
solver Context
ctx Fixedpoint
fixedpoint Optimize
optimize

-- | Create a new Z3 environment.
newEnv :: Maybe Logic -> Opts -> IO Z3Env
newEnv :: Maybe Logic -> Opts -> IO Z3Env
newEnv = (Config -> IO Context) -> Maybe Logic -> Opts -> IO Z3Env
newEnvWith Config -> IO Context
Base.mkContext

-- | Eval a Z3 script with a given environment.
--
-- Environments may facilitate running many queries under the same
-- logical context.
--
-- Note that an environment may change after each query.
-- If you want to preserve the same environment then use 'local', as in
-- @evalZ3WithEnv /env/ (local /query/)@.
evalZ3WithEnv :: Z3 a
              -> Z3Env
              -> IO a
evalZ3WithEnv :: forall a. Z3 a -> Z3Env -> IO a
evalZ3WithEnv (Z3 ReaderT Z3Env IO a
s) = ReaderT Z3Env IO a -> Z3Env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT Z3Env IO a
s

---------------------------------------------------------------------
-- * Parameters

-- | Create a Z3 (empty) parameter set.
--
-- Starting at Z3 4.0, parameter sets are used to configure many components
-- such as: simplifiers, tactics, solvers, etc.
mkParams :: MonadZ3 z3 => z3 Params
mkParams :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Params
mkParams = (Context -> IO Params) -> z3 Params
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Params
Base.mkParams

-- | Add a Boolean parameter /k/ with value /v/ to the parameter set /p/.
paramsSetBool :: MonadZ3 z3 => Params -> Symbol -> Bool -> z3 ()
paramsSetBool :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Params -> Symbol -> Bool -> z3 ()
paramsSetBool = (Context -> Params -> Symbol -> Bool -> IO ())
-> Params -> Symbol -> Bool -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Params -> Symbol -> Bool -> IO ()
Base.paramsSetBool

-- | Add a unsigned parameter /k/ with value /v/ to the parameter set /p/.
paramsSetUInt :: MonadZ3 z3 => Params -> Symbol -> Word -> z3 ()
paramsSetUInt :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Params -> Symbol -> Word -> z3 ()
paramsSetUInt = (Context -> Params -> Symbol -> Word -> IO ())
-> Params -> Symbol -> Word -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Params -> Symbol -> Word -> IO ()
Base.paramsSetUInt

-- | Add a double parameter /k/ with value /v/ to the parameter set /p/.
paramsSetDouble :: MonadZ3 z3 => Params -> Symbol -> Double -> z3 ()
paramsSetDouble :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Params -> Symbol -> Double -> z3 ()
paramsSetDouble = (Context -> Params -> Symbol -> Double -> IO ())
-> Params -> Symbol -> Double -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Params -> Symbol -> Double -> IO ()
Base.paramsSetDouble

-- | Add a symbol parameter /k/ with value /v/ to the parameter set /p/.
paramsSetSymbol :: MonadZ3 z3 => Params -> Symbol -> Symbol -> z3 ()
paramsSetSymbol :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Params -> Symbol -> Symbol -> z3 ()
paramsSetSymbol = (Context -> Params -> Symbol -> Symbol -> IO ())
-> Params -> Symbol -> Symbol -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Params -> Symbol -> Symbol -> IO ()
Base.paramsSetSymbol

-- | Convert a parameter set into a string.
--
-- This function is mainly used for printing the contents of a parameter set.
paramsToString :: MonadZ3 z3 => Params -> z3 String
paramsToString :: forall (z3 :: * -> *). MonadZ3 z3 => Params -> z3 String
paramsToString = (Context -> Params -> IO String) -> Params -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Params -> IO String
Base.paramsToString

-- TODO: Z3_params_validate

---------------------------------------------------------------------
-- Symbols

-- | Create a Z3 symbol using an integer.
mkIntSymbol :: (MonadZ3 z3, Integral i) => i -> z3 Symbol
mkIntSymbol :: forall (z3 :: * -> *) i. (MonadZ3 z3, Integral i) => i -> z3 Symbol
mkIntSymbol = (Context -> i -> IO Symbol) -> i -> z3 Symbol
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> i -> IO Symbol
forall int. Integral int => Context -> int -> IO Symbol
Base.mkIntSymbol

-- | Create a Z3 symbol using a string.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gafebb0d3c212927cf7834c3a20a84ecae>
mkStringSymbol :: MonadZ3 z3 => String -> z3 Symbol
mkStringSymbol :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 Symbol
mkStringSymbol = (Context -> String -> IO Symbol) -> String -> z3 Symbol
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO Symbol
Base.mkStringSymbol

---------------------------------------------------------------------
-- Sorts

-- | Create a free (uninterpreted) type using the given name (symbol).
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga736e88741af1c178cbebf94c49aa42de>
mkUninterpretedSort :: MonadZ3 z3 => Symbol -> z3 Sort
mkUninterpretedSort :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> z3 Sort
mkUninterpretedSort = (Context -> Symbol -> IO Sort) -> Symbol -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Symbol -> IO Sort
Base.mkUninterpretedSort

-- | Create the /boolean/ type.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gacdc73510b69a010b71793d429015f342>
mkBoolSort :: MonadZ3 z3 => z3 Sort
mkBoolSort :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkBoolSort = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkBoolSort

-- | Create the /integer/ type.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga6cd426ab5748653b77d389fd3eac1015>
mkIntSort :: MonadZ3 z3 => z3 Sort
mkIntSort :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkIntSort = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkIntSort

-- | Create the /real/ type.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga40ef93b9738485caed6dc84631c3c1a0>
mkRealSort :: MonadZ3 z3 => z3 Sort
mkRealSort :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkRealSort = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkRealSort

-- | Create a bit-vector type of the given size.
--
-- This type can also be seen as a machine integer.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaeed000a1bbb84b6ca6fdaac6cf0c1688>
mkBvSort :: MonadZ3 z3 => Int -> z3 Sort
mkBvSort :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> z3 Sort
mkBvSort = (Context -> Int -> IO Sort) -> Int -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Int -> IO Sort
forall int. Integral int => Context -> int -> IO Sort
Base.mkBvSort

-- | Create a finite-domain type.
mkFiniteDomainSort :: MonadZ3 z3 => Symbol -> Word64 -> z3 Sort
mkFiniteDomainSort :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> Word64 -> z3 Sort
mkFiniteDomainSort = (Context -> Symbol -> Word64 -> IO Sort)
-> Symbol -> Word64 -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Symbol -> Word64 -> IO Sort
Base.mkFiniteDomainSort

-- | Create an array type
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gafe617994cce1b516f46128e448c84445>
--
mkArraySort :: MonadZ3 z3 => Sort -> Sort -> z3 Sort
mkArraySort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> Sort -> z3 Sort
mkArraySort = (Context -> Sort -> Sort -> IO Sort) -> Sort -> Sort -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> Sort -> IO Sort
Base.mkArraySort

-- | Create a tuple type
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga7156b9c0a76a28fae46c81f8e3cdf0f1>
mkTupleSort :: MonadZ3 z3
            => Symbol                          -- ^ Name of the sort
            -> [(Symbol, Sort)]                -- ^ Name and sort of each field
            -> z3 (Sort, FuncDecl, [FuncDecl]) -- ^ Resulting sort, and function
                                               -- declarations for the
                                               -- constructor and projections.
mkTupleSort :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Symbol -> [(Symbol, Sort)] -> z3 (Sort, FuncDecl, [FuncDecl])
mkTupleSort = (Context
 -> Symbol -> [(Symbol, Sort)] -> IO (Sort, FuncDecl, [FuncDecl]))
-> Symbol -> [(Symbol, Sort)] -> z3 (Sort, FuncDecl, [FuncDecl])
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context
-> Symbol -> [(Symbol, Sort)] -> IO (Sort, FuncDecl, [FuncDecl])
Base.mkTupleSort

-- | Create a constructor
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaa779e39f7050b9d51857887954b5f9b0>
mkConstructor :: MonadZ3 z3
              => Symbol                       -- ^ Name of the constructor
              -> Symbol                       -- ^ Name of recognizer function
              -> [(Symbol, Maybe Sort, Int)]  -- ^ Name, sort option, and sortRefs
              -> z3 Constructor
mkConstructor :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Symbol -> Symbol -> [(Symbol, Maybe Sort, Int)] -> z3 Constructor
mkConstructor = (Context
 -> Symbol
 -> Symbol
 -> [(Symbol, Maybe Sort, Int)]
 -> IO Constructor)
-> Symbol
-> Symbol
-> [(Symbol, Maybe Sort, Int)]
-> z3 Constructor
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context
-> Symbol
-> Symbol
-> [(Symbol, Maybe Sort, Int)]
-> IO Constructor
Base.mkConstructor

-- | Create datatype, such as lists, trees, records, enumerations or unions of
--   records. The datatype may be recursive. Return the datatype sort.
--
-- Reference <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gab6809d53327d807da9158abdf75df387>
mkDatatype :: MonadZ3 z3
           => Symbol
           -> [Constructor]
           -> z3 Sort
mkDatatype :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Symbol -> [Constructor] -> z3 Sort
mkDatatype = (Context -> Symbol -> [Constructor] -> IO Sort)
-> Symbol -> [Constructor] -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Symbol -> [Constructor] -> IO Sort
Base.mkDatatype

-- | Create mutually recursive datatypes, such as a tree and forest.
--
-- Returns the datatype sorts
mkDatatypes :: MonadZ3 z3
            => [Symbol]
            -> [[Constructor]]
            -> z3 [Sort]
mkDatatypes :: forall (z3 :: * -> *).
MonadZ3 z3 =>
[Symbol] -> [[Constructor]] -> z3 [Sort]
mkDatatypes = (Context -> [Symbol] -> [[Constructor]] -> IO [Sort])
-> [Symbol] -> [[Constructor]] -> z3 [Sort]
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> [Symbol] -> [[Constructor]] -> IO [Sort]
Base.mkDatatypes

-- | Create a set type
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga6865879523e7e882d7e50a2d8445ac8b>
--
mkSetSort :: MonadZ3 z3 => Sort -> z3 Sort
mkSetSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Sort
mkSetSort = (Context -> Sort -> IO Sort) -> Sort -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Sort
Base.mkSetSort

---------------------------------------------------------------------
-- Constants and Applications

-- | A Z3 function
mkFuncDecl :: MonadZ3 z3 => Symbol -> [Sort] -> Sort -> z3 FuncDecl
mkFuncDecl :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Symbol -> [Sort] -> Sort -> z3 FuncDecl
mkFuncDecl = (Context -> Symbol -> [Sort] -> Sort -> IO FuncDecl)
-> Symbol -> [Sort] -> Sort -> z3 FuncDecl
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Symbol -> [Sort] -> Sort -> IO FuncDecl
Base.mkFuncDecl

-- | Create a constant or function application.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga33a202d86bf628bfab9b6f437536cebe>
mkApp :: MonadZ3 z3 => FuncDecl -> [AST] -> z3 AST
mkApp :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> [AST] -> z3 AST
mkApp = (Context -> FuncDecl -> [AST] -> IO AST)
-> FuncDecl -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> FuncDecl -> [AST] -> IO AST
Base.mkApp

-- | Declare and create a constant.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga093c9703393f33ae282ec5e8729354ef>
mkConst :: MonadZ3 z3 => Symbol -> Sort -> z3 AST
mkConst :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> Sort -> z3 AST
mkConst = (Context -> Symbol -> Sort -> IO AST) -> Symbol -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Symbol -> Sort -> IO AST
Base.mkConst

-- | Declare and create a constant.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga093c9703393f33ae282ec5e8729354ef>
mkFreshConst :: MonadZ3 z3 => String -> Sort -> z3 AST
mkFreshConst :: forall (z3 :: * -> *). MonadZ3 z3 => String -> Sort -> z3 AST
mkFreshConst = (Context -> String -> Sort -> IO AST) -> String -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> String -> Sort -> IO AST
Base.mkFreshConst

-- | Declare a fresh constant or function.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga1f60c7eb41c5603e55a188a14dc929ec>
mkFreshFuncDecl :: MonadZ3 z3 => String -> [Sort] -> Sort -> z3 FuncDecl
mkFreshFuncDecl :: forall (z3 :: * -> *).
MonadZ3 z3 =>
String -> [Sort] -> Sort -> z3 FuncDecl
mkFreshFuncDecl = (Context -> String -> [Sort] -> Sort -> IO FuncDecl)
-> String -> [Sort] -> Sort -> z3 FuncDecl
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> String -> [Sort] -> Sort -> IO FuncDecl
Base.mkFreshFuncDecl

-- | A recursive Z3 function
mkRecFuncDecl :: MonadZ3 z3 => Symbol -> [Sort] -> Sort -> z3 FuncDecl
mkRecFuncDecl :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Symbol -> [Sort] -> Sort -> z3 FuncDecl
mkRecFuncDecl = (Context -> Symbol -> [Sort] -> Sort -> IO FuncDecl)
-> Symbol -> [Sort] -> Sort -> z3 FuncDecl
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Symbol -> [Sort] -> Sort -> IO FuncDecl
Base.mkRecFuncDecl

-- | Define the body of a recursive Z3 function
addRecDef :: MonadZ3 z3 => FuncDecl -> [AST] -> AST -> z3 ()
addRecDef :: forall (z3 :: * -> *).
MonadZ3 z3 =>
FuncDecl -> [AST] -> AST -> z3 ()
addRecDef = (Context -> FuncDecl -> [AST] -> AST -> IO ())
-> FuncDecl -> [AST] -> AST -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> FuncDecl -> [AST] -> AST -> IO ()
Base.addRecDef

-------------------------------------------------
-- ** Helpers

-- | Declare and create a variable (aka /constant/).
--
-- An alias for 'mkConst'.
mkVar :: MonadZ3 z3 => Symbol -> Sort -> z3 AST
mkVar :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> Sort -> z3 AST
mkVar = (Context -> Symbol -> Sort -> IO AST) -> Symbol -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Symbol -> Sort -> IO AST
Base.mkVar

-- | Declarate and create a variable of sort /bool/.
--
-- See 'mkVar'.
mkBoolVar :: MonadZ3 z3 => Symbol -> z3 AST
mkBoolVar :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> z3 AST
mkBoolVar = (Context -> Symbol -> IO AST) -> Symbol -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Symbol -> IO AST
Base.mkBoolVar

-- | Declarate and create a variable of sort /real/.
--
-- See 'mkVar'.
mkRealVar :: MonadZ3 z3 => Symbol -> z3 AST
mkRealVar :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> z3 AST
mkRealVar = (Context -> Symbol -> IO AST) -> Symbol -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Symbol -> IO AST
Base.mkRealVar

-- | Declarate and create a variable of sort /int/.
--
-- See 'mkVar'.
mkIntVar :: MonadZ3 z3 => Symbol -> z3 AST
mkIntVar :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> z3 AST
mkIntVar = (Context -> Symbol -> IO AST) -> Symbol -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Symbol -> IO AST
Base.mkIntVar

-- | Declarate and create a variable of sort /bit-vector/.
--
-- See 'mkVar'.
mkBvVar :: MonadZ3 z3 => Symbol
                   -> Int     -- ^ bit-width
                   -> z3 AST
mkBvVar :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> Int -> z3 AST
mkBvVar = (Context -> Symbol -> Int -> IO AST) -> Symbol -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Symbol -> Int -> IO AST
Base.mkBvVar

-- | Declare and create a /fresh/ variable (aka /constant/).
--
-- An alias for 'mkFreshConst'.
mkFreshVar :: MonadZ3 z3 => String -> Sort -> z3 AST
mkFreshVar :: forall (z3 :: * -> *). MonadZ3 z3 => String -> Sort -> z3 AST
mkFreshVar = (Context -> String -> Sort -> IO AST) -> String -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> String -> Sort -> IO AST
Base.mkFreshConst

-- | Declarate and create a /fresh/ variable of sort /bool/.
--
-- See 'mkFreshVar'.
mkFreshBoolVar :: MonadZ3 z3 => String -> z3 AST
mkFreshBoolVar :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 AST
mkFreshBoolVar = (Context -> String -> IO AST) -> String -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO AST
Base.mkFreshBoolVar

-- | Declarate and create a /fresh/ variable of sort /real/.
--
-- See 'mkFreshVar'.
mkFreshRealVar :: MonadZ3 z3 => String -> z3 AST
mkFreshRealVar :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 AST
mkFreshRealVar = (Context -> String -> IO AST) -> String -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO AST
Base.mkFreshRealVar

-- | Declarate and create a /fresh/ variable of sort /int/.
--
-- See 'mkFreshVar'.
mkFreshIntVar :: MonadZ3 z3 => String -> z3 AST
mkFreshIntVar :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 AST
mkFreshIntVar = (Context -> String -> IO AST) -> String -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO AST
Base.mkFreshIntVar

-- | Declarate and create a /fresh/ variable of sort /bit-vector/.
--
-- See 'mkFreshVar'.
mkFreshBvVar :: MonadZ3 z3 => String
                        -> Int     -- ^ bit-width
                        -> z3 AST
mkFreshBvVar :: forall (z3 :: * -> *). MonadZ3 z3 => String -> Int -> z3 AST
mkFreshBvVar = (Context -> String -> Int -> IO AST) -> String -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> String -> Int -> IO AST
Base.mkFreshBvVar

---------------------------------------------------------------------
-- Propositional Logic and Equality

-- | Create an AST node representing /true/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gae898e7380409bbc57b56cc5205ef1db7>
mkTrue :: MonadZ3 z3 => z3 AST
mkTrue :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkTrue = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkTrue

-- | Create an AST node representing /false/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga5952ac17671117a02001fed6575c778d>
mkFalse :: MonadZ3 z3 => z3 AST
mkFalse :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFalse = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFalse

-- | Create an AST node representing /l = r/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga95a19ce675b70e22bb0401f7137af37c>
mkEq :: MonadZ3 z3 => AST -> AST -> z3 AST
mkEq :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkEq = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkEq

-- | The distinct construct is used for declaring the arguments pairwise
-- distinct.
--
-- Requires a non-empty list.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaa076d3a668e0ec97d61744403153ecf7>
mkDistinct :: MonadZ3 z3 => [AST] -> z3 AST
mkDistinct :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkDistinct = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkDistinct

-- | Same as 'mkDistinct' but type-safe.
mkDistinct1 :: MonadZ3 z3 => NonEmpty AST -> z3 AST
mkDistinct1 :: forall (z3 :: * -> *). MonadZ3 z3 => NonEmpty AST -> z3 AST
mkDistinct1 = (Context -> NonEmpty AST -> IO AST) -> NonEmpty AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> NonEmpty AST -> IO AST
Base.mkDistinct1

-- | Create an AST node representing /not(a)/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga3329538091996eb7b3dc677760a61072>
mkNot :: MonadZ3 z3 => AST -> z3 AST
mkNot :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkNot = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkNot

-- | Create an AST node representing an if-then-else: /ite(t1, t2, t3)/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga94417eed5c36e1ad48bcfc8ad6e83547>
mkIte :: MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkIte :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkIte = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkIte

-- | Create an AST node representing /t1 iff t2/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga930a8e844d345fbebc498ac43a696042>
mkIff :: MonadZ3 z3 => AST -> AST -> z3 AST
mkIff :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkIff = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkIff

-- | Create an AST node representing /t1 implies t2/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac829c0e25bbbd30343bf073f7b524517>
mkImplies :: MonadZ3 z3 => AST -> AST -> z3 AST
mkImplies :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkImplies = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkImplies

-- | Create an AST node representing /t1 xor t2/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gacc6d1b848032dec0c4617b594d4229ec>
mkXor :: MonadZ3 z3 => AST -> AST -> z3 AST
mkXor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkXor = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkXor

-- | Create an AST node representing args[0] and ... and args[num_args-1].
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gacde98ce4a8ed1dde50b9669db4838c61>
mkAnd :: MonadZ3 z3 => [AST] -> z3 AST
mkAnd :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkAnd = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkAnd

-- | Create an AST node representing args[0] or ... or args[num_args-1].
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga00866d16331d505620a6c515302021f9>
mkOr :: MonadZ3 z3 => [AST] -> z3 AST
mkOr :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkOr = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkOr

-------------------------------------------------
-- ** Helpers

-- | Create an AST node representing the given boolean.
mkBool :: MonadZ3 z3 => Bool -> z3 AST
mkBool :: forall (z3 :: * -> *). MonadZ3 z3 => Bool -> z3 AST
mkBool = (Context -> Bool -> IO AST) -> Bool -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Bool -> IO AST
Base.mkBool

---------------------------------------------------------------------
-- Arithmetic: Integers and Reals

-- | Create an AST node representing args[0] + ... + args[num_args-1].
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4e4ac0a4e53eee0b4b0ef159ed7d0cd5>
mkAdd :: MonadZ3 z3 => [AST] -> z3 AST
mkAdd :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkAdd = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkAdd

-- | Create an AST node representing args[0] * ... * args[num_args-1].
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gab9affbf8401a18eea474b59ad4adc890>
mkMul :: MonadZ3 z3 => [AST] -> z3 AST
mkMul :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkMul = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkMul

-- | Create an AST node representing args[0] - ... - args[num_args - 1].
--
-- Requires a non-empty list.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4f5fea9b683f9e674fd8f14d676cc9a9>
mkSub :: MonadZ3 z3 => [AST] -> z3 AST
mkSub :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkSub = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkSub

-- | Same as 'mkSub' but type-safe.
mkSub1 :: MonadZ3 z3 => NonEmpty AST -> z3 AST
mkSub1 :: forall (z3 :: * -> *). MonadZ3 z3 => NonEmpty AST -> z3 AST
mkSub1 = (Context -> NonEmpty AST -> IO AST) -> NonEmpty AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> NonEmpty AST -> IO AST
Base.mkSub1

-- | Create an AST node representing -arg.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gadcd2929ad732937e25f34277ce4988ea>
mkUnaryMinus :: MonadZ3 z3 => AST -> z3 AST
mkUnaryMinus :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkUnaryMinus = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkUnaryMinus

-- | Create an AST node representing arg1 div arg2.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga1ac60ee8307af8d0b900375914194ff3>
mkDiv :: MonadZ3 z3 => AST -> AST -> z3 AST
mkDiv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkDiv = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkDiv

-- | Create an AST node representing arg1 mod arg2.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga8e350ac77e6b8fe805f57efe196e7713>
mkMod :: MonadZ3 z3 => AST -> AST -> z3 AST
mkMod :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkMod = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkMod

-- | Create an AST node representing arg1 rem arg2.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga2fcdb17f9039bbdaddf8a30d037bd9ff>
mkRem :: MonadZ3 z3 => AST -> AST -> z3 AST
mkRem :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkRem = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkRem

-- | Create an AST node representing arg1 ^ arg2.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga8414506c805caa171f0c1fe29f9f9612>
mkPower :: MonadZ3 z3 => AST -> AST -> z3 AST
mkPower :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkPower = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkPower

-- | Create less than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga58a3dc67c5de52cf599c346803ba1534>
mkLt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkLt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkLt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkLt

-- | Create less than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaa9a33d11096841f4e8c407f1578bc0bf>
mkLe :: MonadZ3 z3 => AST -> AST -> z3 AST
mkLe :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkLe = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkLe

-- | Create greater than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga46167b86067586bb742c0557d7babfd3>
mkGt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkGt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkGt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkGt

-- | Create greater than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gad9245cbadb80b192323d01a8360fb942>
mkGe :: MonadZ3 z3 => AST -> AST -> z3 AST
mkGe :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkGe = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkGe

-- | Coerce an integer to a real.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga7130641e614c7ebafd28ae16a7681a21>
mkInt2Real :: MonadZ3 z3 => AST -> z3 AST
mkInt2Real :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkInt2Real = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkInt2Real

-- | Coerce a real to an integer.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga759b6563ba1204aae55289009a3fdc6d>
mkReal2Int :: MonadZ3 z3 => AST -> z3 AST
mkReal2Int :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkReal2Int = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkReal2Int

-- | Check if a real number is an integer.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaac2ad0fb04e4900fdb4add438d137ad3>
mkIsInt :: MonadZ3 z3 => AST -> z3 AST
mkIsInt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkIsInt = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkIsInt

---------------------------------------------------------------------
-- Bit-vectors

-- | Bitwise negation.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga36cf75c92c54c1ca633a230344f23080>
mkBvnot :: MonadZ3 z3 => AST -> z3 AST
mkBvnot :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkBvnot = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkBvnot

-- | Take conjunction of bits in vector, return vector of length 1.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaccc04f2b58903279b1b3be589b00a7d8>
mkBvredand :: MonadZ3 z3 => AST -> z3 AST
mkBvredand :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkBvredand = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkBvredand

-- | Take disjunction of bits in vector, return vector of length 1.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gafd18e127c0586abf47ad9cd96895f7d2>
mkBvredor :: MonadZ3 z3 => AST -> z3 AST
mkBvredor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkBvredor = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkBvredor

-- | Bitwise and.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gab96e0ea55334cbcd5a0e79323b57615d>
mkBvand :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvand :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvand  = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvand

-- | Bitwise or.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga77a6ae233fb3371d187c6d559b2843f5>
mkBvor :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvor = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvor

-- | Bitwise exclusive-or.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga0a3821ea00b1c762205f73e4bc29e7d8>
mkBvxor :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvxor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvxor = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvxor

-- | Bitwise nand.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga96dc37d36efd658fff5b2b4df49b0e61>
mkBvnand :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvnand :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvnand = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvnand

-- | Bitwise nor.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gabf15059e9e8a2eafe4929fdfd259aadb>
mkBvnor :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvnor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvnor = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvnor

-- | Bitwise xnor.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga784f5ca36a4b03b93c67242cc94b21d6>
mkBvxnor :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvxnor :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvxnor = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvxnor

-- | Standard two's complement unary minus.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga0c78be00c03eda4ed6a983224ed5c7b7
mkBvneg :: MonadZ3 z3 => AST -> z3 AST
mkBvneg :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkBvneg = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkBvneg

-- | Standard two's complement addition.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga819814e33573f3f9948b32fdc5311158>
mkBvadd :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvadd :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvadd = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvadd

-- | Standard two's complement subtraction.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga688c9aa1347888c7a51be4e46c19178e>
mkBvsub :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsub :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsub = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsub

-- | Standard two's complement multiplication.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga6abd3dde2a1ceff1704cf7221a72258c>
mkBvmul :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvmul :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvmul = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvmul

-- | Unsigned division.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga56ce0cd61666c6f8cf5777286f590544>
mkBvudiv :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvudiv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvudiv = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvudiv

-- | Two's complement signed division.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gad240fedb2fda1c1005b8e9d3c7f3d5a0>
mkBvsdiv :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsdiv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsdiv = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsdiv

-- | Unsigned remainder.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga5df4298ec835e43ddc9e3e0bae690c8d>
mkBvurem :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvurem :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvurem = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvurem

-- | Two's complement signed remainder (sign follows dividend).
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga46c18a3042fca174fe659d3185693db1>
mkBvsrem :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsrem :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsrem = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsrem

-- | Two's complement signed remainder (sign follows divisor).
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga95dac8e6eecb50f63cb82038560e0879>
mkBvsmod :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsmod :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsmod = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsmod

-- | Unsigned less than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga5774b22e93abcaf9b594672af6c7c3c4>
mkBvult :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvult :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvult = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvult

-- | Two's complement signed less than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga8ce08af4ed1fbdf08d4d6e63d171663a>
mkBvslt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvslt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvslt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvslt

-- | Unsigned less than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gab738b89de0410e70c089d3ac9e696e87>
mkBvule :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvule :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvule = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvule

-- | Two's complement signed less than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gab7c026feb93e7d2eab180e96f1e6255d>
mkBvsle :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsle :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsle = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsle

-- | Unsigned greater than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gade58fbfcf61b67bf8c4a441490d3c4df>
mkBvuge :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvuge :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvuge = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvuge

-- | Two's complement signed greater than or equal to.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaeec3414c0e8a90a6aa5a23af36bf6dc5>
mkBvsge :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsge :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsge = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsge

-- | Unsigned greater than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga063ab9f16246c99e5c1c893613927ee3>
mkBvugt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvugt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvugt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvugt

-- | Two's complement signed greater than.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4e93a985aa2a7812c7c11a2c65d7c5f0>
mkBvsgt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsgt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsgt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsgt

-- | Concatenate the given bit-vectors.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gae774128fa5e9ff7458a36bd10e6ca0fa>
mkConcat :: MonadZ3 z3 => AST -> AST -> z3 AST
mkConcat :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkConcat = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkConcat

-- | Extract the bits high down to low from a bitvector of size m to yield a new
-- bitvector of size /n/, where /n = high - low + 1/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga32d2fe7563f3e6b114c1b97b205d4317>
mkExtract :: MonadZ3 z3 => Int -> Int -> AST -> z3 AST
mkExtract :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> Int -> AST -> z3 AST
mkExtract = (Context -> Int -> Int -> AST -> IO AST)
-> Int -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Int -> Int -> AST -> IO AST
Base.mkExtract

-- | Sign-extend of the given bit-vector to the (signed) equivalent bitvector
-- of size /m+i/, where /m/ is the size of the given bit-vector.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gad29099270b36d0680bb54b560353c10e>
mkSignExt :: MonadZ3 z3 => Int -> AST -> z3 AST
mkSignExt :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkSignExt = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkSignExt

-- | Extend the given bit-vector with zeros to the (unsigned) equivalent
-- bitvector of size /m+i/, where /m/ is the size of the given bit-vector.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac9322fae11365a78640baf9078c428b3>
mkZeroExt :: MonadZ3 z3 => Int -> AST -> z3 AST
mkZeroExt :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkZeroExt = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkZeroExt

-- | Repeat the given bit-vector up length /i/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga03e81721502ea225c264d1f556c9119d>
mkRepeat :: MonadZ3 z3 => Int -> AST -> z3 AST
mkRepeat :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkRepeat = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkRepeat

-- | Shift left.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac8d5e776c786c1172fa0d7dfede454e1>
mkBvshl :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvshl :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvshl = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvshl

-- | Logical shift right.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac59645a6edadad79a201f417e4e0c512>
mkBvlshr :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvlshr :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvlshr = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvlshr

-- | Arithmetic shift right.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga674b580ad605ba1c2c9f9d3748be87c4>
mkBvashr :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvashr :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvashr = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvashr

-- | Rotate bits of /t1/ to the left /i/ times.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4932b7d08fea079dd903cd857a52dcda>
mkRotateLeft :: MonadZ3 z3 => Int -> AST -> z3 AST
mkRotateLeft :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkRotateLeft = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkRotateLeft

-- | Rotate bits of /t1/ to the right /i/ times.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga3b94e1bf87ecd1a1858af8ebc1da4a1c>
mkRotateRight :: MonadZ3 z3 => Int -> AST -> z3 AST
mkRotateRight :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkRotateRight = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkRotateRight

-- | Rotate bits of /t1/ to the left /t2/ times.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaf46f1cb80e5a56044591a76e7c89e5e7>
mkExtRotateLeft :: MonadZ3 z3 => AST -> AST -> z3 AST
mkExtRotateLeft :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkExtRotateLeft = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkExtRotateLeft

-- | Rotate bits of /t1/ to the right /t2/ times.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gabb227526c592b523879083f12aab281f>
mkExtRotateRight :: MonadZ3 z3 => AST -> AST -> z3 AST
mkExtRotateRight :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkExtRotateRight = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkExtRotateRight

-- | Create an /n/ bit bit-vector from the integer argument /t1/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga35f89eb05df43fbd9cce7200cc1f30b5>
mkInt2bv :: MonadZ3 z3 => Int -> AST -> z3 AST
mkInt2bv :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> AST -> z3 AST
mkInt2bv = (Context -> Int -> AST -> IO AST) -> Int -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> AST -> IO AST
Base.mkInt2bv

-- | Create an integer from the bit-vector argument /t1/. If /is_signed/ is false,
-- then the bit-vector /t1/ is treated as unsigned. So the result is non-negative
-- and in the range [0..2^/N/-1], where /N/ are the number of bits in /t1/.
-- If /is_signed/ is true, /t1/ is treated as a signed bit-vector.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac87b227dc3821d57258d7f53a28323d4>
mkBv2int :: MonadZ3 z3 => AST -> Bool -> z3 AST
mkBv2int :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Bool -> z3 AST
mkBv2int = (Context -> AST -> Bool -> IO AST) -> AST -> Bool -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Bool -> IO AST
Base.mkBv2int

-- | Create a predicate that checks that the bit-wise addition of /t1/ and /t2/
-- does not overflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga88f6b5ec876f05e0d7ba51e96c4b077f>
mkBvaddNoOverflow :: MonadZ3 z3 => AST -> AST -> Bool -> z3 AST
mkBvaddNoOverflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Bool -> z3 AST
mkBvaddNoOverflow = (Context -> AST -> AST -> Bool -> IO AST)
-> AST -> AST -> Bool -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Bool -> IO AST
Base.mkBvaddNoOverflow

-- | Create a predicate that checks that the bit-wise signed addition of /t1/
-- and /t2/ does not underflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga1e2b1927cf4e50000c1600d47a152947>
mkBvaddNoUnderflow :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvaddNoUnderflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvaddNoUnderflow = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvaddNoUnderflow

-- | Create a predicate that checks that the bit-wise signed subtraction of /t1/
-- and /t2/ does not overflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga785f8127b87e0b42130e6d8f52167d7c>
mkBvsubNoOverflow :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsubNoOverflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsubNoOverflow = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsubNoOverflow

-- | Create a predicate that checks that the bit-wise subtraction of /t1/ and
-- /t2/ does not underflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga6480850f9fa01e14aea936c88ff184c4>
mkBvsubNoUnderflow :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsubNoUnderflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsubNoUnderflow = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsubNoUnderflow

-- | Create a predicate that checks that the bit-wise signed division of /t1/
-- and /t2/ does not overflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaa17e7b2c33dfe2abbd74d390927ae83e>
mkBvsdivNoOverflow :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsdivNoOverflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvsdivNoOverflow = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvsdivNoOverflow

-- | Check that bit-wise negation does not overflow when /t1/ is interpreted as
-- a signed bit-vector.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gae9c5d72605ddcd0e76657341eaccb6c7>
mkBvnegNoOverflow :: MonadZ3 z3 => AST -> z3 AST
mkBvnegNoOverflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkBvnegNoOverflow = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkBvnegNoOverflow

-- | Create a predicate that checks that the bit-wise multiplication of /t1/ and
-- /t2/ does not overflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga86f4415719d295a2f6845c70b3aaa1df>
mkBvmulNoOverflow :: MonadZ3 z3 => AST -> AST -> Bool -> z3 AST
mkBvmulNoOverflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Bool -> z3 AST
mkBvmulNoOverflow = (Context -> AST -> AST -> Bool -> IO AST)
-> AST -> AST -> Bool -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Bool -> IO AST
Base.mkBvmulNoOverflow

-- | Create a predicate that checks that the bit-wise signed multiplication of
-- /t1/ and /t2/ does not underflow.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga501ccc01d737aad3ede5699741717fda>
mkBvmulNoUnderflow :: MonadZ3 z3 => AST -> AST -> z3 AST
mkBvmulNoUnderflow :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkBvmulNoUnderflow = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkBvmulNoUnderflow

---------------------------------------------------------------------
-- Arrays

-- | Array read. The argument a is the array and i is the index of the array
-- that gets read.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga38f423f3683379e7f597a7fe59eccb67>
mkSelect :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSelect :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSelect = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSelect

-- | Array update.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gae305a4f54b4a64f7e5973ae6ccb13593>
mkStore :: MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkStore :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkStore = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkStore

-- | Create the constant array.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga84ea6f0c32b99c70033feaa8f00e8f2d>
mkConstArray :: MonadZ3 z3 => Sort -> AST -> z3 AST
mkConstArray :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> AST -> z3 AST
mkConstArray = (Context -> Sort -> AST -> IO AST) -> Sort -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> AST -> IO AST
Base.mkConstArray

-- | map f on the the argument arrays.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga9150242d9430a8c3d55d2ca3b9a4362d>
mkMap :: MonadZ3 z3 => FuncDecl -> [AST] -> z3 AST
mkMap :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> [AST] -> z3 AST
mkMap = (Context -> FuncDecl -> [AST] -> IO AST)
-> FuncDecl -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> FuncDecl -> [AST] -> IO AST
Base.mkMap

-- | Access the array default value. Produces the default range value, for
-- arrays that can be represented as finite maps with a default range value.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga78e89cca82f0ab4d5f4e662e5e5fba7d>
mkArrayDefault :: MonadZ3 z3 => AST -> z3 AST
mkArrayDefault :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkArrayDefault = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkArrayDefault

---------------------------------------------------------------------
-- Sets

-- | Create the empty set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga358b6b80509a567148f1c0ca9252118c>
mkEmptySet :: MonadZ3 z3 => Sort -> z3 AST
mkEmptySet :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkEmptySet = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkEmptySet

-- | Create the full set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga5e92662c657374f7332aa32ce4503dd2>
mkFullSet :: MonadZ3 z3 => Sort -> z3 AST
mkFullSet :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkFullSet = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkFullSet

-- | Add an element to a set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga856c3d0e28ce720f53912c2bbdd76175>
mkSetAdd :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSetAdd :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSetAdd = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSetAdd

-- | Remove an element from a set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga80e883f39dd3b88f9d0745c8a5b91d1d>
mkSetDel :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSetDel :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSetDel = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSetDel

-- | Take the union of a list of sets.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4050162a13d539b8913200963bb4743c>
mkSetUnion :: MonadZ3 z3 => [AST] -> z3 AST
mkSetUnion :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkSetUnion = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkSetUnion

-- | Take the intersection of a list of sets.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga8a8abff0ebe6aeeaa6c919eaa013049d>
mkSetIntersect :: MonadZ3 z3 => [AST] -> z3 AST
mkSetIntersect :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkSetIntersect = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkSetIntersect

-- | Take the set difference between two sets.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gabb49c62f70b8198362e1a29ba6d8bde1>
mkSetDifference :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSetDifference :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSetDifference = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSetDifference

-- | Take the complement of a set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga5c57143c9229cdf730c5103ff696590f>
mkSetComplement :: MonadZ3 z3 => AST -> z3 AST
mkSetComplement :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkSetComplement = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkSetComplement

-- | Check for set membership.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac6e516f3dce0bdd41095c6d6daf56063>
mkSetMember :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSetMember :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSetMember = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSetMember

-- | Check if the first set is a subset of the second set.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga139c5803af0e86464adc7cedc53e7f3a>
mkSetSubset :: MonadZ3 z3 => AST -> AST -> z3 AST
mkSetSubset :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSetSubset = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSetSubset

---------------------------------------------------------------------
-- * Numerals

-- | Create a numeral of a given sort.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gac8aca397e32ca33618d8024bff32948c>
mkNumeral :: MonadZ3 z3 => String -> Sort -> z3 AST
mkNumeral :: forall (z3 :: * -> *). MonadZ3 z3 => String -> Sort -> z3 AST
mkNumeral = (Context -> String -> Sort -> IO AST) -> String -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> String -> Sort -> IO AST
Base.mkNumeral

-- | Create a numeral of sort /real/.
mkReal :: MonadZ3 z3 => Int -> Int -> z3 AST
mkReal :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> Int -> z3 AST
mkReal = (Context -> Int -> Int -> IO AST) -> Int -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> Int -> IO AST
Base.mkReal

-- | Create a numeral of an int, bit-vector, or finite-domain sort.
--
-- This function can be use to create numerals that fit in a
-- /machine integer/.
-- It is slightly faster than 'mkNumeral' since it is not necessary
-- to parse a string.
mkInt :: MonadZ3 z3 => Int -> Sort -> z3 AST
mkInt :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> Sort -> z3 AST
mkInt = (Context -> Int -> Sort -> IO AST) -> Int -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> Sort -> IO AST
Base.mkInt

-- | Create a numeral of an int, bit-vector, or finite-domain sort.
--
-- This function can be use to create numerals that fit in a
-- /machine unsigned integer/.
-- It is slightly faster than 'mkNumeral' since it is not necessary
-- to parse a string.
mkUnsignedInt :: MonadZ3 z3 => Word -> Sort -> z3 AST
mkUnsignedInt :: forall (z3 :: * -> *). MonadZ3 z3 => Word -> Sort -> z3 AST
mkUnsignedInt = (Context -> Word -> Sort -> IO AST) -> Word -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Word -> Sort -> IO AST
Base.mkUnsignedInt

-- | Create a numeral of an int, bit-vector, or finite-domain sort.
--
-- This function can be use to create numerals that fit in a
-- /machine 64-bit integer/.
-- It is slightly faster than 'mkNumeral' since it is not necessary
-- to parse a string.
mkInt64 :: MonadZ3 z3 => Int64 -> Sort -> z3 AST
mkInt64 :: forall (z3 :: * -> *). MonadZ3 z3 => Int64 -> Sort -> z3 AST
mkInt64 = (Context -> Int64 -> Sort -> IO AST) -> Int64 -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int64 -> Sort -> IO AST
Base.mkInt64

-- | Create a numeral of an int, bit-vector, or finite-domain sort.
--
-- This function can be use to create numerals that fit in a
-- /machine unsigned 64-bit integer/.
-- It is slightly faster than 'mkNumeral' since it is not necessary
-- to parse a string.
mkUnsignedInt64 :: MonadZ3 z3 => Word64 -> Sort -> z3 AST
mkUnsignedInt64 :: forall (z3 :: * -> *). MonadZ3 z3 => Word64 -> Sort -> z3 AST
mkUnsignedInt64 = (Context -> Word64 -> Sort -> IO AST) -> Word64 -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Word64 -> Sort -> IO AST
Base.mkUnsignedInt64

-------------------------------------------------
-- ** Helpers

-- | Create a numeral of an int, bit-vector, or finite-domain sort.
mkIntegral :: (MonadZ3 z3, Integral a) => a -> Sort -> z3 AST
mkIntegral :: forall (z3 :: * -> *) a.
(MonadZ3 z3, Integral a) =>
a -> Sort -> z3 AST
mkIntegral = (Context -> a -> Sort -> IO AST) -> a -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> a -> Sort -> IO AST
forall a. Integral a => Context -> a -> Sort -> IO AST
Base.mkIntegral

-- | Create a numeral of sort /real/ from a 'Rational'.
mkRational :: MonadZ3 z3 => Rational -> z3 AST
mkRational :: forall (z3 :: * -> *). MonadZ3 z3 => Rational -> z3 AST
mkRational = (Context -> Rational -> IO AST) -> Rational -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Rational -> IO AST
Base.mkRational

-- | Create a numeral of sort /real/ from a 'Fixed'.
mkFixed :: (MonadZ3 z3, HasResolution a) => Fixed a -> z3 AST
mkFixed :: forall (z3 :: * -> *) a.
(MonadZ3 z3, HasResolution a) =>
Fixed a -> z3 AST
mkFixed = (Context -> Fixed a -> IO AST) -> Fixed a -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Fixed a -> IO AST
forall a. HasResolution a => Context -> Fixed a -> IO AST
Base.mkFixed

-- | Create a numeral of sort /real/ from a 'Real'.
mkRealNum :: (MonadZ3 z3, Real r) => r -> z3 AST
mkRealNum :: forall (z3 :: * -> *) r. (MonadZ3 z3, Real r) => r -> z3 AST
mkRealNum = (Context -> r -> IO AST) -> r -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> r -> IO AST
forall r. Real r => Context -> r -> IO AST
Base.mkRealNum

-- | Create a numeral of sort /int/ from an 'Integer'.
mkInteger :: MonadZ3 z3 => Integer -> z3 AST
mkInteger :: forall (z3 :: * -> *). MonadZ3 z3 => Integer -> z3 AST
mkInteger = (Context -> Integer -> IO AST) -> Integer -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Integer -> IO AST
Base.mkInteger

-- | Create a numeral of sort /int/ from an 'Integral'.
mkIntNum :: (MonadZ3 z3, Integral a) => a -> z3 AST
mkIntNum :: forall (z3 :: * -> *) a. (MonadZ3 z3, Integral a) => a -> z3 AST
mkIntNum = (Context -> a -> IO AST) -> a -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> a -> IO AST
forall a. Integral a => Context -> a -> IO AST
Base.mkIntNum

-- | Create a numeral of sort /Bit-vector/ from an 'Integer'.
mkBitvector :: MonadZ3 z3 => Int      -- ^ bit-width
                          -> Integer  -- ^ integer value
                          -> z3 AST
mkBitvector :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> Integer -> z3 AST
mkBitvector = (Context -> Int -> Integer -> IO AST) -> Int -> Integer -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> Integer -> IO AST
Base.mkBitvector

-- | Create a numeral of sort /Bit-vector/ from an 'Integral'.
mkBvNum :: (MonadZ3 z3, Integral i) => Int    -- ^ bit-width
                                    -> i      -- ^ integer value
                                    -> z3 AST
mkBvNum :: forall (z3 :: * -> *) i.
(MonadZ3 z3, Integral i) =>
Int -> i -> z3 AST
mkBvNum = (Context -> Int -> i -> IO AST) -> Int -> i -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> i -> IO AST
forall i. Integral i => Context -> Int -> i -> IO AST
Base.mkBvNum

---------------------------------------------------------------------
-- Sequences and regular expressions

-- | Create a sequence sort out of the sort for the elements.
mkSeqSort :: MonadZ3 z3 => Sort -> z3 Sort
mkSeqSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Sort
mkSeqSort = (Context -> Sort -> IO Sort) -> Sort -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Sort
Base.mkSeqSort

-- | Check if s is a sequence sort.
isSeqSort :: MonadZ3 z3 => Sort -> z3 Bool
isSeqSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Bool
isSeqSort = (Context -> Sort -> IO Bool) -> Sort -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Bool
Base.isSeqSort

-- | Create a regular expression sort out of a sequence sort.
mkReSort :: MonadZ3 z3 => Sort -> z3 Sort
mkReSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Sort
mkReSort = (Context -> Sort -> IO Sort) -> Sort -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Sort
Base.mkReSort

-- | Check if s is a regular expression sort.
isReSort :: MonadZ3 z3 => Sort -> z3 Bool
isReSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Bool
isReSort = (Context -> Sort -> IO Bool) -> Sort -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Bool
Base.isReSort

-- | Create a sort for 8 bit strings. This function creates a sort for ASCII
-- strings. Each character is 8 bits.
mkStringSort :: MonadZ3 z3 => z3 Sort
mkStringSort :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkStringSort = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkStringSort

-- | Check if s is a string sort.
isStringSort :: MonadZ3 z3 => Sort -> z3 Bool
isStringSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Bool
isStringSort = (Context -> Sort -> IO Bool) -> Sort -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Bool
Base.isStringSort

-- | Create a string constant out of the string that is passed in.
mkString :: MonadZ3 z3 => String -> z3 AST
mkString :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 AST
mkString = (Context -> String -> IO AST) -> String -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO AST
Base.mkString

-- | Determine if s is a string constant.
isString :: MonadZ3 z3 => AST -> z3 Bool
isString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
isString = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.isString

-- | Retrieve the string constant stored in s.
getString :: MonadZ3 z3 => AST -> z3 String
getString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 String
getString = (Context -> AST -> IO String) -> AST -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO String
Base.getString

-- | Create an empty sequence of the sequence sort seq.
mkSeqEmpty :: MonadZ3 z3 => Sort -> z3 AST
mkSeqEmpty :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkSeqEmpty = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkSeqEmpty

-- | Create a unit sequence of a.
mkSeqUnit :: MonadZ3 z3 => AST -> z3 AST
mkSeqUnit :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkSeqUnit = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkSeqUnit

-- | Concatenate sequences.
mkSeqConcat :: MonadZ3 z3 => [AST] -> z3 AST
mkSeqConcat :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 AST
mkSeqConcat = (Context -> [AST] -> IO AST) -> [AST] -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO AST
Base.mkSeqConcat

-- | Check if prefix is a prefix of s.
mkSeqPrefix :: MonadZ3 z3
            => AST -- ^ prefix
            -> AST -- ^ s
            -> z3 AST
mkSeqPrefix :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSeqPrefix = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSeqPrefix

-- | Check if suffix is a suffix of s.
mkSeqSuffix :: MonadZ3 z3
            => AST -- ^ suffix
            -> AST -- ^ s
            -> z3 AST
mkSeqSuffix :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSeqSuffix = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSeqSuffix

-- | Check if container contains containee.
mkSeqContains :: MonadZ3 z3
              => AST -- ^ container
              -> AST -- ^ containee
              -> z3 AST
mkSeqContains :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSeqContains = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSeqContains

-- | Check if s1 is equal or lexicographically strictly less than s2.
mkStrLt :: MonadZ3 z3
        => AST -- ^ s1
        -> AST -- ^ s2
        -> z3 AST
mkStrLt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkStrLt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkStrLt

-- | Check if s1 is lexicographically strictly less than s2.
mkStrLe :: MonadZ3 z3
        => AST -- ^ s1
        -> AST -- ^ s2
        -> z3 AST
mkStrLe :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkStrLe = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkStrLe

-- | Extract subsequence starting at offset of length.
mkSeqExtract :: MonadZ3 z3
             => AST -- ^ s
             -> AST -- ^ offset
             -> AST -- ^ length
             -> z3 AST
mkSeqExtract :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkSeqExtract = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkSeqExtract

-- | Replace the first occurrence of src with dst in s.
mkSeqReplace :: MonadZ3 z3
             => AST -- ^ s
             -> AST -- ^ src
             -> AST -- ^ dst
             -> z3 AST
mkSeqReplace :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkSeqReplace = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkSeqReplace

-- | Retrieve from s the unit sequence positioned at position index.
mkSeqAt :: MonadZ3 z3
        => AST -- ^ s
        -> AST -- ^ index
        -> z3 AST
mkSeqAt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSeqAt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSeqAt

-- | Return the length of the sequence s.
mkSeqLength :: MonadZ3 z3 => AST -> z3 AST
mkSeqLength :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkSeqLength = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkSeqLength

-- | Return index of first occurrence of substr in s starting from offset
-- offset. If s does not contain substr, then the value is -1, if offset is the
-- length of s, then the value is -1 as well. The function is under-specified if
-- offset is negative or larger than the length of s.
mkSeqIndex :: MonadZ3 z3
           => AST -- ^ s
           -> AST -- ^ substr
           -> AST -- ^ offset
           -> z3 AST
mkSeqIndex :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkSeqIndex = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkSeqIndex

-- | Convert string to integer.
mkStrToInt :: MonadZ3 z3 => AST -> z3 AST
mkStrToInt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkStrToInt = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkStrToInt

-- | Integer to string conversion.
mkIntToStr :: MonadZ3 z3 => AST -> z3 AST
mkIntToStr :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkIntToStr = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkIntToStr

-- | Create a regular expression that accepts the sequence.
mkSeqToRe :: MonadZ3 z3 => AST -> z3 AST
mkSeqToRe :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkSeqToRe = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkSeqToRe

-- | Check if seq is in the language generated by the regular expression re.
mkSeqInRe :: MonadZ3 z3
          => AST -- ^ seq
          -> AST -- ^ re
          -> z3 AST
mkSeqInRe :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkSeqInRe = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkSeqInRe

-- | Create the regular language re+.
mkRePlus :: MonadZ3 z3 => AST -> z3 AST
mkRePlus :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkRePlus = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkRePlus

-- | Create the regular language re*.
mkReStar :: MonadZ3 z3 => AST -> z3 AST
mkReStar :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkReStar = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkReStar

-- | Create the regular language [re].
mkReOption :: MonadZ3 z3 => AST -> z3 AST
mkReOption :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkReOption = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkReOption

-- | Create the union of the regular languages.
mkReUnion :: (Integral int, MonadZ3 z3) => int -> [AST] -> z3 AST
mkReUnion :: forall int (z3 :: * -> *).
(Integral int, MonadZ3 z3) =>
int -> [AST] -> z3 AST
mkReUnion = (Context -> int -> [AST] -> IO AST) -> int -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> int -> [AST] -> IO AST
forall int. Integral int => Context -> int -> [AST] -> IO AST
Base.mkReUnion

-- | Create the concatenation of the regular languages.
mkReConcat :: (Integral int, MonadZ3 z3) => int -> [AST] -> z3 AST
mkReConcat :: forall int (z3 :: * -> *).
(Integral int, MonadZ3 z3) =>
int -> [AST] -> z3 AST
mkReConcat = (Context -> int -> [AST] -> IO AST) -> int -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> int -> [AST] -> IO AST
forall int. Integral int => Context -> int -> [AST] -> IO AST
Base.mkReConcat

-- | Create the range regular expression over two sequences of length 1.
mkReRange :: MonadZ3 z3
          => AST -- ^ lo
          -> AST -- ^ hi
          -> z3 AST
mkReRange :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkReRange = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkReRange

-- | Create a regular expression loop. The supplied regular expression r is
-- repeated between lo and hi times. The lo should be below hi with one
-- exception: when supplying the value hi as 0, the meaning is to repeat the
-- argument r at least lo number of times, and with an unbounded upper bound.
mkReLoop :: (Integral int, MonadZ3 z3)
         => AST -- ^ r
         -> int -- ^ lo
         -> int -- ^ hi
         -> z3 AST
mkReLoop :: forall int (z3 :: * -> *).
(Integral int, MonadZ3 z3) =>
AST -> int -> int -> z3 AST
mkReLoop = (Context -> AST -> int -> int -> IO AST)
-> AST -> int -> int -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> int -> int -> IO AST
forall int. Integral int => Context -> AST -> int -> int -> IO AST
Base.mkReLoop

-- | Create the intersection of the regular languages.
mkReIntersect :: (Integral int, MonadZ3 z3) => int -> [AST] -> z3 AST
mkReIntersect :: forall int (z3 :: * -> *).
(Integral int, MonadZ3 z3) =>
int -> [AST] -> z3 AST
mkReIntersect = (Context -> int -> [AST] -> IO AST) -> int -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> int -> [AST] -> IO AST
forall int. Integral int => Context -> int -> [AST] -> IO AST
Base.mkReIntersect

-- | Create the complement of the regular language.
mkReComplement :: MonadZ3 z3 => AST -> z3 AST
mkReComplement :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkReComplement = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkReComplement

-- | Create an empty regular expression of sort re.
mkReEmpty :: MonadZ3 z3 => Sort -> z3 AST
mkReEmpty :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkReEmpty = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkReEmpty

-- | Create an universal regular expression of sort re.
mkReFull :: MonadZ3 z3 => Sort -> z3 AST
mkReFull :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkReFull = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkReFull


---------------------------------------------------------------------
-- Quantifiers

mkPattern :: MonadZ3 z3 => [AST] -> z3 Pattern
mkPattern :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 Pattern
mkPattern = (Context -> [AST] -> IO Pattern) -> [AST] -> z3 Pattern
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> [AST] -> IO Pattern
Base.mkPattern

mkBound :: MonadZ3 z3 => Int -> Sort -> z3 AST
mkBound :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> Sort -> z3 AST
mkBound = (Context -> Int -> Sort -> IO AST) -> Int -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Int -> Sort -> IO AST
Base.mkBound

mkForallW :: MonadZ3 z3 => Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkForallW :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkForallW = (Context
 -> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST)
-> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
forall (z3 :: * -> *) a1 a2 a3 a4 a5 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> z3 b
liftFun5 Context -> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST
Base.mkForallW

mkForall :: MonadZ3 z3 => [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkForall :: forall (z3 :: * -> *).
MonadZ3 z3 =>
[Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkForall = (Context -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST)
-> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST
Base.mkForall

mkForallConst :: MonadZ3 z3 => [Pattern] -> [App] -> AST -> z3 AST
mkForallConst :: forall (z3 :: * -> *).
MonadZ3 z3 =>
[Pattern] -> [App] -> AST -> z3 AST
mkForallConst = (Context -> [Pattern] -> [App] -> AST -> IO AST)
-> [Pattern] -> [App] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> [Pattern] -> [App] -> AST -> IO AST
Base.mkForallConst

mkForallWConst :: MonadZ3 z3 => Int -> [Pattern] -> [App] -> AST -> z3 AST
mkForallWConst :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Int -> [Pattern] -> [App] -> AST -> z3 AST
mkForallWConst = (Context -> Int -> [Pattern] -> [App] -> AST -> IO AST)
-> Int -> [Pattern] -> [App] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> Int -> [Pattern] -> [App] -> AST -> IO AST
Base.mkForallWConst

mkExistsConst :: MonadZ3 z3 => [Pattern] -> [App] -> AST -> z3 AST
mkExistsConst :: forall (z3 :: * -> *).
MonadZ3 z3 =>
[Pattern] -> [App] -> AST -> z3 AST
mkExistsConst = (Context -> [Pattern] -> [App] -> AST -> IO AST)
-> [Pattern] -> [App] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> [Pattern] -> [App] -> AST -> IO AST
Base.mkExistsConst

mkExistsWConst :: MonadZ3 z3 => Int -> [Pattern] -> [App] -> AST -> z3 AST
mkExistsWConst :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Int -> [Pattern] -> [App] -> AST -> z3 AST
mkExistsWConst = (Context -> Int -> [Pattern] -> [App] -> AST -> IO AST)
-> Int -> [Pattern] -> [App] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> Int -> [Pattern] -> [App] -> AST -> IO AST
Base.mkExistsWConst

mkExistsW :: MonadZ3 z3 => Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkExistsW :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkExistsW = (Context
 -> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST)
-> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
forall (z3 :: * -> *) a1 a2 a3 a4 a5 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> z3 b
liftFun5 Context -> Int -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST
Base.mkExistsW

mkExists :: MonadZ3 z3 => [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkExists :: forall (z3 :: * -> *).
MonadZ3 z3 =>
[Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
mkExists = (Context -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST)
-> [Pattern] -> [Symbol] -> [Sort] -> AST -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> [Pattern] -> [Symbol] -> [Sort] -> AST -> IO AST
Base.mkExists

---------------------------------------------------------------------
-- Accessors

-- | Return the symbol name.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaf1683d9464f377e5089ce6ebf2a9bd31>
getSymbolString :: MonadZ3 z3 => Symbol -> z3 String
getSymbolString :: forall (z3 :: * -> *). MonadZ3 z3 => Symbol -> z3 String
getSymbolString = (Context -> Symbol -> IO String) -> Symbol -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Symbol -> IO String
Base.getSymbolString

-- Reference: <https://z3prover.github.io/api/html/group__capi.html#gacc77e9b5ce5ada28c5af4ddb67d6702a>
getSortId :: MonadZ3 z3 => Sort -> z3 Int
getSortId :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Int
getSortId = (Context -> Sort -> IO Int) -> Sort -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Int
Base.getSortId

-- | Return the sort name as a symbol.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#gab66884f00730c61cf3a5e6814aa2ebd0>
getSortName :: MonadZ3 z3 => Sort -> z3 Symbol
getSortName :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Symbol
getSortName = (Context -> Sort -> IO Symbol) -> Sort -> z3 Symbol
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Symbol
Base.getSortName

-- | Convert a Z3_sort into Z3_ast. This is just type casting.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#gac68cabaff75abfbf3d99f1f66d2e39a5>
sortToAst :: MonadZ3 z3 => Sort -> z3 AST
sortToAst :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
sortToAst = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.sortToAst

-- | Compare sorts.
--
-- | Reference: <https://z3prover.github.io/api/html/group__capi.html#gaf260f3b5bc786cd0552e1ed4f8232a4b>
isEqSort :: MonadZ3 z3 => Sort -> Sort -> z3 Bool
isEqSort :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> Sort -> z3 Bool
isEqSort = (Context -> Sort -> Sort -> IO Bool) -> Sort -> Sort -> z3 Bool
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> Sort -> IO Bool
Base.isEqSort

-- | Return the sort kind.
--
-- Reference: <http://z3prover.github.io/api/html/group__capi.html#gacd85d48842c7bfaa696596d16875681a>
getSortKind :: MonadZ3 z3 => Sort -> z3 SortKind
getSortKind :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 SortKind
getSortKind = (Context -> Sort -> IO SortKind) -> Sort -> z3 SortKind
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO SortKind
Base.getSortKind

-- | Return the size of the given bit-vector sort.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga8fc3550edace7bc046e16d1f96ddb419>
getBvSortSize :: MonadZ3 z3 => Sort -> z3 Int
getBvSortSize :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Int
getBvSortSize = (Context -> Sort -> IO Int) -> Sort -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Int
Base.getBvSortSize


getTupleSortMkDecl :: MonadZ3 z3 => Sort -> z3 FuncDecl
getTupleSortMkDecl :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 FuncDecl
getTupleSortMkDecl = (Context -> Sort -> IO FuncDecl) -> Sort -> z3 FuncDecl
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO FuncDecl
Base.getTupleSortMkDecl

getTupleSortNumFields :: MonadZ3 z3 => Sort -> z3 Int
getTupleSortNumFields :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Int
getTupleSortNumFields = (Context -> Sort -> IO Int) -> Sort -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Int
Base.getTupleSortNumFields

getTupleSortFieldDecl :: MonadZ3 z3 => Sort -> Int -> z3 FuncDecl
getTupleSortFieldDecl :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> Int -> z3 FuncDecl
getTupleSortFieldDecl = (Context -> Sort -> Int -> IO FuncDecl)
-> Sort -> Int -> z3 FuncDecl
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> Int -> IO FuncDecl
Base.getTupleSortFieldDecl

-- | Get list of constructors for datatype.
getDatatypeSortConstructors :: MonadZ3 z3
                            => Sort           -- ^ Datatype sort.
                            -> z3 [FuncDecl]  -- ^ Constructor declarations.
getDatatypeSortConstructors :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 [FuncDecl]
getDatatypeSortConstructors = (Context -> Sort -> IO [FuncDecl]) -> Sort -> z3 [FuncDecl]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO [FuncDecl]
Base.getDatatypeSortConstructors

-- | Get list of recognizers for datatype.
getDatatypeSortRecognizers :: MonadZ3 z3
                           => Sort           -- ^ Datatype sort.
                           -> z3 [FuncDecl]  -- ^ Constructor recognizers.
getDatatypeSortRecognizers :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 [FuncDecl]
getDatatypeSortRecognizers = (Context -> Sort -> IO [FuncDecl]) -> Sort -> z3 [FuncDecl]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO [FuncDecl]
Base.getDatatypeSortRecognizers

-- | Get list of accessors for datatype.
getDatatypeSortConstructorAccessors :: MonadZ3 z3
                           => Sort           -- ^ Datatype sort.
                           -> z3 [[FuncDecl]]  -- ^ Constructor recognizers.
getDatatypeSortConstructorAccessors :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 [[FuncDecl]]
getDatatypeSortConstructorAccessors = (Context -> Sort -> IO [[FuncDecl]]) -> Sort -> z3 [[FuncDecl]]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO [[FuncDecl]]
Base.getDatatypeSortConstructorAccessors

-- | At most @k@ of the arguments @ps@ may be true, i.e. encode @p1 + p2
-- + ... + pn <= k@.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#gaf2501779266a6dc2738a8928d1fc858c>
mkAtMost :: MonadZ3 z3 => [AST] -> Int -> z3 AST
mkAtMost :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> Int -> z3 AST
mkAtMost = (Context -> [AST] -> Int -> IO AST) -> [AST] -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> [AST] -> Int -> IO AST
Base.mkAtMost

-- | At least @k@ of the arguments @ps@ may be true, i.e. encode @p1 +
-- p2 + ... + pn >= k@.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#gaaa996ab58cf979d5849178f1d2963efb>
mkAtLeast :: MonadZ3 z3 => [AST] -> Int -> z3 AST
mkAtLeast :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> Int -> z3 AST
mkAtLeast = (Context -> [AST] -> Int -> IO AST) -> [AST] -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> [AST] -> Int -> IO AST
Base.mkAtLeast

-- | Return the constant declaration name as a symbol.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga741b1bf11cb92aa2ec9ef2fef73ff129>
getDeclName :: MonadZ3 z3 => FuncDecl -> z3 Symbol
getDeclName :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> z3 Symbol
getDeclName = (Context -> FuncDecl -> IO Symbol) -> FuncDecl -> z3 Symbol
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncDecl -> IO Symbol
Base.getDeclName

-- | Returns the number of parameters of the given declaration
getArity :: MonadZ3 z3 => FuncDecl -> z3 Int
getArity :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> z3 Int
getArity = (Context -> FuncDecl -> IO Int) -> FuncDecl -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncDecl -> IO Int
Base.getArity

-- | Returns the sort of the i-th parameter of the given function declaration
getDomain :: MonadZ3 z3
             => FuncDecl         -- ^ A function declaration
             -> Int              -- ^ i
             -> z3 Sort
getDomain :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> Int -> z3 Sort
getDomain = (Context -> FuncDecl -> Int -> IO Sort)
-> FuncDecl -> Int -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> FuncDecl -> Int -> IO Sort
Base.getDomain

-- | Returns the range of the given declaration.
getRange :: MonadZ3 z3 => FuncDecl -> z3 Sort
getRange :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> z3 Sort
getRange = (Context -> FuncDecl -> IO Sort) -> FuncDecl -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncDecl -> IO Sort
Base.getRange

-- | Convert an app into AST. This is just type casting.
appToAst :: MonadZ3 z3 => App -> z3 AST
appToAst :: forall (z3 :: * -> *). MonadZ3 z3 => App -> z3 AST
appToAst = (Context -> App -> IO AST) -> App -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> App -> IO AST
Base.appToAst

-- | Return the declaration of a constant or function application.
getAppDecl :: MonadZ3 z3 => App -> z3 FuncDecl
getAppDecl :: forall (z3 :: * -> *). MonadZ3 z3 => App -> z3 FuncDecl
getAppDecl = (Context -> App -> IO FuncDecl) -> App -> z3 FuncDecl
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> App -> IO FuncDecl
Base.getAppDecl

-- | Return the number of argument of an application. If t is an constant, then the number of arguments is 0.
getAppNumArgs :: MonadZ3 z3 => App -> z3 Int
getAppNumArgs :: forall (z3 :: * -> *). MonadZ3 z3 => App -> z3 Int
getAppNumArgs = (Context -> App -> IO Int) -> App -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> App -> IO Int
Base.getAppNumArgs

-- | Return the i-th argument of the given application.
getAppArg :: MonadZ3 z3 => App -> Int -> z3 AST
getAppArg :: forall (z3 :: * -> *). MonadZ3 z3 => App -> Int -> z3 AST
getAppArg = (Context -> App -> Int -> IO AST) -> App -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> App -> Int -> IO AST
Base.getAppArg

-- | Return a list of all the arguments of the given application.
getAppArgs :: MonadZ3 z3 => App -> z3 [AST]
getAppArgs :: forall (z3 :: * -> *). MonadZ3 z3 => App -> z3 [AST]
getAppArgs = (Context -> App -> IO [AST]) -> App -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> App -> IO [AST]
Base.getAppArgs

-- | Return the sort of an AST node.
getSort :: MonadZ3 z3 => AST -> z3 Sort
getSort :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Sort
getSort = (Context -> AST -> IO Sort) -> AST -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Sort
Base.getSort

getArraySortDomain :: MonadZ3 z3 => Sort -> z3 Sort
getArraySortDomain :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Sort
getArraySortDomain = (Context -> Sort -> IO Sort) -> Sort -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Sort
Base.getArraySortDomain

getArraySortRange :: MonadZ3 z3 => Sort -> z3 Sort
getArraySortRange :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 Sort
getArraySortRange = (Context -> Sort -> IO Sort) -> Sort -> z3 Sort
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO Sort
Base.getArraySortRange

-- | Returns @Just True@, @Just False@, or @Nothing@ for /undefined/.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga133aaa1ec31af9b570ed7627a3c8c5a4>
getBoolValue :: MonadZ3 z3 => AST -> z3 (Maybe Bool)
getBoolValue :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 (Maybe Bool)
getBoolValue = (Context -> AST -> IO (Maybe Bool)) -> AST -> z3 (Maybe Bool)
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO (Maybe Bool)
Base.getBoolValue

-- | Return the kind of the given AST.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4c43608feea4cae363ef9c520c239a5c>
getAstKind :: MonadZ3 z3 => AST -> z3 ASTKind
getAstKind :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 ASTKind
getAstKind = (Context -> AST -> IO ASTKind) -> AST -> z3 ASTKind
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO ASTKind
Base.getAstKind

-- | Return True if an ast is APP_AST, False otherwise.
isApp :: MonadZ3 z3 => AST -> z3 Bool
isApp :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
isApp = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.isApp

-- | Cast AST into an App.
toApp :: MonadZ3 z3 => AST -> z3 App
toApp :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 App
toApp = (Context -> AST -> IO App) -> AST -> z3 App
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO App
Base.toApp

-- | Return numeral value, as a string of a numeric constant term.
getNumeralString :: MonadZ3 z3 => AST -> z3 String
getNumeralString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 String
getNumeralString = (Context -> AST -> IO String) -> AST -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO String
Base.getNumeralString

-- | Return the numerator (as a numeral AST) of a numeral AST of sort Real.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga2d37084eb47ea0ab19638a3407ce610b>
getNumerator :: MonadZ3 z3 => AST -> z3 AST
getNumerator :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
getNumerator = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.getNumerator

-- | Return the denominator (as a numeral AST) of a numeral AST of sort Real.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga07549939888e8fdfc8e0fde1776c31a7>
getDenominator :: MonadZ3 z3 => AST -> z3 AST
getDenominator :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
getDenominator = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.getDenominator

getIndexValue :: MonadZ3 z3 => AST -> z3 Int
getIndexValue :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Int
getIndexValue = (Context -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Int
Base.getIndexValue

isQuantifierForall :: MonadZ3 z3 => AST -> z3 Bool
isQuantifierForall :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
isQuantifierForall = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.isQuantifierForall

isQuantifierExists :: MonadZ3 z3 => AST -> z3 Bool
isQuantifierExists :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
isQuantifierExists = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.isQuantifierExists

getQuantifierWeight :: MonadZ3 z3 => AST -> z3 Int
getQuantifierWeight :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Int
getQuantifierWeight = (Context -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Int
Base.getQuantifierWeight

getQuantifierNumPatterns :: MonadZ3 z3 => AST -> z3 Int
getQuantifierNumPatterns :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Int
getQuantifierNumPatterns = (Context -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Int
Base.getQuantifierNumPatterns

getQuantifierPatternAST :: MonadZ3 z3 => AST -> Int -> z3 AST
getQuantifierPatternAST :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Int -> z3 AST
getQuantifierPatternAST = (Context -> AST -> Int -> IO AST) -> AST -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Int -> IO AST
Base.getQuantifierPatternAST

getQuantifierPatterns :: MonadZ3 z3 => AST -> z3 [AST]
getQuantifierPatterns :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 [AST]
getQuantifierPatterns = (Context -> AST -> IO [AST]) -> AST -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO [AST]
Base.getQuantifierPatterns

getQuantifierNumNoPatterns :: MonadZ3 z3 => AST -> z3 Int
getQuantifierNumNoPatterns :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Int
getQuantifierNumNoPatterns = (Context -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Int
Base.getQuantifierNumNoPatterns

getQuantifierNoPatternAST :: MonadZ3 z3 => AST -> Int -> z3 AST
getQuantifierNoPatternAST :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Int -> z3 AST
getQuantifierNoPatternAST = (Context -> AST -> Int -> IO AST) -> AST -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Int -> IO AST
Base.getQuantifierNoPatternAST

getQuantifierNoPatterns :: MonadZ3 z3 => AST -> z3 [AST]
getQuantifierNoPatterns :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 [AST]
getQuantifierNoPatterns = (Context -> AST -> IO [AST]) -> AST -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO [AST]
Base.getQuantifierNoPatterns

getQuantifierNumBound :: MonadZ3 z3 => AST -> z3 Int
getQuantifierNumBound :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Int
getQuantifierNumBound = (Context -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Int
Base.getQuantifierNumBound

getQuantifierBoundName :: MonadZ3 z3 => AST -> Int -> z3 Symbol
getQuantifierBoundName :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Int -> z3 Symbol
getQuantifierBoundName = (Context -> AST -> Int -> IO Symbol) -> AST -> Int -> z3 Symbol
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Int -> IO Symbol
Base.getQuantifierBoundName

getQuantifierBoundSort :: MonadZ3 z3 => AST -> Int -> z3 Sort
getQuantifierBoundSort :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Int -> z3 Sort
getQuantifierBoundSort = (Context -> AST -> Int -> IO Sort) -> AST -> Int -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Int -> IO Sort
Base.getQuantifierBoundSort

getQuantifierBoundVars :: MonadZ3 z3 => AST -> z3 [AST]
getQuantifierBoundVars :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 [AST]
getQuantifierBoundVars = (Context -> AST -> IO [AST]) -> AST -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO [AST]
Base.getQuantifierBoundVars

getQuantifierBody :: MonadZ3 z3 => AST -> z3 AST
getQuantifierBody :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
getQuantifierBody = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.getQuantifierBody

-- | Simplify the expression.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gada433553406475e5dd6a494ea957844c>
simplify :: MonadZ3 z3 => AST -> z3 AST
simplify :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
simplify = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.simplify

-- | Simplify the expression using the given parameters.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga34329d4c83ca8c98e18b2884b679008c>
simplifyEx :: MonadZ3 z3 => AST -> Params -> z3 AST
simplifyEx :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Params -> z3 AST
simplifyEx = (Context -> AST -> Params -> IO AST) -> AST -> Params -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Params -> IO AST
Base.simplifyEx

-------------------------------------------------
-- ** Helpers

-- | Read a 'Bool' value from an 'AST'
getBool :: MonadZ3 z3 => AST -> z3 Bool
getBool :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
getBool = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.getBool

-- | Return the integer value
getInt :: MonadZ3 z3 => AST -> z3 Integer
getInt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Integer
getInt = (Context -> AST -> IO Integer) -> AST -> z3 Integer
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Integer
Base.getInt

-- | Return rational value
getReal :: MonadZ3 z3 => AST -> z3 Rational
getReal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Rational
getReal = (Context -> AST -> IO Rational) -> AST -> z3 Rational
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Rational
Base.getReal

---------------------------------------------------------------------
-- Modifiers

substituteVars :: MonadZ3 z3 => AST -> [AST] -> z3 AST
substituteVars :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> [AST] -> z3 AST
substituteVars = (Context -> AST -> [AST] -> IO AST) -> AST -> [AST] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> [AST] -> IO AST
Base.substituteVars

substitute :: MonadZ3 z3 => AST -> [(AST, AST)] -> z3 AST
substitute :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> [(AST, AST)] -> z3 AST
substitute = (Context -> AST -> [(AST, AST)] -> IO AST)
-> AST -> [(AST, AST)] -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> [(AST, AST)] -> IO AST
Base.substitute

---------------------------------------------------------------------
-- Models

-- | Evaluate an AST node in the given model.
--
-- The evaluation may fail for the following reasons:
--
--     * /t/ contains a quantifier.
--     * the model /m/ is partial.
--     * /t/ is type incorrect.
modelEval :: MonadZ3 z3 => Model -> AST
             -> Bool  -- ^ Model completion?
             -> z3 (Maybe AST)
modelEval :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> AST -> Bool -> z3 (Maybe AST)
modelEval = (Context -> Model -> AST -> Bool -> IO (Maybe AST))
-> Model -> AST -> Bool -> z3 (Maybe AST)
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Model -> AST -> Bool -> IO (Maybe AST)
Base.modelEval

-- | Get array as a list of argument/value pairs, if it is
-- represented as a function (ie, using as-array).
evalArray :: MonadZ3 z3 => Model -> AST -> z3 (Maybe FuncModel)
evalArray :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> AST -> z3 (Maybe FuncModel)
evalArray = (Context -> Model -> AST -> IO (Maybe FuncModel))
-> Model -> AST -> z3 (Maybe FuncModel)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> AST -> IO (Maybe FuncModel)
Base.evalArray

getConstInterp :: MonadZ3 z3 => Model -> FuncDecl -> z3 (Maybe AST)
getConstInterp :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> FuncDecl -> z3 (Maybe AST)
getConstInterp = (Context -> Model -> FuncDecl -> IO (Maybe AST))
-> Model -> FuncDecl -> z3 (Maybe AST)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> FuncDecl -> IO (Maybe AST)
Base.getConstInterp

-- | Return the interpretation of the function f in the model m.
-- Return NULL, if the model does not assign an interpretation for f.
-- That should be interpreted as: the f does not matter.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gafb9cc5eca9564d8a849c154c5a4a8633>
getFuncInterp :: MonadZ3 z3 => Model -> FuncDecl -> z3 (Maybe FuncInterp)
getFuncInterp :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> FuncDecl -> z3 (Maybe FuncInterp)
getFuncInterp = (Context -> Model -> FuncDecl -> IO (Maybe FuncInterp))
-> Model -> FuncDecl -> z3 (Maybe FuncInterp)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> FuncDecl -> IO (Maybe FuncInterp)
Base.getFuncInterp

modelTranslate :: MonadZ3 z3 => Model -> Base.Context -> z3 Model 
modelTranslate :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> Context -> z3 Model
modelTranslate = (Context -> Model -> Context -> IO Model)
-> Model -> Context -> z3 Model
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> Context -> IO Model
Base.modelTranslate 

hasInterp :: MonadZ3 z3 => Model -> FuncDecl -> z3 Bool
hasInterp :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> FuncDecl -> z3 Bool
hasInterp = (Context -> Model -> FuncDecl -> IO Bool)
-> Model -> FuncDecl -> z3 Bool
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> FuncDecl -> IO Bool
Base.hasInterp

numConsts :: MonadZ3 z3 => Model -> z3 Word
numConsts :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 Word
numConsts = (Context -> Model -> IO Word) -> Model -> z3 Word
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Model -> IO Word
Base.numConsts

numFuncs :: MonadZ3 z3 => Model -> z3 Word
numFuncs :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 Word
numFuncs = (Context -> Model -> IO Word) -> Model -> z3 Word
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Model -> IO Word
Base.numFuncs

getConstDecl :: MonadZ3 z3 => Model -> Word -> z3 FuncDecl
getConstDecl :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> Word -> z3 FuncDecl
getConstDecl = (Context -> Model -> Word -> IO FuncDecl)
-> Model -> Word -> z3 FuncDecl
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> Word -> IO FuncDecl
Base.getConstDecl

getFuncDecl :: MonadZ3 z3 => Model -> Word -> z3 FuncDecl
getFuncDecl :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> Word -> z3 FuncDecl
getFuncDecl = (Context -> Model -> Word -> IO FuncDecl)
-> Model -> Word -> z3 FuncDecl
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> Word -> IO FuncDecl
Base.getFuncDecl

getConsts :: MonadZ3 z3 => Model -> z3 [FuncDecl]
getConsts :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 [FuncDecl]
getConsts = (Context -> Model -> IO [FuncDecl]) -> Model -> z3 [FuncDecl]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Model -> IO [FuncDecl]
Base.getConsts

getFuncs :: MonadZ3 z3 => Model -> z3 [FuncDecl]
getFuncs :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 [FuncDecl]
getFuncs = (Context -> Model -> IO [FuncDecl]) -> Model -> z3 [FuncDecl]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Model -> IO [FuncDecl]
Base.getFuncs

-- | The (_ as-array f) AST node is a construct for assigning interpretations
-- for arrays in Z3. It is the array such that forall indices i we have that
-- (select (_ as-array f) i) is equal to (f i). This procedure returns Z3_TRUE
-- if the a is an as-array AST node.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga4674da67d226bfb16861829b9f129cfa>
isAsArray :: MonadZ3 z3 => AST -> z3 Bool
isAsArray :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
isAsArray = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.isAsArray

isEqAST :: MonadZ3 z3 => AST -> AST -> z3 Bool
isEqAST :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 Bool
isEqAST = (Context -> AST -> AST -> IO Bool) -> AST -> AST -> z3 Bool
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO Bool
Base.isEqAST

addFuncInterp :: MonadZ3 z3 => Model -> FuncDecl -> AST -> z3 FuncInterp
addFuncInterp :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> FuncDecl -> AST -> z3 FuncInterp
addFuncInterp = (Context -> Model -> FuncDecl -> AST -> IO FuncInterp)
-> Model -> FuncDecl -> AST -> z3 FuncInterp
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Model -> FuncDecl -> AST -> IO FuncInterp
Base.addFuncInterp

addConstInterp :: MonadZ3 z3 => Model -> FuncDecl -> AST -> z3 ()
addConstInterp :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> FuncDecl -> AST -> z3 ()
addConstInterp = (Context -> Model -> FuncDecl -> AST -> IO ())
-> Model -> FuncDecl -> AST -> z3 ()
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Model -> FuncDecl -> AST -> IO ()
Base.addConstInterp


-- | Return the function declaration f associated with a (_ as_array f) node.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga7d9262dc6e79f2aeb23fd4a383589dda>
getAsArrayFuncDecl :: MonadZ3 z3 => AST -> z3 FuncDecl
getAsArrayFuncDecl :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 FuncDecl
getAsArrayFuncDecl = (Context -> AST -> IO FuncDecl) -> AST -> z3 FuncDecl
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO FuncDecl
Base.getAsArrayFuncDecl

-- | Return the number of entries in the given function interpretation.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga2bab9ae1444940e7593729beec279844>
funcInterpGetNumEntries :: MonadZ3 z3 => FuncInterp -> z3 Int
funcInterpGetNumEntries :: forall (z3 :: * -> *). MonadZ3 z3 => FuncInterp -> z3 Int
funcInterpGetNumEntries = (Context -> FuncInterp -> IO Int) -> FuncInterp -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncInterp -> IO Int
Base.funcInterpGetNumEntries

-- | Return a "point" of the given function intepretation.
-- It represents the value of f in a particular point.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaf157e1e1cd8c0cfe6a21be6370f659da>
funcInterpGetEntry :: MonadZ3 z3 => FuncInterp -> Int -> z3 FuncEntry
funcInterpGetEntry :: forall (z3 :: * -> *).
MonadZ3 z3 =>
FuncInterp -> Int -> z3 FuncEntry
funcInterpGetEntry = (Context -> FuncInterp -> Int -> IO FuncEntry)
-> FuncInterp -> Int -> z3 FuncEntry
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> FuncInterp -> Int -> IO FuncEntry
Base.funcInterpGetEntry

-- | Return the 'else' value of the given function interpretation.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga46de7559826ba71b8488d727cba1fb64>
funcInterpGetElse :: MonadZ3 z3 => FuncInterp -> z3 AST
funcInterpGetElse :: forall (z3 :: * -> *). MonadZ3 z3 => FuncInterp -> z3 AST
funcInterpGetElse = (Context -> FuncInterp -> IO AST) -> FuncInterp -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncInterp -> IO AST
Base.funcInterpGetElse

-- | Return the arity (number of arguments) of the given function
-- interpretation.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#gaca22cbdb6f7787aaae5d814f2ab383d8>
funcInterpGetArity :: MonadZ3 z3 => FuncInterp -> z3 Int
funcInterpGetArity :: forall (z3 :: * -> *). MonadZ3 z3 => FuncInterp -> z3 Int
funcInterpGetArity = (Context -> FuncInterp -> IO Int) -> FuncInterp -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncInterp -> IO Int
Base.funcInterpGetArity

-- | Return the value of this point.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga9fd65e2ab039aa8e40608c2ecf7084da>
funcEntryGetValue :: MonadZ3 z3 => FuncEntry -> z3 AST
funcEntryGetValue :: forall (z3 :: * -> *). MonadZ3 z3 => FuncEntry -> z3 AST
funcEntryGetValue = (Context -> FuncEntry -> IO AST) -> FuncEntry -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncEntry -> IO AST
Base.funcEntryGetValue

-- | Return the number of arguments in a Z3_func_entry object.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga51aed8c5bc4b1f53f0c371312de3ce1a>
funcEntryGetNumArgs :: MonadZ3 z3 => FuncEntry -> z3 Int
funcEntryGetNumArgs :: forall (z3 :: * -> *). MonadZ3 z3 => FuncEntry -> z3 Int
funcEntryGetNumArgs = (Context -> FuncEntry -> IO Int) -> FuncEntry -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncEntry -> IO Int
Base.funcEntryGetNumArgs

-- | Return an argument of a Z3_func_entry object.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga6fe03fe3c824fceb52766a4d8c2cbeab>
funcEntryGetArg :: MonadZ3 z3 => FuncEntry -> Int -> z3 AST
funcEntryGetArg :: forall (z3 :: * -> *). MonadZ3 z3 => FuncEntry -> Int -> z3 AST
funcEntryGetArg = (Context -> FuncEntry -> Int -> IO AST)
-> FuncEntry -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> FuncEntry -> Int -> IO AST
Base.funcEntryGetArg

-- | Convert the given model into a string.
modelToString :: MonadZ3 z3 => Model -> z3 String
modelToString :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 String
modelToString = (Context -> Model -> IO String) -> Model -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Model -> IO String
Base.modelToString

-- | Alias for 'modelToString'.
showModel :: MonadZ3 z3 => Model -> z3 String
showModel :: forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 String
showModel = Model -> z3 String
forall (z3 :: * -> *). MonadZ3 z3 => Model -> z3 String
modelToString

-------------------------------------------------
-- ** Helpers

-- | Type of an evaluation function for 'AST'.
--
-- Evaluation may fail (i.e. return 'Nothing') for a few
-- reasons, see 'modelEval'.
type EvalAst m a = Model -> AST -> m (Maybe a)

-- | An alias for 'modelEval' with model completion enabled.
eval :: MonadZ3 z3 => EvalAst z3 AST
eval :: forall (z3 :: * -> *). MonadZ3 z3 => EvalAst z3 AST
eval = (Context -> Model -> AST -> IO (Maybe AST))
-> Model -> AST -> z3 (Maybe AST)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> AST -> IO (Maybe AST)
Base.eval

-- | Evaluate an AST node of sort /bool/ in the given model.
--
-- See 'modelEval' and 'getBool'.
evalBool :: MonadZ3 z3 => EvalAst z3 Bool
evalBool :: forall (z3 :: * -> *). MonadZ3 z3 => EvalAst z3 Bool
evalBool = (Context -> Model -> AST -> IO (Maybe Bool))
-> Model -> AST -> z3 (Maybe Bool)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> AST -> IO (Maybe Bool)
Base.evalBool

-- | Evaluate an AST node of sort /int/ in the given model.
--
-- See 'modelEval' and 'getInt'.
evalInt :: MonadZ3 z3 => EvalAst z3 Integer
evalInt :: forall (z3 :: * -> *). MonadZ3 z3 => EvalAst z3 Integer
evalInt = (Context -> Model -> AST -> IO (Maybe Integer))
-> Model -> AST -> z3 (Maybe Integer)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> AST -> IO (Maybe Integer)
Base.evalInt

-- | Evaluate an AST node of sort /real/ in the given model.
--
-- See 'modelEval' and 'getReal'.
evalReal :: MonadZ3 z3 => EvalAst z3 Rational
evalReal :: forall (z3 :: * -> *). MonadZ3 z3 => EvalAst z3 Rational
evalReal = (Context -> Model -> AST -> IO (Maybe Rational))
-> Model -> AST -> z3 (Maybe Rational)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> AST -> IO (Maybe Rational)
Base.evalReal

-- | Evaluate an AST node of sort /bit-vector/ in the given model.
--
-- The flag /signed/ decides whether the bit-vector value is
-- interpreted as a signed or unsigned integer.
--
-- See 'modelEval' and 'mkBv2int'.
evalBv :: MonadZ3 z3 => Bool -- ^ signed?
                     -> EvalAst z3 Integer
evalBv :: forall (z3 :: * -> *). MonadZ3 z3 => Bool -> EvalAst z3 Integer
evalBv = (Context -> Bool -> Model -> AST -> IO (Maybe Integer))
-> Bool -> Model -> AST -> z3 (Maybe Integer)
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Bool -> Model -> AST -> IO (Maybe Integer)
Base.evalBv

-- | Evaluate a collection of AST nodes in the given model.
evalT :: (MonadZ3 z3,Traversable t) => Model -> t AST -> z3 (Maybe (t AST))
evalT :: forall (z3 :: * -> *) (t :: * -> *).
(MonadZ3 z3, Traversable t) =>
Model -> t AST -> z3 (Maybe (t AST))
evalT = (Context -> Model -> t AST -> IO (Maybe (t AST)))
-> Model -> t AST -> z3 (Maybe (t AST))
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> t AST -> IO (Maybe (t AST))
forall (t :: * -> *).
Traversable t =>
Context -> Model -> t AST -> IO (Maybe (t AST))
Base.evalT

-- | Run a evaluation function on a 'Traversable' data structure of 'AST's
-- (e.g. @[AST]@, @Vector AST@, @Maybe AST@, etc).
--
-- This a generic version of 'evalT' which can be used in combination with
-- other helpers. For instance, @mapEval evalInt@ can be used to obtain
-- the 'Integer' interpretation of a list of 'AST' of sort /int/.
mapEval :: (MonadZ3 z3, Traversable t) => EvalAst z3 a
                                       -> Model
                                       -> t AST
                                       -> z3 (Maybe (t a))
mapEval :: forall (z3 :: * -> *) (t :: * -> *) a.
(MonadZ3 z3, Traversable t) =>
EvalAst z3 a -> Model -> t AST -> z3 (Maybe (t a))
mapEval EvalAst z3 a
f Model
m = (t (Maybe a) -> Maybe (t a))
-> z3 (t (Maybe a)) -> z3 (Maybe (t a))
forall a b. (a -> b) -> z3 a -> z3 b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap t (Maybe a) -> Maybe (t a)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)
T.sequence (z3 (t (Maybe a)) -> z3 (Maybe (t a)))
-> (t AST -> z3 (t (Maybe a))) -> t AST -> z3 (Maybe (t a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AST -> z3 (Maybe a)) -> t AST -> z3 (t (Maybe a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)
T.mapM (EvalAst z3 a
f Model
m)

-- | Get function as a list of argument/value pairs.
evalFunc :: MonadZ3 z3 => Model -> FuncDecl -> z3 (Maybe FuncModel)
evalFunc :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Model -> FuncDecl -> z3 (Maybe FuncModel)
evalFunc = (Context -> Model -> FuncDecl -> IO (Maybe FuncModel))
-> Model -> FuncDecl -> z3 (Maybe FuncModel)
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Model -> FuncDecl -> IO (Maybe FuncModel)
Base.evalFunc

---------------------------------------------------------------------
-- Tactics

mkTactic :: MonadZ3 z3 => String -> z3 Tactic
mkTactic :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 Tactic
mkTactic = (Context -> String -> IO Tactic) -> String -> z3 Tactic
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO Tactic
Base.mkTactic

andThenTactic :: MonadZ3 z3 => Tactic -> Tactic -> z3 Tactic
andThenTactic :: forall (z3 :: * -> *). MonadZ3 z3 => Tactic -> Tactic -> z3 Tactic
andThenTactic = (Context -> Tactic -> Tactic -> IO Tactic)
-> Tactic -> Tactic -> z3 Tactic
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Tactic -> IO Tactic
Base.andThenTactic

orElseTactic :: MonadZ3 z3 => Tactic -> Tactic -> z3 Tactic
orElseTactic :: forall (z3 :: * -> *). MonadZ3 z3 => Tactic -> Tactic -> z3 Tactic
orElseTactic = (Context -> Tactic -> Tactic -> IO Tactic)
-> Tactic -> Tactic -> z3 Tactic
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Tactic -> IO Tactic
Base.orElseTactic

skipTactic :: MonadZ3 z3 => z3 Tactic
skipTactic :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Tactic
skipTactic = (Context -> IO Tactic) -> z3 Tactic
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Tactic
Base.skipTactic

tryForTactic :: MonadZ3 z3 => Tactic -> Int -> z3 Tactic
tryForTactic :: forall (z3 :: * -> *). MonadZ3 z3 => Tactic -> Int -> z3 Tactic
tryForTactic = (Context -> Tactic -> Int -> IO Tactic)
-> Tactic -> Int -> z3 Tactic
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Int -> IO Tactic
Base.tryForTactic

tacticUsingParams :: MonadZ3 z3 => Tactic -> Params -> z3 Tactic
tacticUsingParams :: forall (z3 :: * -> *). MonadZ3 z3 => Tactic -> Params -> z3 Tactic
tacticUsingParams = (Context -> Tactic -> Params -> IO Tactic)
-> Tactic -> Params -> z3 Tactic
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Params -> IO Tactic
Base.tacticUsingParams

repeatTactic :: MonadZ3 z3 => Tactic -> Int -> z3 Tactic
repeatTactic :: forall (z3 :: * -> *). MonadZ3 z3 => Tactic -> Int -> z3 Tactic
repeatTactic = (Context -> Tactic -> Int -> IO Tactic)
-> Tactic -> Int -> z3 Tactic
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Int -> IO Tactic
Base.repeatTactic

mkQuantifierEliminationTactic :: MonadZ3 z3 => z3 Tactic
mkQuantifierEliminationTactic :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Tactic
mkQuantifierEliminationTactic = (Context -> IO Tactic) -> z3 Tactic
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Tactic
Base.mkQuantifierEliminationTactic

mkAndInverterGraphTactic :: MonadZ3 z3 => z3 Tactic
mkAndInverterGraphTactic :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Tactic
mkAndInverterGraphTactic = (Context -> IO Tactic) -> z3 Tactic
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Tactic
Base.mkAndInverterGraphTactic

applyTactic :: MonadZ3 z3 => Tactic -> Goal -> z3 ApplyResult
applyTactic :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Tactic -> Goal -> z3 ApplyResult
applyTactic = (Context -> Tactic -> Goal -> IO ApplyResult)
-> Tactic -> Goal -> z3 ApplyResult
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Tactic -> Goal -> IO ApplyResult
Base.applyTactic

applyResultToString :: MonadZ3 z3 => ApplyResult -> z3 String
applyResultToString :: forall (z3 :: * -> *). MonadZ3 z3 => ApplyResult -> z3 String
applyResultToString = (Context -> ApplyResult -> IO String) -> ApplyResult -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> ApplyResult -> IO String
Base.applyResultToString

getApplyResultNumSubgoals :: MonadZ3 z3 => ApplyResult -> z3 Int
getApplyResultNumSubgoals :: forall (z3 :: * -> *). MonadZ3 z3 => ApplyResult -> z3 Int
getApplyResultNumSubgoals = (Context -> ApplyResult -> IO Int) -> ApplyResult -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> ApplyResult -> IO Int
Base.getApplyResultNumSubgoals

getApplyResultSubgoal :: MonadZ3 z3 => ApplyResult -> Int -> z3 Goal
getApplyResultSubgoal :: forall (z3 :: * -> *). MonadZ3 z3 => ApplyResult -> Int -> z3 Goal
getApplyResultSubgoal = (Context -> ApplyResult -> Int -> IO Goal)
-> ApplyResult -> Int -> z3 Goal
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> ApplyResult -> Int -> IO Goal
Base.getApplyResultSubgoal

getApplyResultSubgoals :: MonadZ3 z3 => ApplyResult -> z3 [Goal]
getApplyResultSubgoals :: forall (z3 :: * -> *). MonadZ3 z3 => ApplyResult -> z3 [Goal]
getApplyResultSubgoals = (Context -> ApplyResult -> IO [Goal]) -> ApplyResult -> z3 [Goal]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> ApplyResult -> IO [Goal]
Base.getApplyResultSubgoals

mkGoal :: MonadZ3 z3 => Bool -> Bool -> Bool -> z3 Goal
mkGoal :: forall (z3 :: * -> *).
MonadZ3 z3 =>
Bool -> Bool -> Bool -> z3 Goal
mkGoal = (Context -> Bool -> Bool -> Bool -> IO Goal)
-> Bool -> Bool -> Bool -> z3 Goal
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> Bool -> Bool -> Bool -> IO Goal
Base.mkGoal

goalAssert :: MonadZ3 z3 => Goal -> AST -> z3 ()
goalAssert :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> AST -> z3 ()
goalAssert = (Context -> Goal -> AST -> IO ()) -> Goal -> AST -> z3 ()
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Goal -> AST -> IO ()
Base.goalAssert

getGoalSize :: MonadZ3 z3 => Goal -> z3 Int
getGoalSize :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> z3 Int
getGoalSize = (Context -> Goal -> IO Int) -> Goal -> z3 Int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Goal -> IO Int
Base.getGoalSize

getGoalFormula :: MonadZ3 z3 => Goal -> Int -> z3 AST
getGoalFormula :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> Int -> z3 AST
getGoalFormula = (Context -> Goal -> Int -> IO AST) -> Goal -> Int -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Goal -> Int -> IO AST
Base.getGoalFormula

getGoalFormulas :: MonadZ3 z3 => Goal -> z3 [AST]
getGoalFormulas :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> z3 [AST]
getGoalFormulas = (Context -> Goal -> IO [AST]) -> Goal -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Goal -> IO [AST]
Base.getGoalFormulas

goalToString :: MonadZ3 z3 => Goal -> z3 String
goalToString :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> z3 String
goalToString = (Context -> Goal -> IO String) -> Goal -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Goal -> IO String
Base.goalToString

convertModel :: MonadZ3 z3 => Goal -> Model -> z3 Model
convertModel :: forall (z3 :: * -> *). MonadZ3 z3 => Goal -> Model -> z3 Model
convertModel = (Context -> Goal -> Model -> IO Model) -> Goal -> Model -> z3 Model
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Goal -> Model -> IO Model
Base.convertModel 

---------------------------------------------------------------------
-- String Conversion

-- | Set the mode for converting expressions to strings.
setASTPrintMode :: MonadZ3 z3 => ASTPrintMode -> z3 ()
setASTPrintMode :: forall (z3 :: * -> *). MonadZ3 z3 => ASTPrintMode -> z3 ()
setASTPrintMode = (Context -> ASTPrintMode -> IO ()) -> ASTPrintMode -> z3 ()
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> ASTPrintMode -> IO ()
Base.setASTPrintMode

-- | Convert an AST to a string.
astToString :: MonadZ3 z3 => AST -> z3 String
astToString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 String
astToString = (Context -> AST -> IO String) -> AST -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO String
Base.astToString

-- | Convert a pattern to a string.
patternToString :: MonadZ3 z3 => Pattern -> z3 String
patternToString :: forall (z3 :: * -> *). MonadZ3 z3 => Pattern -> z3 String
patternToString = (Context -> Pattern -> IO String) -> Pattern -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Pattern -> IO String
Base.patternToString

-- | Convert a sort to a string.
sortToString :: MonadZ3 z3 => Sort -> z3 String
sortToString :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 String
sortToString = (Context -> Sort -> IO String) -> Sort -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO String
Base.sortToString

-- | Convert a FuncDecl to a string.
funcDeclToString :: MonadZ3 z3 => FuncDecl -> z3 String
funcDeclToString :: forall (z3 :: * -> *). MonadZ3 z3 => FuncDecl -> z3 String
funcDeclToString = (Context -> FuncDecl -> IO String) -> FuncDecl -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> FuncDecl -> IO String
Base.funcDeclToString

-- | Convert the given benchmark into SMT-LIB formatted string.
--
-- The output format can be configured via 'setASTPrintMode'.
benchmarkToSMTLibString :: MonadZ3 z3 =>
                               String   -- ^ name
                            -> String   -- ^ logic
                            -> String   -- ^ status
                            -> String   -- ^ attributes
                            -> [AST]    -- ^ assumptions1
                            -> AST      -- ^ formula
                            -> z3 String
benchmarkToSMTLibString :: forall (z3 :: * -> *).
MonadZ3 z3 =>
String -> String -> String -> String -> [AST] -> AST -> z3 String
benchmarkToSMTLibString = (Context
 -> String
 -> String
 -> String
 -> String
 -> [AST]
 -> AST
 -> IO String)
-> String
-> String
-> String
-> String
-> [AST]
-> AST
-> z3 String
forall (z3 :: * -> *) a1 a2 a3 a4 a5 a6 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> z3 b
liftFun6 Context
-> String
-> String
-> String
-> String
-> [AST]
-> AST
-> IO String
Base.benchmarkToSMTLibString


---------------------------------------------------------------------
-- Parser interface

-- | Parse SMT expressions from a string
--
-- The sort and declaration arguments allow parsing in a context in which variables and functions have already been declared. They are almost never used.
parseSMTLib2String :: MonadZ3 z3 =>
                      String     -- ^ string to parse
                   -> [Symbol]   -- ^ sort names
                   -> [Sort]     -- ^ sorts
                   -> [Symbol]   -- ^ declaration names
                   -> [FuncDecl] -- ^ declarations
                   -> z3 [AST]
parseSMTLib2String :: forall (z3 :: * -> *).
MonadZ3 z3 =>
String -> [Symbol] -> [Sort] -> [Symbol] -> [FuncDecl] -> z3 [AST]
parseSMTLib2String = (Context
 -> String
 -> [Symbol]
 -> [Sort]
 -> [Symbol]
 -> [FuncDecl]
 -> IO [AST])
-> String
-> [Symbol]
-> [Sort]
-> [Symbol]
-> [FuncDecl]
-> z3 [AST]
forall (z3 :: * -> *) a1 a2 a3 a4 a5 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> z3 b
liftFun5 Context
-> String
-> [Symbol]
-> [Sort]
-> [Symbol]
-> [FuncDecl]
-> IO [AST]
Base.parseSMTLib2String

-- | Parse SMT expressions from a file
--
-- The sort and declaration arguments allow parsing in a context in which variables and functions have already been declared. They are almost never used.
parseSMTLib2File :: MonadZ3 z3 =>
                    String     -- ^ string to parse
                 -> [Symbol]   -- ^ sort names
                 -> [Sort]     -- ^ sorts
                 -> [Symbol]   -- ^ declaration names
                 -> [FuncDecl] -- ^ declarations
                 -> z3 [AST]
parseSMTLib2File :: forall (z3 :: * -> *).
MonadZ3 z3 =>
String -> [Symbol] -> [Sort] -> [Symbol] -> [FuncDecl] -> z3 [AST]
parseSMTLib2File = (Context
 -> String
 -> [Symbol]
 -> [Sort]
 -> [Symbol]
 -> [FuncDecl]
 -> IO [AST])
-> String
-> [Symbol]
-> [Sort]
-> [Symbol]
-> [FuncDecl]
-> z3 [AST]
forall (z3 :: * -> *) a1 a2 a3 a4 a5 b.
MonadZ3 z3 =>
(Context -> a1 -> a2 -> a3 -> a4 -> a5 -> IO b)
-> a1 -> a2 -> a3 -> a4 -> a5 -> z3 b
liftFun5 Context
-> String
-> [Symbol]
-> [Sort]
-> [Symbol]
-> [FuncDecl]
-> IO [AST]
Base.parseSMTLib2File

evalSMTLib2String :: MonadZ3 z3 =>
                     String     -- ^ string to parse
                  -> z3 String
evalSMTLib2String :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 String
evalSMTLib2String = (Context -> String -> IO String) -> String -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> String -> IO String
Base.evalSMTLib2String

---------------------------------------------------------------------
-- Miscellaneous

-- | Return Z3 version number information.
getVersion :: MonadZ3 z3 => z3 Version
getVersion :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Version
getVersion = IO Version -> z3 Version
forall a. IO a -> z3 a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Version
Base.getVersion

---------------------------------------------------------------------
-- Fixedpoint

class MonadZ3 m => MonadFixedpoint m where
  getFixedpoint :: m Base.Fixedpoint

fixedpointAddRule :: MonadFixedpoint z3 => AST -> Symbol -> z3 ()
fixedpointAddRule :: forall (z3 :: * -> *). MonadFixedpoint z3 => AST -> Symbol -> z3 ()
fixedpointAddRule = (Context -> Fixedpoint -> AST -> Symbol -> IO ())
-> AST -> Symbol -> z3 ()
forall (z3 :: * -> *) a b c.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> b -> IO c) -> a -> b -> z3 c
liftFixedpoint2 Context -> Fixedpoint -> AST -> Symbol -> IO ()
Base.fixedpointAddRule

fixedpointSetParams :: MonadFixedpoint z3 => Params -> z3 ()
fixedpointSetParams :: forall (z3 :: * -> *). MonadFixedpoint z3 => Params -> z3 ()
fixedpointSetParams = (Context -> Fixedpoint -> Params -> IO ()) -> Params -> z3 ()
forall (z3 :: * -> *) a b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> IO b) -> a -> z3 b
liftFixedpoint1 Context -> Fixedpoint -> Params -> IO ()
Base.fixedpointSetParams

fixedpointRegisterRelation :: MonadFixedpoint z3 => FuncDecl -> z3 ()
fixedpointRegisterRelation :: forall (z3 :: * -> *). MonadFixedpoint z3 => FuncDecl -> z3 ()
fixedpointRegisterRelation = (Context -> Fixedpoint -> FuncDecl -> IO ()) -> FuncDecl -> z3 ()
forall (z3 :: * -> *) a b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> IO b) -> a -> z3 b
liftFixedpoint1 Context -> Fixedpoint -> FuncDecl -> IO ()
Base.fixedpointRegisterRelation

fixedpointQueryRelations :: MonadFixedpoint z3 => [FuncDecl] -> z3 Result
fixedpointQueryRelations :: forall (z3 :: * -> *).
MonadFixedpoint z3 =>
[FuncDecl] -> z3 Result
fixedpointQueryRelations = (Context -> Fixedpoint -> [FuncDecl] -> IO Result)
-> [FuncDecl] -> z3 Result
forall (z3 :: * -> *) a b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> a -> IO b) -> a -> z3 b
liftFixedpoint1 Context -> Fixedpoint -> [FuncDecl] -> IO Result
Base.fixedpointQueryRelations

fixedpointGetAnswer :: MonadFixedpoint z3 => z3 AST
fixedpointGetAnswer :: forall (z3 :: * -> *). MonadFixedpoint z3 => z3 AST
fixedpointGetAnswer = (Context -> Fixedpoint -> IO AST) -> z3 AST
forall (z3 :: * -> *) b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> IO b) -> z3 b
liftFixedpoint0 Context -> Fixedpoint -> IO AST
Base.fixedpointGetAnswer

fixedpointGetAssertions :: MonadFixedpoint z3 => z3 [AST]
fixedpointGetAssertions :: forall (z3 :: * -> *). MonadFixedpoint z3 => z3 [AST]
fixedpointGetAssertions = (Context -> Fixedpoint -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadFixedpoint z3 =>
(Context -> Fixedpoint -> IO b) -> z3 b
liftFixedpoint0 Context -> Fixedpoint -> IO [AST]
Base.fixedpointGetAssertions

---------------------------------------------------------------------
-- Floating-Point Arithmetic

-- | Create the RoundingMode sort.
mkFpaRoundingModeSort :: MonadZ3 z3 => z3 Sort
mkFpaRoundingModeSort :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaRoundingModeSort = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaRoundingModeSort

-- | Create a numeral of RoundingMode sort which represents the
-- NearestTiesToEven rounding mode.
mkFpaRoundNearestTiesToEven :: MonadZ3 z3 => z3 AST
mkFpaRoundNearestTiesToEven :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRoundNearestTiesToEven = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRoundNearestTiesToEven

-- | Create a numeral of RoundingMode sort which represents the
-- NearestTiesToEven rounding mode.
mkFpaRne :: MonadZ3 z3 => z3 AST
mkFpaRne :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRne = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRne

-- | Create a numeral of RoundingMode sort which represents the
-- NearestTiesToAway rounding mode.
mkFpaRoundNearestTiesToAway :: MonadZ3 z3 => z3 AST
mkFpaRoundNearestTiesToAway :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRoundNearestTiesToAway = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRoundNearestTiesToAway

-- | Create a numeral of RoundingMode sort which represents the
-- NearestTiesToAway rounding mode.
mkFpaRna :: MonadZ3 z3 => z3 AST
mkFpaRna :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRna = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRna

-- | Create a numeral of RoundingMode sort which represents the
-- TowardPositive rounding mode.
mkFpaRoundTowardPositive :: MonadZ3 z3 => z3 AST
mkFpaRoundTowardPositive :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRoundTowardPositive = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRoundTowardPositive

-- | Create a numeral of RoundingMode sort which represents the
-- TowardPositive rounding mode.
mkFpaRtp :: MonadZ3 z3 => z3 AST
mkFpaRtp :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRtp = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRtp

-- | Create a numeral of RoundingMode sort which represents the
-- TowardNegative rounding mode.
mkFpaRoundTowardNegative :: MonadZ3 z3 => z3 AST
mkFpaRoundTowardNegative :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRoundTowardNegative = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRoundTowardNegative

-- | Create a numeral of RoundingMode sort which represents the
-- TowardNegative rounding mode.
mkFpaRtn :: MonadZ3 z3 => z3 AST
mkFpaRtn :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRtn = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRtn

-- | Create a numeral of RoundingMode sort which represents the
-- TowardZero rounding mode.
mkFpaRoundTowardZero :: MonadZ3 z3 => z3 AST
mkFpaRoundTowardZero :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRoundTowardZero = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRoundTowardZero

-- | Create a numeral of RoundingMode sort which represents the
-- TowardZero rounding mode.
mkFpaRtz :: MonadZ3 z3 => z3 AST
mkFpaRtz :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
mkFpaRtz = (Context -> IO AST) -> z3 AST
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO AST
Base.mkFpaRtz

-- | Create a FloatingPoint sort.
mkFpaSort :: (MonadZ3 z3, Integral int)
          => int -- ^ Number of exponent bits
          -> int -- ^ Number of significand bits
          -> z3 Sort
mkFpaSort :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
int -> int -> z3 Sort
mkFpaSort = (Context -> int -> int -> IO Sort) -> int -> int -> z3 Sort
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> int -> int -> IO Sort
forall int. Integral int => Context -> int -> int -> IO Sort
Base.mkFpaSort

-- | Create the half-precision (16-bit) FloatingPoint sort.
mkFpaSortHalf :: MonadZ3 z3 => z3 Sort
mkFpaSortHalf :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSortHalf = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSortHalf

-- | Create the half-precision (16-bit) FloatingPoint sort.
mkFpaSort16 :: MonadZ3 z3 => z3 Sort
mkFpaSort16 :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSort16 = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSort16

-- | Create the single-precision (32-bit) FloatingPoint sort.
mkFpaSortSingle :: MonadZ3 z3 => z3 Sort
mkFpaSortSingle :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSortSingle = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSortSingle

-- | Create the single-precision (32-bit) FloatingPoint sort.
mkFpaSort32 :: MonadZ3 z3 => z3 Sort
mkFpaSort32 :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSort32 = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSort32

-- | Create the double-precision (64-bit) FloatingPoint sort.
mkFpaSortDouble :: MonadZ3 z3 => z3 Sort
mkFpaSortDouble :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSortDouble = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSortDouble

-- | Create the double-precision (64-bit) FloatingPoint sort.
mkFpaSort64 :: MonadZ3 z3 => z3 Sort
mkFpaSort64 :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSort64 = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSort64

-- | Create the quadruple-precision (128-bit) FloatingPoint sort.
mkFpaSortQuadruple :: MonadZ3 z3 => z3 Sort
mkFpaSortQuadruple :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSortQuadruple = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSortQuadruple

-- | Create the quadruple-precision (128-bit) FloatingPoint sort.
mkFpaSort128 :: MonadZ3 z3 => z3 Sort
mkFpaSort128 :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Sort
mkFpaSort128 = (Context -> IO Sort) -> z3 Sort
forall (z3 :: * -> *) b. MonadZ3 z3 => (Context -> IO b) -> z3 b
liftScalar Context -> IO Sort
Base.mkFpaSort128

-- | Create a floating-point NaN of sort @s@.
mkFpaNaN :: MonadZ3 z3 => Sort -> z3 AST
mkFpaNaN :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> z3 AST
mkFpaNaN = (Context -> Sort -> IO AST) -> Sort -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO AST
Base.mkFpaNaN

-- | Create a floating-point infinity of sort @s@.
mkFpaInf :: MonadZ3 z3
         => Sort    -- ^ Target sort
         -> Bool    -- ^ Indicates whether the result should be negative
         -> z3 AST
mkFpaInf :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> Bool -> z3 AST
mkFpaInf = (Context -> Sort -> Bool -> IO AST) -> Sort -> Bool -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> Bool -> IO AST
Base.mkFpaInf

-- | Create a floating-point zero of sort @s@.
mkFpaZero :: MonadZ3 z3 
          => Sort    -- ^ Target sort
          -> Bool    -- ^ Indicates whether the result should be negative
          -> z3 AST
mkFpaZero :: forall (z3 :: * -> *). MonadZ3 z3 => Sort -> Bool -> z3 AST
mkFpaZero = (Context -> Sort -> Bool -> IO AST) -> Sort -> Bool -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Sort -> Bool -> IO AST
Base.mkFpaZero

-- | Create an expression of FloatingPoint sort from three bit-vector
-- expressions.
--
-- This is the operator named `fp' in the SMT FP theory definition.
-- Note that @sgn@ is required to be a bit-vector of size 1.
-- Significand and exponent are required to be longer than 1 and 2
-- respectively. The FloatingPoint sort of the resulting expression
-- is automatically determined from the bit-vector sizes of the
-- arguments. The exponent is assumed to be in IEEE-754 biased
-- representation.
mkFpaFp :: MonadZ3 z3
        => AST     -- ^ Sign
        -> AST     -- ^ Exponent
        -> AST     -- ^ Significand
        -> z3 AST
mkFpaFp :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkFpaFp = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkFpaFp

-- | Create a numeral of FloatingPoint sort from a float.
mkFpaNumeralFloat :: MonadZ3 z3 => Float -> Sort -> z3 AST
mkFpaNumeralFloat :: forall (z3 :: * -> *). MonadZ3 z3 => Float -> Sort -> z3 AST
mkFpaNumeralFloat = (Context -> Float -> Sort -> IO AST) -> Float -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Float -> Sort -> IO AST
Base.mkFpaNumeralFloat

-- | Create a numeral of FloatingPoint sort from a double.
mkFpaNumeralDouble :: MonadZ3 z3 => Double -> Sort -> z3 AST
mkFpaNumeralDouble :: forall (z3 :: * -> *). MonadZ3 z3 => Double -> Sort -> z3 AST
mkFpaNumeralDouble = (Context -> Double -> Sort -> IO AST) -> Double -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> Double -> Sort -> IO AST
Base.mkFpaNumeralDouble

-- | Create a numeral of FloatingPoint sort from a signed integer.
mkFpaNumeralInt :: (MonadZ3 z3, Integral int) => int -> Sort -> z3 AST
mkFpaNumeralInt :: forall (z3 :: * -> *) a.
(MonadZ3 z3, Integral a) =>
a -> Sort -> z3 AST
mkFpaNumeralInt = (Context -> int -> Sort -> IO AST) -> int -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> int -> Sort -> IO AST
forall a. Integral a => Context -> a -> Sort -> IO AST
Base.mkFpaNumeralInt

-- | Create a numeral of FLoatingPoint sort from a sign bit and
-- two integers.
mkFpaNumeralIntUInt :: (MonadZ3 z3, Integral int)
                    => Bool    -- ^ Sign bit (true == negative)
                    -> int     -- ^ Significand
                    -> int     -- ^ Exponent
                    -> Sort    -- ^ Result sort
                    -> z3 AST
mkFpaNumeralIntUInt :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
Bool -> int -> int -> Sort -> z3 AST
mkFpaNumeralIntUInt = (Context -> Bool -> int -> int -> Sort -> IO AST)
-> Bool -> int -> int -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> Bool -> int -> int -> Sort -> IO AST
forall int.
Integral int =>
Context -> Bool -> int -> int -> Sort -> IO AST
Base.mkFpaNumeralIntUInt

-- | Create a numeral of FloatingPoint sort from a sign bit and
-- two 64-bit integers.
mkFpaNumeralInt64UInt64 :: (MonadZ3 z3, Integral int)
                        => Bool    -- ^ Sign bit (true == negative)
                        -> int     -- ^ Significand
                        -> int     -- ^ Exponent
                        -> Sort    -- ^ Result sort
                        -> z3 AST
mkFpaNumeralInt64UInt64 :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
Bool -> int -> int -> Sort -> z3 AST
mkFpaNumeralInt64UInt64 = (Context -> Bool -> int -> int -> Sort -> IO AST)
-> Bool -> int -> int -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> Bool -> int -> int -> Sort -> IO AST
forall int.
Integral int =>
Context -> Bool -> int -> int -> Sort -> IO AST
Base.mkFpaNumeralInt64UInt64

-- | Floating-point absolute value.
mkFpaAbs :: MonadZ3 z3 => AST -> z3 AST
mkFpaAbs :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaAbs = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaAbs

-- | Floating-point negation.
mkFpaNeg :: MonadZ3 z3 => AST -> z3 AST
mkFpaNeg :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaNeg = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaNeg

-- | Floating-point addition.
mkFpaAdd :: MonadZ3 z3
         => AST     -- ^ Rounding Mode
         -> AST     -- ^ FloatingPoint sort term
         -> AST     -- ^ FloatingPoint sort term
         -> z3 AST
mkFpaAdd :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkFpaAdd = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkFpaAdd

-- | Floating-point subtraction.
mkFpaSub :: MonadZ3 z3
         => AST     -- ^ Rounding Mode
         -> AST     -- ^ FloatingPoint sort term
         -> AST     -- ^ FloatingPoint sort term
         -> z3 AST
mkFpaSub :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkFpaSub = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkFpaSub

-- | Floating-point multiplication.
mkFpaMul :: MonadZ3 z3
         => AST     -- ^ Rounding Mode
         -> AST     -- ^ FloatingPoint sort term
         -> AST     -- ^ FloatingPoint sort term
         -> z3 AST
mkFpaMul :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkFpaMul = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkFpaMul

-- | Floating-point division.
mkFpaDiv :: MonadZ3 z3
         => AST     -- ^ Rounding Mode
         -> AST     -- ^ FloatingPoint sort term
         -> AST     -- ^ FloatingPoint sort term
         -> z3 AST
mkFpaDiv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> AST -> z3 AST
mkFpaDiv = (Context -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> AST -> IO AST
Base.mkFpaDiv

-- | Floating-point fused multiply-add.
--
-- The result is @round((t1 * t2) + t3)@.
mkFpaFma :: MonadZ3 z3 => AST -> AST -> AST -> AST -> z3 AST
mkFpaFma :: forall (z3 :: * -> *).
MonadZ3 z3 =>
AST -> AST -> AST -> AST -> z3 AST
mkFpaFma = (Context -> AST -> AST -> AST -> AST -> IO AST)
-> AST -> AST -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> AST -> AST -> AST -> AST -> IO AST
Base.mkFpaFma

-- | Floating-point square root.
mkFpaSqrt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaSqrt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaSqrt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaSqrt

-- | Floating-point remainder.
mkFpaRem :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaRem :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaRem = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaRem

-- | Floating-point roundToIntegral. Rounds a floating-point number
-- to the closest integer, again represented as a floating-point
-- number.
mkFpaRoundToIntegral :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaRoundToIntegral :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaRoundToIntegral = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaRoundToIntegral

-- | Minimum of floating-point numbers.
mkFpaMin :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaMin :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaMin = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaMin

-- | Maximum of floating-point numbers.
mkFpaMax :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaMax :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaMax = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaMax

-- | Floating-point less than or equal.
mkFpaLeq :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaLeq :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaLeq = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaLeq

-- | Floating-point less than.
mkFpaLt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaLt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaLt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaLt

-- | Floating-point greater than or equal.
mkFpaGeq :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaGeq :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaGeq = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaGeq

-- | Floating-point greater than.
mkFpaGt :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaGt :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaGt = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaGt

-- | Floating-point equality.
mkFpaEq :: MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaEq :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 AST
mkFpaEq = (Context -> AST -> AST -> IO AST) -> AST -> AST -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> AST -> IO AST
Base.mkFpaEq

-- | Predicate indicating whether @t@ is a normal floating-point
-- number.
mkFpaIsNormal :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsNormal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsNormal = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsNormal

-- | Predicate indicating whether @t@ is a subnormal floating-point
-- number.
mkFpaIsSubnormal :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsSubnormal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsSubnormal = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsSubnormal

-- | Predicate indicating whether @t@ is a floating-point number
-- with zero value, i.e., +zero or -zero.
mkFpaIsZero :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsZero :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsZero = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsZero

-- | Predicate indicating whether @t@ is a floating-point number
-- representing infinity, i.e., +oo or -oo.
mkFpaIsInfinite :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsInfinite :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsInfinite = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsInfinite

-- | Predicate indicating whether @t@ is NaN.
mkFpaIsNaN :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsNaN :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsNaN = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsNaN

-- | Predicate indicating whether @t@ is a negative floating-point
-- number.
mkFpaIsNegative :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsNegative :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsNegative = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsNegative

-- | Predicate indicating whether @t@ is a positive floating-point
-- number.
mkFpaIsPositive :: MonadZ3 z3 => AST -> z3 AST
mkFpaIsPositive :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaIsPositive = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaIsPositive

-- | Conversion of a single IEEE 754-2008 bit-vector into a
-- floating-point number.
mkFpaToFpBv :: MonadZ3 z3 => AST -> Sort -> z3 AST
mkFpaToFpBv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Sort -> z3 AST
mkFpaToFpBv = (Context -> AST -> Sort -> IO AST) -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Sort -> IO AST
Base.mkFpaToFpBv

-- | Conversion of a FloatingPoint term into another term of
-- different FloatingPoint sort.
mkFpaToFpFloat :: MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpFloat :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpFloat = (Context -> AST -> AST -> Sort -> IO AST)
-> AST -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Sort -> IO AST
Base.mkFpaToFpFloat

-- | Conversion of a term of real sort into a term of
-- FloatingPoint sort.
mkFpaToFpReal :: MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpReal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpReal = (Context -> AST -> AST -> Sort -> IO AST)
-> AST -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Sort -> IO AST
Base.mkFpaToFpReal

-- | Conversion of a 2's complement signed bit-vector term into
-- a term of FloatingPoint sort.
mkFpaToFpSigned :: MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpSigned :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpSigned = (Context -> AST -> AST -> Sort -> IO AST)
-> AST -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Sort -> IO AST
Base.mkFpaToFpSigned

-- | Conversion of a 2's complement unsigned bit-vector term into
-- a term of FloatingPoint sort.
mkFpaToFpUnsigned :: MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpUnsigned :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> Sort -> z3 AST
mkFpaToFpUnsigned = (Context -> AST -> AST -> Sort -> IO AST)
-> AST -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> Sort -> IO AST
Base.mkFpaToFpUnsigned

-- | Conversion of a floating-point term into an unsigned bit-vector.
mkFpaToUbv :: (MonadZ3 z3, Integral int) => AST -> AST -> int -> z3 AST
mkFpaToUbv :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
AST -> AST -> int -> z3 AST
mkFpaToUbv = (Context -> AST -> AST -> int -> IO AST)
-> AST -> AST -> int -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> int -> IO AST
forall int. Integral int => Context -> AST -> AST -> int -> IO AST
Base.mkFpaToUbv

-- | Conversion of a floating-point term into a signed bit-vector.
mkFpaToSbv :: (MonadZ3 z3, Integral int) => AST -> AST -> int -> z3 AST
mkFpaToSbv :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
AST -> AST -> int -> z3 AST
mkFpaToSbv = (Context -> AST -> AST -> int -> IO AST)
-> AST -> AST -> int -> z3 AST
forall (z3 :: * -> *) a b c d.
MonadZ3 z3 =>
(Context -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftFun3 Context -> AST -> AST -> int -> IO AST
forall int. Integral int => Context -> AST -> AST -> int -> IO AST
Base.mkFpaToSbv

-- | Conversion of a floating-point term into an real-numbered
-- term.
mkFpaToReal :: MonadZ3 z3 => AST -> z3 AST
mkFpaToReal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaToReal = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaToReal

---------------------------------------------------------------------
-- Z3-specific floating-point extensions

-- | Retrieves the number of bits reserved for the exponent in a
-- FloatingPoint sort.
fpaGetEbits :: (MonadZ3 z3, Integral int) => Sort -> z3 int
fpaGetEbits :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
Sort -> z3 int
fpaGetEbits = (Context -> Sort -> IO int) -> Sort -> z3 int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO int
forall int. Integral int => Context -> Sort -> IO int
Base.fpaGetEbits

-- | Retrieves the number of bits reserved for the significand in
-- a FloatingPoint sort.
fpaGetSbits :: (MonadZ3 z3, Integral int) => Sort -> z3 int
fpaGetSbits :: forall (z3 :: * -> *) int.
(MonadZ3 z3, Integral int) =>
Sort -> z3 int
fpaGetSbits = (Context -> Sort -> IO int) -> Sort -> z3 int
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> Sort -> IO int
forall int. Integral int => Context -> Sort -> IO int
Base.fpaGetSbits

-- | Checks whether a given floating-point numeral is a NaN.
fpaIsNumeralNaN :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNaN :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNaN = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralNaN

-- | Checks whether a given floating-point numeral is a +oo or -oo.
fpaIsNumeralInf :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralInf :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralInf = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralInf

-- | Checks whether a given floating-point numeral is a +zero or
-- -zero.
fpaIsNumeralZero :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralZero :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralZero = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralZero

-- | Checks whether a given floating-point numeral is normal.
fpaIsNumeralNormal :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNormal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNormal = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralNormal

-- | Checks whether a given floating-point numeral is subnormal.
fpaIsNumeralSubnormal :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralSubnormal :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralSubnormal = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralSubnormal

-- | Checks whether a given floating-point numeral is positive.
fpaIsNumeralPositive :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralPositive :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralPositive = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralPositive

-- | Checks whether a given floating-point numeral is negative.
fpaIsNumeralNegative :: MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNegative :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 Bool
fpaIsNumeralNegative = (Context -> AST -> IO Bool) -> AST -> z3 Bool
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO Bool
Base.fpaIsNumeralNegative

-- | Retrieves the sign of a floating-point literal as a bit-vector
-- expression.
fpaGetNumeralSignBv :: MonadZ3 z3 => AST -> z3 AST
fpaGetNumeralSignBv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
fpaGetNumeralSignBv = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.fpaGetNumeralSignBv

-- | Retrieves the significand of a floating-point literal as a
-- bit-vector expression.
fpaGetNumeralSignificandBv :: MonadZ3 z3 => AST -> z3 AST
fpaGetNumeralSignificandBv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
fpaGetNumeralSignificandBv = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.fpaGetNumeralSignificandBv

-- | Return the significand value of a floating-point numeral as a
-- string.
fpaGetNumeralSignificandString :: MonadZ3 z3 => AST -> z3 String
fpaGetNumeralSignificandString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 String
fpaGetNumeralSignificandString = (Context -> AST -> IO String) -> AST -> z3 String
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO String
Base.fpaGetNumeralSignificandString

-- | Return the exponent value of a floating-point numeral as a
-- string.
fpaGetNumeralExponentString :: MonadZ3 z3 => AST -> Bool -> z3 String
fpaGetNumeralExponentString :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Bool -> z3 String
fpaGetNumeralExponentString = (Context -> AST -> Bool -> IO String) -> AST -> Bool -> z3 String
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Bool -> IO String
Base.fpaGetNumeralExponentString

-- | Retrieves the exponent of a floating-point literal as a
-- bit-vector expression.
fpaGetNumeralExponentBv :: MonadZ3 z3 => AST -> Bool -> z3 AST
fpaGetNumeralExponentBv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> Bool -> z3 AST
fpaGetNumeralExponentBv = (Context -> AST -> Bool -> IO AST) -> AST -> Bool -> z3 AST
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> a -> b -> IO c) -> a -> b -> z3 c
liftFun2 Context -> AST -> Bool -> IO AST
Base.fpaGetNumeralExponentBv

-- | Conversion of a floating-point term into a bit-vector term
-- in IEEE 754-2008 format.
mkFpaToIEEEBv :: MonadZ3 z3 => AST -> z3 AST
mkFpaToIEEEBv :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 AST
mkFpaToIEEEBv = (Context -> AST -> IO AST) -> AST -> z3 AST
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> a -> IO b) -> a -> z3 b
liftFun1 Context -> AST -> IO AST
Base.mkFpaToIEEEBv

-- | Conversion of a real-sorted significand and an integer-sorted
-- exponent into a term of FloatingPoint sort.
mkFpaToFpIntReal :: MonadZ3 z3 => AST -> AST -> AST -> Sort -> z3 AST
mkFpaToFpIntReal :: forall (z3 :: * -> *).
MonadZ3 z3 =>
AST -> AST -> AST -> Sort -> z3 AST
mkFpaToFpIntReal = (Context -> AST -> AST -> AST -> Sort -> IO AST)
-> AST -> AST -> AST -> Sort -> z3 AST
forall (z3 :: * -> *) a b c d e.
MonadZ3 z3 =>
(Context -> a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> z3 e
liftFun4 Context -> AST -> AST -> AST -> Sort -> IO AST
Base.mkFpaToFpIntReal

---------------------------------------------------------------------
-- Optimization

class MonadZ3 m => MonadOptimize m where
  getOptimize :: m Base.Optimize

optimizeAssert :: MonadOptimize z3 => AST -> z3 ()
optimizeAssert :: forall (z3 :: * -> *). MonadOptimize z3 => AST -> z3 ()
optimizeAssert = (Context -> Optimize -> AST -> IO ()) -> AST -> z3 ()
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> AST -> IO ()
Base.optimizeAssert

optimizeAssertAndTrack :: MonadOptimize z3 => AST -> AST -> z3 ()
optimizeAssertAndTrack :: forall (z3 :: * -> *). MonadOptimize z3 => AST -> AST -> z3 ()
optimizeAssertAndTrack = (Context -> Optimize -> AST -> AST -> IO ()) -> AST -> AST -> z3 ()
forall (z3 :: * -> *) a b c.
MonadOptimize z3 =>
(Context -> Optimize -> a -> b -> IO c) -> a -> b -> z3 c
liftOptimize2 Context -> Optimize -> AST -> AST -> IO ()
Base.optimizeAssertAndTrack

optimizeAssertSoft :: MonadOptimize z3 => AST -> String -> Symbol -> z3 Int
optimizeAssertSoft :: forall (z3 :: * -> *).
MonadOptimize z3 =>
AST -> String -> Symbol -> z3 Int
optimizeAssertSoft = (Context -> Optimize -> AST -> String -> Symbol -> IO Int)
-> AST -> String -> Symbol -> z3 Int
forall (z3 :: * -> *) a b c d.
MonadOptimize z3 =>
(Context -> Optimize -> a -> b -> c -> IO d) -> a -> b -> c -> z3 d
liftOptimize3 Context -> Optimize -> AST -> String -> Symbol -> IO Int
Base.optimizeAssertSoft

optimizeMaximize :: MonadOptimize z3 => AST -> z3 Int
optimizeMaximize :: forall (z3 :: * -> *). MonadOptimize z3 => AST -> z3 Int
optimizeMaximize = (Context -> Optimize -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> AST -> IO Int
Base.optimizeMaximize

optimizeMinimize :: MonadOptimize z3 => AST -> z3 Int
optimizeMinimize :: forall (z3 :: * -> *). MonadOptimize z3 => AST -> z3 Int
optimizeMinimize = (Context -> Optimize -> AST -> IO Int) -> AST -> z3 Int
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> AST -> IO Int
Base.optimizeMinimize

optimizePush :: MonadOptimize z3 => z3 ()
optimizePush :: forall (z3 :: * -> *). MonadOptimize z3 => z3 ()
optimizePush = (Context -> Optimize -> IO ()) -> z3 ()
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO ()
Base.optimizePush

optimizePop :: MonadOptimize z3 => z3 ()
optimizePop :: forall (z3 :: * -> *). MonadOptimize z3 => z3 ()
optimizePop = (Context -> Optimize -> IO ()) -> z3 ()
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO ()
Base.optimizePop

optimizeCheck :: MonadOptimize z3 => [AST] -> z3 Result
optimizeCheck :: forall (z3 :: * -> *). MonadOptimize z3 => [AST] -> z3 Result
optimizeCheck = (Context -> Optimize -> [AST] -> IO Result) -> [AST] -> z3 Result
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> [AST] -> IO Result
Base.optimizeCheck

optimizeGetReasonUnknown :: MonadOptimize z3 => z3 String
optimizeGetReasonUnknown :: forall (z3 :: * -> *). MonadOptimize z3 => z3 String
optimizeGetReasonUnknown = (Context -> Optimize -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO String
Base.optimizeGetReasonUnknown

optimizeGetModel :: MonadOptimize z3 => z3 Model
optimizeGetModel :: forall (z3 :: * -> *). MonadOptimize z3 => z3 Model
optimizeGetModel = (Context -> Optimize -> IO Model) -> z3 Model
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO Model
Base.optimizeGetModel

optimizeGetUnsatCore :: MonadOptimize z3 => z3 [AST]
optimizeGetUnsatCore :: forall (z3 :: * -> *). MonadOptimize z3 => z3 [AST]
optimizeGetUnsatCore = (Context -> Optimize -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO [AST]
Base.optimizeGetUnsatCore

optimizeSetParams :: MonadOptimize z3 => Params -> z3 ()
optimizeSetParams :: forall (z3 :: * -> *). MonadOptimize z3 => Params -> z3 ()
optimizeSetParams = (Context -> Optimize -> Params -> IO ()) -> Params -> z3 ()
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> Params -> IO ()
Base.optimizeSetParams

optimizeGetLower :: MonadOptimize z3 => Int -> z3 AST
optimizeGetLower :: forall (z3 :: * -> *). MonadOptimize z3 => Int -> z3 AST
optimizeGetLower = (Context -> Optimize -> Int -> IO AST) -> Int -> z3 AST
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> Int -> IO AST
Base.optimizeGetLower

optimizeGetUpper :: MonadOptimize z3 => Int -> z3 AST
optimizeGetUpper :: forall (z3 :: * -> *). MonadOptimize z3 => Int -> z3 AST
optimizeGetUpper = (Context -> Optimize -> Int -> IO AST) -> Int -> z3 AST
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> Int -> IO AST
Base.optimizeGetLower

optimizeGetUpperAsVector :: MonadOptimize z3 => Int -> z3 [AST]
optimizeGetUpperAsVector :: forall (z3 :: * -> *). MonadOptimize z3 => Int -> z3 [AST]
optimizeGetUpperAsVector = (Context -> Optimize -> Int -> IO [AST]) -> Int -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> Int -> IO [AST]
Base.optimizeGetUpperAsVector

optimizeGetLowerAsVector :: MonadOptimize z3 => Int -> z3 [AST]
optimizeGetLowerAsVector :: forall (z3 :: * -> *). MonadOptimize z3 => Int -> z3 [AST]
optimizeGetLowerAsVector = (Context -> Optimize -> Int -> IO [AST]) -> Int -> z3 [AST]
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> Int -> IO [AST]
Base.optimizeGetLowerAsVector

optimizeToString :: MonadOptimize z3 => z3 String
optimizeToString :: forall (z3 :: * -> *). MonadOptimize z3 => z3 String
optimizeToString = (Context -> Optimize -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO String
Base.optimizeToString

optimizeFromString :: MonadOptimize z3 => String -> z3 ()
optimizeFromString :: forall (z3 :: * -> *). MonadOptimize z3 => String -> z3 ()
optimizeFromString = (Context -> Optimize -> String -> IO ()) -> String -> z3 ()
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> String -> IO ()
Base.optimizeFromString

optimizeFromFile :: MonadOptimize z3 => String -> z3 ()
optimizeFromFile :: forall (z3 :: * -> *). MonadOptimize z3 => String -> z3 ()
optimizeFromFile = (Context -> Optimize -> String -> IO ()) -> String -> z3 ()
forall (z3 :: * -> *) a b.
MonadOptimize z3 =>
(Context -> Optimize -> a -> IO b) -> a -> z3 b
liftOptimize1 Context -> Optimize -> String -> IO ()
Base.optimizeFromFile

optimizeGetHelp :: MonadOptimize z3 => z3 String
optimizeGetHelp :: forall (z3 :: * -> *). MonadOptimize z3 => z3 String
optimizeGetHelp = (Context -> Optimize -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO String
Base.optimizeGetHelp

optimizeGetAssertions :: MonadOptimize z3 => z3 [AST]
optimizeGetAssertions :: forall (z3 :: * -> *). MonadOptimize z3 => z3 [AST]
optimizeGetAssertions = (Context -> Optimize -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO [AST]
Base.optimizeGetAssertions

optimizeGetObjectives :: MonadOptimize z3 => z3 [AST]
optimizeGetObjectives :: forall (z3 :: * -> *). MonadOptimize z3 => z3 [AST]
optimizeGetObjectives = (Context -> Optimize -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadOptimize z3 =>
(Context -> Optimize -> IO b) -> z3 b
liftOptimize0 Context -> Optimize -> IO [AST]
Base.optimizeGetObjectives

---------------------------------------------------------------------
-- * Solvers

-- mkSolver :: Context -> IO Solver
-- mkSolver = liftFun0 z3_mk_solver

-- mkSimpleSolver :: Context -> IO Solver
-- mkSimpleSolver = liftFun0 z3_mk_simple_solver

-- mkSolverForLogic :: Context -> Logic -> IO Solver
-- mkSolverForLogic c logic = withContextError c $ \cPtr ->
--   do sym <- mkStringSymbol c (show logic)
--      c2h c =<< z3_mk_solver_for_logic cPtr (unSymbol sym)

-- | Return a string describing all solver available parameters.
solverGetHelp :: MonadZ3 z3 => z3 String
solverGetHelp :: forall (z3 :: * -> *). MonadZ3 z3 => z3 String
solverGetHelp = (Context -> Solver -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO String
Base.solverGetHelp

-- | Set the solver using the given parameters.
solverSetParams :: MonadZ3 z3 => Params -> z3 ()
solverSetParams :: forall (z3 :: * -> *). MonadZ3 z3 => Params -> z3 ()
solverSetParams = (Context -> Solver -> Params -> IO ()) -> Params -> z3 ()
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> Params -> IO ()
Base.solverSetParams

-- | Create a backtracking point.
solverPush :: MonadZ3 z3 => z3 ()
solverPush :: forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
solverPush = (Context -> Solver -> IO ()) -> z3 ()
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO ()
Base.solverPush

-- | Backtrack /n/ backtracking points.
solverPop :: MonadZ3 z3 => Int -> z3 ()
solverPop :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> z3 ()
solverPop = (Context -> Solver -> Int -> IO ()) -> Int -> z3 ()
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> Int -> IO ()
Base.solverPop

solverReset :: MonadZ3 z3 => z3 ()
solverReset :: forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
solverReset = (Context -> Solver -> IO ()) -> z3 ()
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO ()
Base.solverReset

-- | Number of backtracking points.
solverGetNumScopes :: MonadZ3 z3 => z3 Int
solverGetNumScopes :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Int
solverGetNumScopes = (Context -> Solver -> IO Int) -> z3 Int
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO Int
Base.solverGetNumScopes

-- | Assert a constraing into the logical context.
--
-- Reference: <http://research.microsoft.com/en-us/um/redmond/projects/z3/group__capi.html#ga1a05ff73a564ae7256a2257048a4680a>
solverAssertCnstr :: MonadZ3 z3 => AST -> z3 ()
solverAssertCnstr :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 ()
solverAssertCnstr = (Context -> Solver -> AST -> IO ()) -> AST -> z3 ()
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> AST -> IO ()
Base.solverAssertCnstr

-- | Assert a constraint a into the solver, and track it
-- (in the unsat) core using the Boolean constant /p/.
--
-- This API is an alternative to Z3_solver_check_assumptions
-- for extracting unsat cores. Both APIs can be used in the same
-- solver. The unsat core will contain a combination of the Boolean
-- variables provided using Z3_solver_assert_and_track and the
-- Boolean literals provided using Z3_solver_check_assumptions.
solverAssertAndTrack :: MonadZ3 z3 => AST -> AST -> z3 ()
solverAssertAndTrack :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> AST -> z3 ()
solverAssertAndTrack = (Context -> Solver -> AST -> AST -> IO ()) -> AST -> AST -> z3 ()
forall (z3 :: * -> *) a b c.
MonadZ3 z3 =>
(Context -> Solver -> a -> b -> IO c) -> a -> b -> z3 c
liftSolver2 Context -> Solver -> AST -> AST -> IO ()
Base.solverAssertAndTrack

-- | Return the set of asserted formulas on the solver.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga3b3d6d8c5bafd5be707cda2d144073db>
solverGetAssertions :: MonadZ3 z3 => z3 [AST]
solverGetAssertions :: forall (z3 :: * -> *). MonadZ3 z3 => z3 [AST]
solverGetAssertions = (Context -> Solver -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO [AST]
Base.solverGetAssertions

-- | Check whether the assertions in a given solver are consistent or not.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga3570e58a8c3d493da4109568b1eca2ce>
solverCheck :: MonadZ3 z3 => z3 Result
solverCheck :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Result
solverCheck = (Context -> Solver -> IO Result) -> z3 Result
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO Result
Base.solverCheck

-- | Check whether the assertions in the given solver and optional assumptions are consistent or not.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga65b2bd980519c0e873d328edcc5f9317>
solverCheckAssumptions :: MonadZ3 z3 => [AST] -> z3 Result
solverCheckAssumptions :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 Result
solverCheckAssumptions = (Context -> Solver -> [AST] -> IO Result) -> [AST] -> z3 Result
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> [AST] -> IO Result
Base.solverCheckAssumptions

-- | Retrieve the model for the last 'solverCheck' or 'solverCheckAssumptions'.
--
-- The error handler is invoked if a model is not available because
-- the commands above were not invoked for the given solver,
-- or if the result was 'Unsat'.
--
-- Reference: <https://z3prover.github.io/api/html/group__capi.html#ga6342b4260e9c92b11cb3eea3a145dff4>
solverGetModel :: MonadZ3 z3 => z3 Model
solverGetModel :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Model
solverGetModel = (Context -> Solver -> IO Model) -> z3 Model
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO Model
Base.solverGetModel
--
-- | Retrieve the proof for the last 'solverCheck' or 'solverCheckAssumptions'.
--
-- The error handler is invoked if a proof is not available because
-- the commands above were not invoked for the given solver,
-- or if the result was different from 'Unsat' (so 'Sat' does not have a proof).
solverGetProof :: MonadZ3 z3 => z3 AST
solverGetProof :: forall (z3 :: * -> *). MonadZ3 z3 => z3 AST
solverGetProof = (Context -> Solver -> IO AST) -> z3 AST
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO AST
Base.solverGetProof

-- | Retrieve the unsat core for the last 'solverCheckAssumptions'; the unsat core is a subset of the assumptions
solverGetUnsatCore :: MonadZ3 z3 => z3 [AST]
solverGetUnsatCore :: forall (z3 :: * -> *). MonadZ3 z3 => z3 [AST]
solverGetUnsatCore = (Context -> Solver -> IO [AST]) -> z3 [AST]
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO [AST]
Base.solverGetUnsatCore

-- | Return a brief justification for an 'Unknown' result for the commands 'solverCheck' and 'solverCheckAssumptions'.
solverGetReasonUnknown :: MonadZ3 z3 => z3 String
solverGetReasonUnknown :: forall (z3 :: * -> *). MonadZ3 z3 => z3 String
solverGetReasonUnknown = (Context -> Solver -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO String
Base.solverGetReasonUnknown

-- | Convert the given solver into a string.
solverToString :: MonadZ3 z3 => z3 String
solverToString :: forall (z3 :: * -> *). MonadZ3 z3 => z3 String
solverToString = (Context -> Solver -> IO String) -> z3 String
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO String
Base.solverToString

solverFromString :: MonadZ3 z3 => String -> z3 ()
solverFromString :: forall (z3 :: * -> *). MonadZ3 z3 => String -> z3 ()
solverFromString = (Context -> Solver -> String -> IO ()) -> String -> z3 ()
forall (z3 :: * -> *) a b.
MonadZ3 z3 =>
(Context -> Solver -> a -> IO b) -> a -> z3 b
liftSolver1 Context -> Solver -> String -> IO ()
Base.solverFromString

-------------------------------------------------
-- ** Helpers

-- | Create a backtracking point.
--
-- For @push; m; pop 1@ see 'local'.
--
-- Alias for 'solverPush'
push :: MonadZ3 z3 => z3 ()
push :: forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
push = z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
solverPush

-- | Backtrack /n/ backtracking points.
--
-- Contrary to 'solverPop' this funtion checks whether /n/ is within
-- the size of the solver scope stack.
pop :: MonadZ3 z3 => Int -> z3 ()
pop :: forall (z3 :: * -> *). MonadZ3 z3 => Int -> z3 ()
pop Int
n = do
  Int
scopes <- z3 Int
forall (z3 :: * -> *). MonadZ3 z3 => z3 Int
solverGetNumScopes
  if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
scopes
    then Int -> z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => Int -> z3 ()
solverPop Int
n
    else String -> z3 ()
forall a. HasCallStack => String -> a
error String
"Z3.Monad.safePop: too many scopes to backtrack"

-- | Run a query and restore the initial logical context.
--
-- This is a shorthand for 'push', run the query, and 'pop'.
local :: MonadZ3 z3 => z3 a -> z3 a
local :: forall (z3 :: * -> *) a. MonadZ3 z3 => z3 a -> z3 a
local z3 a
q = do
  z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
push
  a
r <- z3 a
q
  Int -> z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => Int -> z3 ()
pop Int
1
  a -> z3 a
forall a. a -> z3 a
forall (m :: * -> *) a. Monad m => a -> m a
return a
r

-- | Backtrack all the way.
--
-- Alias for 'solverReset'
reset :: MonadZ3 z3 => z3 ()
reset :: forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
reset = z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => z3 ()
solverReset

-- | Get number of backtracking points.
getNumScopes :: MonadZ3 z3 => z3 Int
getNumScopes :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Int
getNumScopes = (Context -> Solver -> IO Int) -> z3 Int
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO Int
Base.solverGetNumScopes

-- | Alias for 'solverAssertCnstr'
assert :: MonadZ3 z3 => AST -> z3 ()
assert :: forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 ()
assert = AST -> z3 ()
forall (z3 :: * -> *). MonadZ3 z3 => AST -> z3 ()
solverAssertCnstr

-- | Check whether the given logical context is consistent or not.
--
-- Alias for 'solverCheck'
check :: MonadZ3 z3 => z3 Result
check :: forall (z3 :: * -> *). MonadZ3 z3 => z3 Result
check = z3 Result
forall (z3 :: * -> *). MonadZ3 z3 => z3 Result
solverCheck

-- | Check whether the assertions in the given solver and optional assumptions are consistent or not.
--
-- Alias for 'solverCheckAssumptions'
checkAssumptions :: MonadZ3 z3 => [AST] -> z3 Result
checkAssumptions :: forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 Result
checkAssumptions = [AST] -> z3 Result
forall (z3 :: * -> *). MonadZ3 z3 => [AST] -> z3 Result
solverCheckAssumptions

-- | Call 'solverCheck' and based on the result also call 'solverGetModel'.
solverCheckAndGetModel :: MonadZ3 z3 => z3 (Result, Maybe Model)
solverCheckAndGetModel :: forall (z3 :: * -> *). MonadZ3 z3 => z3 (Result, Maybe Model)
solverCheckAndGetModel = (Context -> Solver -> IO (Result, Maybe Model))
-> z3 (Result, Maybe Model)
forall (z3 :: * -> *) b.
MonadZ3 z3 =>
(Context -> Solver -> IO b) -> z3 b
liftSolver0 Context -> Solver -> IO (Result, Maybe Model)
Base.solverCheckAndGetModel

-- | Check and get model.
--
-- Alias for 'solverCheckAndGetModel'
getModel :: MonadZ3 z3 => z3 (Result, Maybe Model)
getModel :: forall (z3 :: * -> *). MonadZ3 z3 => z3 (Result, Maybe Model)
getModel = z3 (Result, Maybe Model)
forall (z3 :: * -> *). MonadZ3 z3 => z3 (Result, Maybe Model)
solverCheckAndGetModel

-- | Check satisfiability and, if /sat/, compute a value from the given model.
--
-- E.g.
-- @
-- withModel $ \\m ->
--   fromJust \<$\> evalInt m x
-- @
withModel :: (Applicative z3, MonadZ3 z3) =>
                (Base.Model -> z3 a) -> z3 (Result, Maybe a)
withModel :: forall (z3 :: * -> *) a.
(Applicative z3, MonadZ3 z3) =>
(Model -> z3 a) -> z3 (Result, Maybe a)
withModel Model -> z3 a
f = do
 (Result
r,Maybe Model
mb_m) <- z3 (Result, Maybe Model)
forall (z3 :: * -> *). MonadZ3 z3 => z3 (Result, Maybe Model)
getModel
 Maybe a
mb_e <- (Model -> z3 a) -> Maybe Model -> z3 (Maybe a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
T.traverse Model -> z3 a
f Maybe Model
mb_m
 (Result, Maybe a) -> z3 (Result, Maybe a)
forall a. a -> z3 a
forall (m :: * -> *) a. Monad m => a -> m a
return (Result
r, Maybe a
mb_e)

-- | Retrieve the unsat core for the last 'checkAssumptions'; the unsat core is a subset of the assumptions.
--
-- Alias for 'solverGetUnsatCore'
getUnsatCore :: MonadZ3 z3 => z3 [AST]
getUnsatCore :: forall (z3 :: * -> *). MonadZ3 z3 => z3 [AST]
getUnsatCore = z3 [AST]
forall (z3 :: * -> *). MonadZ3 z3 => z3 [AST]
solverGetUnsatCore