OPTIONS(3cvc)

NAME
options - the options infrastructure

AVAILABLE INTERNAL OPTIONS

    COMMON OPTIONS

    inputLanguage
        (InputLanguage, default = language::input::LANG_AUTO)
        force input language (default is "auto"; see --lang help)

    outputLanguage
        (OutputLanguage, default = language::output::LANG_AUTO)
        force output language (default is "auto"; see --output-lang help)

    statistics
        (bool)
        give statistics on exit

    help
        (bool)
        full command line reference

    seed
        (uint64_t, default = 0)
        seed for random number generator

    version
        (bool)
        identify this CVC4 binary

    strictParsing
        (bool)
        be less tolerant of non-conforming inputs

    cpuTime
        (bool, default = false)
        measures CPU time if set to true and wall time if false (default false)

    dumpToFileName
        (std::string)
        all dumping goes to FILE (instead of stdout)

    dumpModeString
        (std::string)
        dump preprocessed assertions, etc., see --dump=help

    hardLimit
        (bool, default = false)
        the resource limit is hard potentially leaving the smtEngine in an unsafe state (should be destroyed and rebuild after resourcing out)

    incrementalSolving
        (bool, default = true)
        enable incremental solving

    produceAssertions
        (bool)
        keep an assertions list (enables get-assertions command)

    produceModels
        (bool, default = false)
        support the get-value and get-model commands

    perCallResourceLimit
        (unsigned long)
        enable resource limiting per query

    cumulativeResourceLimit
        (unsigned long)
        enable resource limiting (currently, roughly the number of SAT conflicts)

    perCallMillisecondLimit
        (unsigned long)
        enable time limiting per query (give milliseconds)

    cumulativeMillisecondLimit
        (unsigned long)
        enable time limiting (give milliseconds)

    ARITHMETIC THEORY OPTIONS

    maxApproxDepth
        (int16_t, default = 200)
        maximum branch depth the approximate solver is allowed to take

    arithNoPartialFun
        (bool, default = false)
        do not use partial function semantics for arithmetic (not SMT LIB compliant)

    arithPropAsLemmaLength
        (uint16_t, default = 8)
        rows shorter than this are propagated as clauses

    arithPropagationMode
        (ArithPropagationMode, default = BOTH_PROP)
        turns on arithmetic propagation (default is 'old', see --arith-prop=help)

    arithRewriteEq
        (bool, default = false)
        turns on the preprocessing rewrite turning equalities into a conjunction of inequalities

    collectPivots
        (bool, default = false)
        collect the pivot history

    doCutAllBounded
        (bool, default = false)
        turns on the integer solving step of periodically cutting all integer variables that have both upper and lower bounds

    exportDioDecompositions
        (bool, default = false)
        let skolem variables for integer divisibility constraints leak from the dio solver

    dioRepeat
        (bool, default = false)
        handle dio solver constraints in mass or one at a time

    arithDioSolver
        (bool, default = true)
        turns on Linear Diophantine Equation solver (Griggio, JSAT 2012)

    dioSolverTurns
        (int, default = 10)
        turns in a row dio solver cutting gets

    arithErrorSelectionRule
        (ErrorSelectionRule, default = MINIMUM_AMOUNT)
        change the pivot rule for the basic variable (default is 'min', see --pivot-rule help)

    havePenalties
        (bool, default = false)
        turns on degenerate pivot penalties

    arithHeuristicPivots
        (int16_t, default = 0)
        the number of times to apply the heuristic pivot rule; if N < 0, this defaults to the number of variables; if this is unset, this is tuned by the logic selection

    replayFailureLemma
        (bool, default = false)
        attempt to use external lemmas if approximate solve integer failed

    maxCutsInContext
        (unsigned, default = 65535)
        maximum cuts in a given context before signalling a restart

    arithMLTrick
        (bool, default = false)
        turns on the preprocessing step of attempting to infer bounds on miplib problems

    arithMLTrickSubstitutions
        (unsigned, default = 1)
        do substitution for miplib 'tmp' vars if defined in <= N eliminated vars

    newProp
        (bool, default = false)
        use the new row propagation system

    nlExt
        (bool, default = true)
        extended approach to non-linear

    nlExtEntailConflicts
        (bool, default = false)
        check for entailed conflicts in non-linear solver

    nlExtFactor
        (bool, default = true)
        use factoring inference in non-linear solver

    nlExtIncPrecision
        (bool, default = true)
        whether to increment the precision for irrational function constraints

    nlExtPurify
        (bool, default = false)
        purify non-linear terms at preprocess

    nlExtResBound
        (bool, default = false)
        use resolution-style inference for inferring new bounds

    nlExtRewrites
        (bool, default = true)
        do rewrites in non-linear solver

    nlExtSplitZero
        (bool, default = false)
        intial splits on zero for all variables

    nlExtTfTaylorDegree
        (int16_t, default = 4)
        initial degree of polynomials for Taylor approximation

    nlExtTfTangentPlanes
        (bool, default = true)
        use non-terminating tangent plane strategy for transcendental functions for non-linear

    nlExtTangentPlanes
        (bool, default = false)
        use non-terminating tangent plane strategy for non-linear

    nlExtTangentPlanesInterleave
        (bool, default = false)
        interleave tangent plane strategy for non-linear

    pbRewrites
        (bool, default = false)
        apply pseudo boolean rewrites

    arithPivotThreshold
        (uint16_t, default = 2)
        sets the number of pivots using --pivot-rule per basic variable per simplex instance before using variable order

    ppAssertMaxSubSize
        (unsigned, default = 2)
        threshold for substituting an equality in ppAssert

    arithPropagateMaxLength
        (uint16_t, default = 16)
        sets the maximum row length to be used in propagation

    replayEarlyCloseDepths
        (int, default = 1)
        multiples of the depths to try to close the approx log eagerly

    replayFailurePenalty
        (int, default = 100)
        number of solve integer attempts to skips after a numeric failure

    lemmaRejectCutSize
        (unsigned, default = 25500)
        maximum complexity of any coefficient while outputting replaying cut lemmas

    replayNumericFailurePenalty
        (int, default = 4194304)
        number of solve integer attempts to skips after a numeric failure

    replayRejectCutSize
        (unsigned, default = 25500)
        maximum complexity of any coefficient while replaying cuts

    soiApproxMajorFailure
        (double, default = .01)
        threshold for a major tolerance failure by the approximate solver

    soiApproxMajorFailurePen
        (int, default = 50)
        threshold for a major tolerance failure by the approximate solver

    soiApproxMinorFailure
        (double, default = .0001)
        threshold for a minor tolerance failure by the approximate solver

    soiApproxMinorFailurePen
        (int, default = 10)
        threshold for a minor tolerance failure by the approximate solver

    restrictedPivots
        (bool, default = true)
        have a pivot cap for simplex at effort levels below fullEffort

    revertArithModels
        (bool, default = false)
        revert the arithmetic model to a known safe model on unsat if one is cached

    rewriteDivk
        (bool, default = false)
        rewrite division and mod when by a constant into linear terms

    rrTurns
        (int, default = 3)
        round robin turn

    trySolveIntStandardEffort
        (bool, default = false)
        attempt to use the approximate solve integer method on standard effort

    arithSimplexCheckPeriod
        (uint16_t, default = 200)
        the number of pivots to do in simplex before rechecking for a conflict on all variables

    sNormInferEq
        (bool, default = false)
        infer equalities based on Shostak normalization

    soiQuickExplain
        (bool, default = false)
        use quick explain to minimize the sum of infeasibility conflicts

    arithStandardCheckVarOrderPivots
        (int16_t, default = -1)
        limits the number of pivots in a single invocation of check() at a non-full effort level using Bland's pivot rule (EXPERTS only)

    arithUnateLemmaMode
        (ArithUnateLemmaMode, default = ALL_PRESOLVE_LEMMAS)
        determines which lemmas to add before solving (default is 'all', see --unate-lemmas=help)

    useApprox
        (bool, default = false)
        attempt to use an approximate solver

    useFC
        (bool, default = false)
        use focusing and converging simplex (FMCAD 2013 submission)

    useSOI
        (bool, default = false)
        use sum of infeasibility simplex (FMCAD 2013 submission)

    ARRAYS THEORY OPTIONS

    arraysConfig
        (int, default = 0)
        set different array option configurations - for developers only

    arraysEagerIndexSplitting
        (bool, default = true)
        turn on eager index splitting for generated array lemmas

    arraysEagerLemmas
        (bool, default = false)
        turn on eager lemma generation for arrays

    arraysLazyRIntro1
        (bool, default = true)
        turn on optimization to only perform RIntro1 rule lazily (see Jovanovic/Barrett 2012: Being Careful with Theory Combination)

    arraysModelBased
        (bool, default = false)
        turn on model-based array solver

    arraysOptimizeLinear
        (bool, default = true)
        turn on optimization for linear array terms (see de Moura FMCAD 09 arrays paper)

    arraysPropagate
        (int, default = 2)
        propagation effort for arrays: 0 is none, 1 is some, 2 is full

    arraysReduceSharing
        (bool, default = false)
        use model information to reduce size of care graph for arrays

    arraysWeakEquivalence
        (bool, default = false)
        use algorithm from Christ/Hoenicke (SMT 2014)

    BASE OPTIONS

    binary_name
        (std::string)
        [undocumented]

    err (std::ostream*, default = &std::cerr)
        [undocumented]

    in  (std::istream*, default = &std::cin)
        [undocumented]

    languageHelp
        (bool)
        [undocumented]

    out (std::ostream*, default = &std::cout)
        [undocumented]

    parseOnly
        (bool)
        exit after parsing input

    preprocessOnly
        (bool)
        exit after preprocessing input

    printSuccess
        (bool)
        print the "success" output required of SMT-LIBv2

    statsEveryQuery
        (bool, default = false)
        in incremental mode, print stats after every satisfiability or validity query

    statsHideZeros
        (bool, default = false)
        hide statistics which are zero

    verbosity
        (int, default = 0)
        the verbosity level of CVC4

    BITVECTOR THEORY OPTIONS

    bitvectorAig
        (bool, default = false)
        bitblast by first converting to AIG (implies --bitblast=eager)

    bitblastMode
        (CVC4::theory::bv::BitblastMode, default = CVC4::theory::bv::BITBLAST_MODE_LAZY)
        choose bitblasting mode, see --bitblast=help

    boolToBitvector
        (bool, default = false)
        convert booleans to bit-vectors of size 1 when possible

    bvAbstraction
        (bool, default = false)
        mcm benchmark abstraction (EXPERTS only)

    bitvectorAigSimplifications
        (std::string)
        abc command to run AIG simplifications (implies --bitblast-aig, default is "balance;drw") (EXPERTS only)

    bvAlgExtf
        (bool, default = true)
        algebraic inferences for extended functions

    bitvectorAlgebraicBudget
        (unsigned, default = 1500)
        the budget allowed for the algebraic solver in number of SAT conflicts (EXPERTS only)

    bitvectorAlgebraicSolver
        (bool, default = true)
        turn on the algebraic solver for the bit-vector theory (only if --bitblast=lazy)

    bitvectorDivByZeroConst
        (bool, default = false)
        always return -1 on division by zero

    bvEagerExplanations
        (bool, default = false)
        compute bit-blasting propagation explanations eagerly (EXPERTS only)

    bitvectorEqualitySlicer
        (CVC4::theory::bv::BvSlicerMode, default = CVC4::theory::bv::BITVECTOR_SLICER_OFF)
        turn on the slicing equality solver for the bit-vector theory (only if --bitblast=lazy)

    bitvectorEqualitySolver
        (bool, default = true)
        use the equality engine for the bit-vector theory (only if --bitblast=lazy)

    bvExtractArithRewrite
        (bool, default = false)
        enable rewrite pushing extract [i:0] over arithmetic operations (can blow up) (EXPERTS only)

    bvGaussElim
        (bool, default = false)
        simplify formula via Gaussian Elimination if applicable (EXPERTS only)

    bitvectorInequalitySolver
        (bool, default = true)
        turn on the inequality solver for the bit-vector theory (only if --bitblast=lazy)

    bvIntroducePow2
        (bool, default = false)
        introduce bitvector powers of two as a preprocessing pass (EXPERTS only)

    bvLazyReduceExtf
        (bool, default = false)
        reduce extended functions like bv2nat and int2bv at last call instead of full effort

    bvLazyRewriteExtf
        (bool, default = true)
        lazily rewrite extended functions like bv2nat and int2bv

    bvNumFunc
        (unsigned, default = 1)
        number of function symbols in conflicts that are generalized (EXPERTS only)

    bitvectorPropagate
        (bool, default = true)
        use bit-vector propagation in the bit-blaster

    bitvectorQuickXplain
        (bool, default = false)
        minimize bv conflicts using the QuickXplain algorithm (EXPERTS only)

    bvSatSolver
        (CVC4::theory::bv::SatSolverMode, default = CVC4::theory::bv::SAT_SOLVER_MINISAT)
        choose which sat solver to use, see --bv-sat-solver=help (EXPERTS only)

    skolemizeArguments
        (bool, default = false)
        skolemize arguments for bv abstraction (only does something if --bv-abstraction is on) (EXPERTS only)

    bitvectorToBool
        (bool, default = false)
        lift bit-vectors of size 1 to booleans when possible

    DATATYPES THEORY OPTIONS

    cdtBisimilar
        (bool, default = true)
        do bisimilarity check for co-datatypes

    dtBinarySplit
        (bool, default = false)
        do binary splits for datatype constructor types

    dtBlastSplits
        (bool, default = false)
        when applicable, blast splitting lemmas for all variables at once

    dtCyclic
        (bool, default = true)
        do cyclicity check for datatypes

    dtForceAssignment
        (bool, default = false)
        force the datatypes solver to give specific values to all datatypes terms before answering sat

    dtInferAsLemmas
        (bool, default = false)
        always send lemmas out instead of making internal inferences

    dtRefIntro
        (bool, default = false)
        introduce reference skolems for shorter explanations

    dtRewriteErrorSel
        (bool, default = false)
        rewrite incorrectly applied selectors to arbitrary ground term (EXPERTS only)

    dtSharedSelectors
        (bool, default = true)
        internally use shared selectors across multiple constructors

    dtUseTesters
        (bool, default = true)
        do not preprocess away tester predicates

    sygusAbortSize
        (int, default = -1)
        tells enumerative sygus to only consider solutions up to term size N (-1 == no limit, default)

    sygusEvalBuiltin
        (bool, default = true)
        use builtin kind for evaluation functions in sygus

    sygusFairMax
        (bool, default = true)
        use max instead of sum for multi-function sygus conjectures

    sygusFair
        (CVC4::theory::SygusFairMode, default = CVC4::theory::SYGUS_FAIR_DT_SIZE)
        if and how to apply fairness for sygus

    sygusOpt1
        (bool, default = false)
        sygus experimental option

    sygusSymBreak
        (bool, default = true)
        simple sygus sym break lemmas

    sygusSymBreakDynamic
        (bool, default = true)
        dynamic sygus sym break lemmas

    sygusSymBreakLazy
        (bool, default = true)
        lazily add symmetry breaking lemmas for terms

    sygusSymBreakPbe
        (bool, default = true)
        sygus sym break lemmas based on pbe conjectures

    sygusSymBreakRlv
        (bool, default = true)
        add relevancy conditions to symmetry breaking lemmas

    DECISION HEURISTICS OPTIONS

    decisionRandomWeight
        (int, default = 0)
        assign random weights to nodes between 0 and N-1 (0: disable) (EXPERTS only)

    decisionThreshold
        (decision::DecisionWeight, default = 0)
        ignore all nodes greater than threshold in first attempt to pick decision (EXPERTS only)

    decisionUseWeight
        (bool, default = false)
        use the weight nodes (locally, by looking at children) to direct recursive search (EXPERTS only)

    decisionWeightInternal
        (decision::DecisionWeightInternal, default = decision::DECISION_WEIGHT_INTERNAL_OFF)
        computer weights of internal nodes using children: off, max, sum, usr1 (meaning evolving) (EXPERTS only)

    decisionMode
        (decision::DecisionMode, default = decision::DECISION_STRATEGY_INTERNAL)
        choose decision mode, see --decision=help

    decisionStopOnly
        (bool)
        [undocumented]

    EXPRESSION PACKAGE OPTIONS

    defaultDagThresh
        (int, default = 1)
        dagify common subexprs appearing > N times (1 == default, 0 == don't dagify)

    defaultExprDepth
        (int, default = 0)
        print exprs to depth N (0 == default, -1 == no limit)

    earlyTypeChecking
        (bool, default = USE_EARLY_TYPE_CHECKING_BY_DEFAULT)
        type check expressions immediately on creation (debug builds only)

    printExprTypes
        (bool, default = false)
        print types with variables when printing exprs

    typeChecking
        (bool, default = DO_SEMANTIC_CHECKS_BY_DEFAULT)
        never type check expressions

    IDL OPTIONS

    idlRewriteEq
        (bool, default = false)
        enable rewriting equalities into two inequalities in IDL solver (default is disabled)

    DRIVER OPTIONS

    continuedExecution
        (bool, default = false)
        continue executing commands, even on error

    earlyExit
        (bool, default = true)
        do not run destructors at exit; default on except in debug builds (EXPERTS only)

    fallbackSequential
        (bool, default = false)
        Switch to sequential mode (instead of printing an error) if it can't be solved in portfolio mode

    sharingFilterByLength
        (int, default = -1)
        don't share (among portfolio threads) lemmas strictly longer than N

    incrementalParallel
        (bool, default = false)
        Use parallel solver even in incremental mode (may print 'unknown's at times)

    interactive
        (bool)
        force interactive/non-interactive mode

    interactivePrompt
        (bool, default = true)
        interactive prompting while in interactive mode

    segvSpin
        (bool, default = false)
        spin on segfault/other crash waiting for gdb

    tearDownIncremental
        (int, default = 0)
        implement PUSH/POP/multi-query by destroying and recreating SmtEngine every N queries (EXPERTS only)

    threadStackSize
        (unsigned, default = 0)
        stack size for worker threads in MB (0 means use Boost/thread lib default)

    threadArgv
        (std::vector<std::string>)
        Thread configuration (a string to be passed to parseOptions)

    thread_id
        (int, default = -1)
        Thread ID, for internal use in case of multi-threaded run

    threads
        (unsigned, default = 2)
        Total number of threads for portfolio

    waitToJoin
        (bool, default = true)
        wait for other threads to join before quitting (EXPERTS only)

    PARSER OPTIONS

    filesystemAccess
        (bool, default = true)
        [undocumented]

    globalDeclarations
        (bool, default = false)
        force all declarations and definitions to be global

    memoryMap
        (bool)
        memory map file input

    semanticChecks
        (bool, default = DO_SEMANTIC_CHECKS_BY_DEFAULT)
        disable ALL semantic checks, including type checks

    PRINTING OPTIONS

    instFormatMode
        (InstFormatMode, default = INST_FORMAT_MODE_DEFAULT)
        print format mode for instantiations, see --inst-format=help

    modelFormatMode
        (ModelFormatMode, default = MODEL_FORMAT_MODE_DEFAULT)
        print format mode for models, see --model-format=help

    PROOF OPTIONS

    aggressiveCoreMin
        (bool, default = false)
        turns on aggressive unsat core minimization (experimental)

    allowEmptyDependencies
        (bool, default = false)
        if unable to track the dependencies of a rewritten/preprocessed assertion, fail silently

    fewerPreprocessingHoles
        (bool, default = false)
        try to eliminate preprocessing holes in proofs

    lfscLetification
        (bool, default = true)
        turns on global letification in LFSC proofs

    SAT LAYER OPTIONS

    minisatDumpDimacs
        (bool, default = false)
        instead of solving minisat dumps the asserted clauses in Dimacs format

    minisatUseElim
        (bool, default = true)
        use Minisat elimination

    satRandomFreq
        (double, default = 0.0)
        sets the frequency of random decisions in the sat solver (P=0.0 by default)

    satRandomSeed
        (uint32_t, default = 0)
        sets the random seed for the sat solver

    sat_refine_conflicts
        (bool, default = false)
        refine theory conflict clauses (default false)

    satRestartFirst
        (unsigned, default = 25)
        sets the base restart interval for the sat solver (N=25 by default)

    satRestartInc
        (double, default = 3.0)
        sets the restart interval increase factor for the sat solver (F=3.0 by default)

    satClauseDecay
        (double, default = 0.999)
        clause activity decay factor for Minisat

    satVarDecay
        (double, default = 0.95)
        variable activity decay factor for Minisat

    QUANTIFIERS OPTIONS

    aggressiveMiniscopeQuant
        (bool, default = false)
        perform aggressive miniscoping for quantifiers

    cbqi
        (bool, default = false)
        turns on counterexample-based quantifier instantiation

    cbqiAll
        (bool, default = false)
        apply counterexample-based instantiation to all quantified formulas

    cbqiBv
        (bool, default = true)
        use word-level inversion approach for counterexample-guided quantifier instantiation for bit-vectors

    cbqiBvConcInv
        (bool, default = true)
        compute inverse for concat over equalities rather than producing an invertibility condition

    cbqiBvIneqMode
        (CVC4::theory::quantifiers::CbqiBvIneqMode, default = CVC4::theory::quantifiers::CBQI_BV_INEQ_EQ_BOUNDARY)
        choose mode for handling bit-vector inequalities with counterexample-guided instantiation

    cbqiBvInterleaveValue
        (bool, default = false)
        interleave model value instantiation with word-level inversion approach

    cbqiBvLinearize
        (bool, default = true)
        linearize adder chains for variables

    cbqiBvRmExtract
        (bool, default = true)
        replaces extract terms with variables for counterexample-guided instantiation for bit-vectors

    cbqiBvSolveNl
        (bool, default = false)
        try to solve non-linear bv literals using model value projections

    cbqiFullEffort
        (bool, default = false)
        turns on full effort counterexample-based quantifier instantiation, which may resort to model-value instantiation

    cbqiInnermost
        (bool, default = true)
        only process innermost quantified formulas in counterexample-based quantifier instantiation

    cbqiLitDepend
        (bool, default = true)
        dependency lemmas for quantifier alternation in counterexample-based quantifier instantiation

    cbqiMidpoint
        (bool, default = false)
        choose substitutions based on midpoints of lower and upper bounds for counterexample-based quantifier instantiation

    cbqiMinBounds
        (bool, default = false)
        use minimally constrained lower/upper bound for counterexample-based quantifier instantiation

    cbqiModel
        (bool, default = true)
        guide instantiations by model values for counterexample-based quantifier instantiation

    cbqiMultiInst
        (bool, default = false)
        when applicable, do multi instantiations per quantifier per round in counterexample-based quantifier instantiation

    cbqiNestedQE
        (bool, default = false)
        process nested quantified formulas with quantifier elimination in counterexample-based quantifier instantiation

    cbqiNopt
        (bool, default = true)
        non-optimal bounds for counterexample-based quantifier instantiation

    cbqiPreRegInst
        (bool, default = false)
        preregister ground instantiations in counterexample-based quantifier instantiation

    recurseCbqi
        (bool, default = true)
        turns on recursive counterexample-based quantifier instantiation

    cbqiRepeatLit
        (bool, default = false)
        solve literals more than once in counterexample-based quantifier instantiation

    cbqiRoundUpLowerLia
        (bool, default = false)
        round up integer lower bounds in substitutions for counterexample-based quantifier instantiation

    cbqiSat
        (bool, default = true)
        answer sat when quantifiers are asserted with counterexample-based quantifier instantiation

    cbqiUseInfInt
        (bool, default = false)
        use integer infinity for vts in counterexample-based quantifier instantiation

    cbqiUseInfReal
        (bool, default = false)
        use real infinity for vts in counterexample-based quantifier instantiation

    cegisSample
        (CVC4::theory::quantifiers::CegisSampleMode, default = CVC4::theory::quantifiers::CEGIS_SAMPLE_NONE)
        mode for using samples in the counterexample-guided inductive synthesis loop

    ceGuidedInst
        (bool, default = false)
        counterexample-guided quantifier instantiation for sygus

    cegqiSingleInvAbort
        (bool, default = false)
        abort if synthesis conjecture is not single invocation

    cegqiSingleInvPartial
        (bool, default = false)
        combined techniques for synthesis conjectures that are partially single invocation

    cegqiSingleInvReconstruct
        (bool, default = true)
        reconstruct solutions for single invocation conjectures in original grammar

    cegqiSingleInvReconstructConst
        (bool, default = true)
        include constants when reconstruct solutions for single invocation conjectures in original grammar

    cegqiSolMinCore
        (bool, default = false)
        minimize solutions for single invocation conjectures based on unsat core

    cegqiSolMinInst
        (bool, default = true)
        minimize individual instantiations for single invocation conjectures based on unsat core

    cegqiSingleInvMode
        (CVC4::theory::quantifiers::CegqiSingleInvMode, default = CVC4::theory::quantifiers::CEGQI_SI_MODE_NONE)
        mode for processing single invocation synthesis conjectures

    condRewriteQuant
        (bool, default = true)
        conditional rewriting of quantified formulas

    condVarSplitQuantAgg
        (bool, default = false)
        aggressive split quantified formulas that lead to variable eliminations

    condVarSplitQuant
        (bool, default = true)
        split quantified formulas that lead to variable eliminations

    conjectureFilterActiveTerms
        (bool, default = true)
        filter based on active terms

    conjectureFilterCanonical
        (bool, default = true)
        filter based on canonicity

    conjectureFilterModel
        (bool, default = true)
        filter based on model

    conjectureGen
        (bool, default = false)
        generate candidate conjectures for inductive proofs

    conjectureGenGtEnum
        (int, default = 50)
        number of ground terms to generate for model filtering

    conjectureGenMaxDepth
        (int, default = 3)
        maximum depth of terms to consider for conjectures

    conjectureGenPerRound
        (int, default = 1)
        number of conjectures to generate per instantiation round

    conjectureUeeIntro
        (bool, default = false)
        more aggressive merging for universal equality engine, introduces terms

    conjectureNoFilter
        (bool, default = false)
        do not filter conjectures

    dtStcInduction
        (bool, default = false)
        apply strengthening for existential quantification over datatypes based on structural induction

    dtVarExpandQuant
        (bool, default = true)
        expand datatype variables bound to one constructor in quantifiers

    eMatching
        (bool, default = true)
        whether to do heuristic E-matching

    elimExtArithQuant
        (bool, default = true)
        eliminate extended arithmetic symbols in quantified formulas

    elimTautQuant
        (bool, default = true)
        eliminate tautological disjuncts of quantified formulas

    finiteModelFind
        (bool, default = false)
        use finite model finding heuristic for quantifier instantiation

    fmfBound
        (bool, default = false)
        finite model finding on bounded quantification

    fmfBoundInt
        (bool, default = false)
        finite model finding on bounded integer quantification

    fmfBoundLazy
        (bool, default = false)
        enforce bounds for bounded quantification lazily via use of proxy variables

    fmfBoundMinMode
        (CVC4::theory::quantifiers::FmfBoundMinMode, default = CVC4::theory::quantifiers::FMF_BOUND_MIN_INT_RANGE)
        mode for which types of bounds to minimize via first decision heuristics

    fmfEmptySorts
        (bool, default = false)
        allow finite model finding to assume sorts that do not occur in ground assertions are empty

    fmfFmcSimple
        (bool, default = true)
        simple models in full model check for finite model finding

    fmfFreshDistConst
        (bool, default = false)
        use fresh distinguished representative when applying Inst-Gen techniques

    fmfFunWellDefined
        (bool, default = false)
        find models for recursively defined functions, assumes functions are admissible

    fmfFunWellDefinedRelevant
        (bool, default = false)
        find models for recursively defined functions, assumes functions are admissible, allows empty type when function is irrelevant

    fmfInstEngine
        (bool, default = false)
        use instantiation engine in conjunction with finite model finding

    fmfInstGen
        (bool, default = true)
        enable Inst-Gen instantiation techniques for finite model finding

    fmfInstGenOneQuantPerRound
        (bool, default = false)
        only perform Inst-Gen instantiation techniques on one quantifier per round

    fullSaturateInterleave
        (bool, default = false)
        interleave full saturate instantiation with other techniques

    fullSaturateQuant
        (bool, default = false)
        when all other quantifier instantiation strategies fail, instantiate with ground terms from relevant domain, then arbitrary ground terms before answering unknown

    fullSaturateQuantRd
        (bool, default = true)
        whether to use relevant domain first for full saturation instantiation strategy

    globalNegate
        (bool, default = false)
        do global negation of input formula

    hoMatching
        (bool, default = true)
        do higher-order matching algorithm for triggers with variable operators

    hoMatchingVarArgPriority
        (bool, default = true)
        give priority to variable arguments over constant arguments

    hoMergeTermDb
        (bool, default = true)
        merge term indices modulo equality

    incrementTriggers
        (bool, default = true)
        generate additional triggers as needed during search

    inferArithTriggerEq
        (bool, default = false)
        infer equalities for trigger terms based on solving arithmetic equalities

    inferArithTriggerEqExp
        (bool, default = false)
        record explanations for inferArithTriggerEq

    instLevelInputOnly
        (bool, default = true)
        only input terms are assigned instantiation level zero

    instMaxLevel
        (int, default = -1)
        maximum inst level of terms used to instantiate quantified formulas with (-1 == no limit, default)

    instNoEntail
        (bool, default = true)
        do not consider instances of quantified formulas that are currently entailed

    instNoModelTrue
        (bool, default = false)
        do not consider instances of quantified formulas that are currently true in model, if it is available

    instPropagate
        (bool, default = false)
        internal propagation for instantiations for selecting relevant instances

    instWhenPhase
        (int, default = 2)
        instantiation rounds quantifiers takes (>=1) before allowing theory combination to happen

    instWhenStrictInterleave
        (bool, default = true)
        ensure theory combination and standard quantifier effort strategies take turns

    instWhenTcFirst
        (bool, default = true)
        allow theory combination to happen once initially, before quantifier strategies are run

    instWhenMode
        (CVC4::theory::quantifiers::InstWhenMode, default = CVC4::theory::quantifiers::INST_WHEN_FULL_LAST_CALL)
        when to apply instantiation

    intWfInduction
        (bool, default = false)
        apply strengthening for integers based on well-founded induction

    iteDtTesterSplitQuant
        (bool, default = false)
        split ites with dt testers as conditions

    iteLiftQuant
        (CVC4::theory::quantifiers::IteLiftQuantMode, default = CVC4::theory::quantifiers::ITE_LIFT_QUANT_MODE_SIMPLE)
        ite lifting mode for quantified formulas

    literalMatchMode
        (CVC4::theory::quantifiers::LiteralMatchMode, default = CVC4::theory::quantifiers::LITERAL_MATCH_USE)
        choose literal matching mode

    localTheoryExt
        (bool, default = false)
        do instantiation based on local theory extensions

    ltePartialInst
        (bool, default = false)
        partially instantiate local theory quantifiers

    lteRestrictInstClosure
        (bool, default = false)
        treat arguments of inst closure as restricted terms for instantiation

    macrosQuant
        (bool, default = false)
        perform quantifiers macro expansion

    macrosQuantMode
        (CVC4::theory::quantifiers::MacrosQuantMode, default = CVC4::theory::quantifiers::MACROS_QUANT_MODE_GROUND_UF)
        mode for quantifiers macro expansion

    mbqiInterleave
        (bool, default = false)
        interleave model-based quantifier instantiation with other techniques

    fmfOneInstPerRound
        (bool, default = false)
        only add one instantiation per quantifier per round for mbqi

    fmfOneQuantPerRound
        (bool, default = false)
        only add instantiations for one quantifier per round for mbqi

    mbqiMode
        (CVC4::theory::quantifiers::MbqiMode, default = CVC4::theory::quantifiers::MBQI_FMC)
        choose mode for model-based quantifier instantiation

    miniscopeQuant
        (bool, default = true)
        miniscope quantifiers

    miniscopeQuantFreeVar
        (bool, default = true)
        miniscope quantifiers for ground subformulas

    multiTriggerCache
        (bool, default = false)
        caching version of multi triggers

    multiTriggerLinear
        (bool, default = true)
        implementation of multi triggers where maximum number of instantiations is linear wrt number of ground terms

    multiTriggerPriority
        (bool, default = false)
        only try multi triggers if single triggers give no instantiations

    multiTriggerWhenSingle
        (bool, default = false)
        select multi triggers when single triggers exist

    partialTriggers
        (bool, default = false)
        use triggers that do not contain all free variables

    preSkolemQuant
        (bool, default = false)
        apply skolemization eagerly to bodies of quantified formulas

    preSkolemQuantAgg
        (bool, default = true)
        apply skolemization to quantified formulas aggressively

    preSkolemQuantNested
        (bool, default = true)
        apply skolemization to nested quantified formulas

    prenexQuantUser
        (bool, default = false)
        prenex quantified formulas with user patterns

    prenexQuant
        (CVC4::theory::quantifiers::PrenexQuantMode, default = CVC4::theory::quantifiers::PRENEX_QUANT_SIMPLE)
        prenex mode for quantified formulas

    pureThTriggers
        (bool, default = false)
        use pure theory terms as single triggers

    purifyDtTriggers
        (bool, default = false)
        purify dt triggers, match all constructors of correct form instead of selectors

    purifyTriggers
        (bool, default = false)
        purify triggers, e.g. f( x+1 ) becomes f( y ), x mapsto y-1

    qcfAllConflict
        (bool, default = false)
        add all available conflicting instances during conflict-based instantiation

    qcfEagerCheckRd
        (bool, default = true)
        optimization, eagerly check relevant domain of matched position

    qcfEagerTest
        (bool, default = true)
        optimization, test qcf instances eagerly

    qcfNestedConflict
        (bool, default = false)
        consider conflicts for nested quantifiers

    qcfSkipRd
        (bool, default = false)
        optimization, skip instances based on possibly irrelevant portions of quantified formulas

    qcfTConstraint
        (bool, default = false)
        enable entailment checks for t-constraints in qcf algorithm

    qcfVoExp
        (bool, default = false)
        qcf experimental variable ordering

    quantAlphaEquiv
        (bool, default = true)
        infer alpha equivalence between quantified formulas

    quantAntiSkolem
        (bool, default = false)
        perform anti-skolemization for quantified formulas

    quantConflictFind
        (bool, default = true)
        enable conflict find mechanism for quantifiers

    qcfMode
        (CVC4::theory::quantifiers::QcfMode, default = CVC4::theory::quantifiers::QCF_PROP_EQ)
        what effort to apply conflict find mechanism

    qcfWhenMode
        (CVC4::theory::quantifiers::QcfWhenMode, default = CVC4::theory::quantifiers::QCF_WHEN_MODE_DEFAULT)
        when to invoke conflict find mechanism for quantifiers

    quantDynamicSplit
        (CVC4::theory::quantifiers::QuantDSplitMode, default = CVC4::theory::quantifiers::QUANT_DSPLIT_MODE_NONE)
        mode for dynamic quantifiers splitting

    quantEpr
        (bool, default = false)
        infer whether in effectively propositional fragment, use for cbqi

    quantEprMatching
        (bool, default = true)
        use matching heuristics for EPR instantiation

    quantFunWellDefined
        (bool, default = false)
        assume that function defined by quantifiers are well defined

    quantInduction
        (bool, default = false)
        use all available techniques for inductive reasoning

    quantModelEe
        (bool, default = false)
        use equality engine of model for last call effort

    quantRepMode
        (CVC4::theory::quantifiers::QuantRepMode, default = CVC4::theory::quantifiers::QUANT_REP_MODE_FIRST)
        selection mode for representatives in quantifiers engine

    quantSplit
        (bool, default = true)
        apply splitting to quantified formulas based on variable disjoint disjuncts

    registerQuantBodyTerms
        (bool, default = false)
        consider ground terms within bodies of quantified formulas for matching

    relationalTriggers
        (bool, default = false)
        choose relational triggers such as x = f(y), x >= f(y)

    relevantTriggers
        (bool, default = false)
        prefer triggers that are more relevant based on SInE style analysis

    quantRewriteRules
        (bool, default = false)
        use rewrite rules module

    rrOneInstPerRound
        (bool, default = false)
        add one instance of rewrite rule per round

    strictTriggers
        (bool, default = false)
        only instantiate quantifiers with user patterns based on triggers

    sygusAddConstGrammar
        (bool, default = false)
        statically add constants appearing in conjecture to grammars

    sygusInvAutoUnfold
        (bool, default = true)
        enable approach which automatically unfolds transition systems for directly solving invariant synthesis problems

    sygusBoolIteReturnConst
        (bool, default = true)
        Only use Boolean constants for return values in unification-based function synthesis

    sygusEvalUnfold
        (bool, default = true)
        do unfolding of sygus evaluation functions

    sygusEvalUnfoldBool
        (bool, default = true)
        do unfolding of Boolean evaluation functions that appear in refinement lemmas

    sygusExtRew
        (bool, default = true)
        use extended rewriter for sygus

    sygusGrammarNorm
        (bool, default = false)
        statically normalize sygus grammars based on flattening (linearization)

    sygusInference
        (bool, default = false)
        attempt to preprocess arbitrary inputs to sygus conjectures

    sygusInvTemplWhenSyntax
        (bool, default = false)
        use invariant templates (with solution reconstruction) for syntax guided problems

    sygusInvTemplMode
        (CVC4::theory::quantifiers::SygusInvTemplMode, default = CVC4::theory::quantifiers::SYGUS_INV_TEMPL_MODE_POST)
        template mode for sygus invariant synthesis (weaken pre-condition, strengthen post-condition, or none)

    sygusMinGrammar
        (bool, default = true)
        statically minimize sygus grammars

    sygusUnifPbe
        (bool, default = true)
        enable approach which unifies conditional solutions, specialized for programming-by-examples (pbe) conjectures

    sygusQePreproc
        (bool, default = false)
        use quantifier elimination as a preprocessing step for sygus

    sygusRefEval
        (bool, default = true)
        direct evaluation of refinement lemmas for conflict analysis

    sygusRepairConst
        (bool, default = true)
        use approach to repair constants in sygus candidate solutions

    sygusRew
        (bool, default = false)
        use sygus to enumerate and verify correctness of rewrite rules via sampling

    sygusRewSynth
        (bool, default = false)
        use sygus to enumerate candidate rewrite rules via sampling

    sygusRewSynthAccel
        (bool, default = false)
        add dynamic symmetry breaking clauses based on candidate rewrites

    sygusRewSynthCheck
        (bool, default = false)
        use satisfiability check to verify correctness of candidate rewrites

    sygusRewSynthFilterCong
        (bool, default = true)
        filter candidate rewrites based on congruence

    sygusRewSynthFilterMatch
        (bool, default = true)
        filter candidate rewrites based on matching

    sygusRewSynthFilterOrder
        (bool, default = true)
        filter candidate rewrites based on variable ordering

    sygusRewVerify
        (bool, default = false)
        use sygus to verify the correctness of rewrite rules via sampling

    sygusRewVerifyAbort
        (bool, default = true)
        abort when sygus-rr-verify finds an instance of unsoundness

    sygusSampleGrammar
        (bool, default = true)
        when applicable, use grammar for choosing sample points

    sygusSamples
        (int, default = 1000)
        number of points to consider when doing sygus rewriter sample testing

    sygusStream
        (bool, default = false)
        enumerate a stream of solutions instead of terminating after the first one

    sygusTemplEmbedGrammar
        (bool, default = false)
        embed sygus templates into grammars

    sygusUnif
        (bool, default = false)
        Unification-based function synthesis

    termDbMode
        (CVC4::theory::quantifiers::TermDbMode, default = CVC4::theory::quantifiers::TERM_DB_ALL)
        which ground terms to consider for instantiation

    trackInstLemmas
        (bool, default = false)
        track instantiation lemmas (for proofs, unsat cores, qe and synthesis minimization)

    triggerActiveSelMode
        (CVC4::theory::quantifiers::TriggerActiveSelMode, default = CVC4::theory::quantifiers::TRIGGER_ACTIVE_SEL_ALL)
        selection mode to activate triggers

    triggerSelMode
        (CVC4::theory::quantifiers::TriggerSelMode, default = CVC4::theory::quantifiers::TRIGGER_SEL_MIN)
        selection mode for triggers

    userPatternsQuant
        (CVC4::theory::quantifiers::UserPatMode, default = CVC4::theory::quantifiers::USER_PAT_MODE_TRUST)
        policy for handling user-provided patterns for quantifier instantiation

    varElimQuant
        (bool, default = true)
        enable simple variable elimination for quantified formulas

    varIneqElimQuant
        (bool, default = true)
        enable variable elimination based on infinite projection of unbound arithmetic variables

    SEP OPTIONS

    sepCheckNeg
        (bool, default = true)
        check negated spatial assertions

    sepChildRefine
        (bool, default = false)
        child-specific refinements of negated star, positive wand

    sepDisequalC
        (bool, default = true)
        assume cardinality elements are distinct

    sepExp
        (bool, default = false)
        experimental flag for sep

    sepMinimalRefine
        (bool, default = false)
        only add refinement lemmas for minimal (innermost) assertions

    sepPreSkolemEmp
        (bool, default = false)
        eliminate emp constraint at preprocess time

    SETS OPTIONS

    setsExt
        (bool, default = false)
        enable extended symbols such as complement and universe in theory of sets

    setsInferAsLemmas
        (bool, default = true)
        send inferences as lemmas

    setsProxyLemmas
        (bool, default = false)
        introduce proxy variables eagerly to shorten lemmas

    setsRelEager
        (bool, default = true)
        standard effort checks for relations

    SMT LAYER OPTIONS

    abstractValues
        (bool, default = false)
        in models, output arrays (and in future, maybe others) using abstract values, as required by the SMT-LIB standard

    bitblastStep
        (unsigned, default = 1)
        amount of resources spent for each bitblast step (EXPERTS only)

    bvSatConflictStep
        (unsigned, default = 1)
        amount of resources spent for each sat conflict (bitvectors) (EXPERTS only)

    checkModels
        (bool)
        after SAT/INVALID/UNKNOWN, check that the generated model satisfies user assertions

    checkProofs
        (bool)
        after UNSAT/VALID, machine-check the generated proof

    checkSynthSol
        (bool, default = false)
        checks whether produced solutions to functions-to-synthesize satisfy the conjecture

    checkUnsatCores
        (bool)
        after UNSAT/VALID, produce and check an unsat core (expensive)

    cnfStep
        (unsigned, default = 1)
        amount of resources spent for each call to cnf conversion (EXPERTS only)

    decisionStep
        (unsigned, default = 1)
        amount of getNext decision calls in the decision engine (EXPERTS only)

    diagnosticChannelName
        (std::string)
        set the diagnostic output channel of the solver

    dumpInstantiations
        (bool, default = false)
        output instantiations of quantified formulas after every UNSAT/VALID response

    dumpModels
        (bool, default = false)
        output models after every SAT/INVALID/UNKNOWN response

    dumpProofs
        (bool, default = false)
        output proofs after every UNSAT/VALID response

    dumpSynth
        (bool, default = false)
        output solution for synthesis conjectures after every UNSAT/VALID response

    dumpUnsatCores
        (bool, default = false)
        output unsat cores after every UNSAT/VALID response

    dumpUnsatCoresFull
        (bool, default = false)
        dump the full unsat core, including unlabeled assertions

    expandDefinitions
        (bool, default = false)
        always expand symbol definitions in output

    extRewPrep
        (bool, default = false)
        use extended rewriter as a preprocessing pass

    extRewPrepAgg
        (bool, default = false)
        use aggressive extended rewriter as a preprocessing pass

    forceLogicString
        (std::string)
        set the logic, and override all further user attempts to change it (EXPERTS only)

    forceNoLimitCpuWhileDump
        (bool, default = false)
        Force no CPU limit when dumping models and proofs

    interactiveMode
        (bool)
        deprecated name for produce-assertions

    doITESimp
        (bool)
        turn on ite simplification (Kim (and Somenzi) et al., SAT 2009)

    lemmaStep
        (unsigned, default = 1)
        amount of resources spent when adding lemmas (EXPERTS only)

    modelUninterpDtEnum
        (bool, default = false)
        in models, output uninterpreted sorts as datatype enumerations

    omitDontCares
        (bool, default = false)
        When producing a model, omit variables whose value does not matter

    doITESimpOnRepeat
        (bool, default = false)
        do the ite simplification pass again if repeating simplification

    parseStep
        (unsigned, default = 1)
        amount of resources spent for each command/expression parsing (EXPERTS only)

    preprocessStep
        (unsigned, default = 1)
        amount of resources spent for each preprocessing step in SmtEngine (EXPERTS only)

    produceAssignments
        (bool, default = false)
        support the get-assignment command

    unsatAssumptions
        (bool, default = false)
        turn on unsat assumptions generation

    unsatCores
        (bool)
        turn on unsat core generation

    proof
        (bool, default = false)
        turn on proof generation

    quantifierStep
        (unsigned, default = 1)
        amount of resources spent for quantifier instantiations (EXPERTS only)

    regularChannelName
        (std::string)
        set the regular output channel of the solver

    repeatSimp
        (bool)
        make multiple passes with nonclausal simplifier

    replayLogFilename
        (std::string)
        replay decisions from file

    replayInputFilename
        (std::string)
        replay decisions from file

    restartStep
        (unsigned, default = 1)
        amount of resources spent for each theory restart (EXPERTS only)

    rewriteApplyToConst
        (bool, default = false)
        eliminate function applications, rewriting e.g. f(5) to a new symbol f_5 (EXPERTS only)

    rewriteStep
        (unsigned, default = 1)
        amount of resources spent for each rewrite step (EXPERTS only)

    satConflictStep
        (unsigned, default = 1)
        amount of resources spent for each sat conflict (main sat solver) (EXPERTS only)

    compressItes
        (bool, default = false)
        enables compressing ites after ite simplification

    zombieHuntThreshold
        (uint32_t, default = 524288)
        post ite compression enables zombie removal while the number of nodes is above this threshold

    simplifyWithCareEnabled
        (bool, default = false)
        enables simplifyWithCare in ite simplificiation

    simplificationMode
        (SimplificationMode, default = SIMPLIFICATION_MODE_BATCH)
        choose simplification mode, see --simplification=help

    solveIntAsBV
        (uint32_t, default = 0)
        attempt to solve a pure integer satisfiable problem by bitblasting in sufficient bitwidth (experimental)

    solveRealAsInt
        (bool, default = false)
        attempt to solve a pure real satisfiable problem as an integer problem (for non-linear)

    sortInference
        (bool, default = false)
        calculate sort inference of input problem, convert the input based on monotonic sorts

    doStaticLearning
        (bool, default = true)
        use static learning (on by default)

    sygusOut
        (SygusSolutionOutMode, default = SYGUS_SOL_OUT_STATUS_AND_DEF)
        output mode for sygus

    sygusPrintCallbacks
        (bool, default = true)
        use sygus print callbacks to print sygus terms in the user-provided form (disable for debugging)

    symmetryBreakerExp
        (bool, default = false)
        generate symmetry breaking constraints after symmetry detection

    theoryCheckStep
        (unsigned, default = 1)
        amount of resources spent for each theory check call (EXPERTS only)

    unconstrainedSimp
        (bool, default = false)
        turn on unconstrained simplification (see Bruttomesso/Brummayer PhD thesis)

    STRINGS THEORY OPTIONS

    stringAbortLoop
        (bool, default = false)
        abort when a looping word equation is encountered

    stringBinaryCsp
        (bool, default = false)
        use binary search when splitting strings

    stringCheckEntailLen
        (bool, default = true)
        check entailment between length terms to reduce splitting

    stringEager
        (bool, default = false)
        strings eager check

    stringEagerLen
        (bool, default = true)
        strings eager length lemmas

    stringEIT
        (bool, default = false)
        the eager intersection used by the theory of strings

    stringExp
        (bool, default = false)
        experimental features in the theory of strings

    stringFMF
        (bool, default = false)
        the finite model finding used by the theory of strings

    stringGuessModel
        (bool, default = false)
        use model guessing to avoid string extended function reductions

    stringInferAsLemmas
        (bool, default = false)
        always send lemmas out instead of making internal inferences

    stringInferSym
        (bool, default = true)
        strings split on empty string

    stringIgnNegMembership
        (bool, default = false)
        internal for strings: ignore negative membership constraints (fragment checking is needed, left to users for now)

    stringLazyPreproc
        (bool, default = true)
        perform string preprocessing lazily

    stringLB
        (unsigned, default = 0)
        the strategy of LB rule application: 0-lazy, 1-eager, 2-no

    stringLenGeqZ
        (bool, default = false)
        strings length greater than zero lemmas

    stringLenNorm
        (bool, default = true)
        strings length normalization lemma

    stringLenPropCsp
        (bool, default = false)
        do length propagation based on constant splits

    stringMinPrefixExplain
        (bool, default = true)
        minimize explanations for prefix of normal forms in strings

    stringOpt1
        (bool, default = true)
        internal option1 for strings: normal form

    stringOpt2
        (bool, default = false)
        internal option2 for strings: constant regexp splitting

    stdPrintASCII
        (bool, default = false)
        the alphabet contains only printable characters from the standard extended ASCII

    stringProcessLoop
        (bool, default = true)
        reduce looping word equations to regular expressions

    stringRExplainLemmas
        (bool, default = true)
        regression explanations for string lemmas

    stringSplitEmp
        (bool, default = true)
        strings split on empty string

    stringUfReduct
        (bool, default = false)
        use uninterpreted functions when applying extended function reductions

    THEORY LAYER OPTIONS

    assignFunctionValues
        (bool, default = true)
        assign values for uninterpreted functions in models

    condenseFunctionValues
        (bool, default = true)
        condense values for functions in models rather than explicitly representing them

    theoryOfMode
        (CVC4::theory::TheoryOfMode, default = CVC4::theory::THEORY_OF_TYPE_BASED)
        mode for Theory::theoryof() (EXPERTS only)

    useTheoryList
        (std::string)
        use alternate theory implementation NAME (--use-theory=help for a list). This option may be repeated or a comma separated list.

    UNINTERPRETED FUNCTIONS THEORY OPTIONS

    ufSymmetryBreaker
        (bool, default = true)
        use UF symmetry breaker (Deharbe et al., CADE 2011)

    ufHo
        (bool, default = false)
        enable support for higher-order reasoning

    ufHoExt
        (bool, default = true)
        apply extensionality on function symbols

    ufssAbortCardinality
        (int, default = -1)
        tells the uf strong solver to only consider models that interpret uninterpreted sorts of cardinality at most N (-1 == no limit, default)

    ufssCliqueSplits
        (bool, default = false)
        use cliques instead of splitting on demand to shrink model

    ufssEagerSplits
        (bool, default = false)
        add splits eagerly for uf strong solver

    ufssFairness
        (bool, default = true)
        use fair strategy for finite model finding multiple sorts

    ufssFairnessMonotone
        (bool, default = false)
        group monotone sorts when enforcing fairness for finite model finding

    ufssRegions
        (bool, default = true)
        disable region-based method for discovering cliques and splits in uf strong solver

    ufssTotality
        (bool, default = false)
        always use totality axioms for enforcing cardinality constraints

    ufssTotalityLimited
        (int, default = -1)
        apply totality axioms, but only up to cardinality N (-1 == do not apply totality axioms, default)

    ufssTotalitySymBreak
        (bool, default = false)
        apply symmetry breaking for totality axioms

    ufssMode
        (CVC4::theory::uf::UfssMode, default = CVC4::theory::uf::UF_SS_FULL)
        mode of operation for uf strong solver.

VERSION
This manual page refers to CVC4 version 1.6.

BUGS
An issue tracker for the CVC4 project is maintained at https://github.com/CVC4/CVC4/issues.

AUTHORS
CVC4 is developed by a team of researchers at Stanford University and the University of Iowa. See the AUTHORS file in the distribution for a full list of contributors.

SEE ALSO
libcvc4(3), libcvc4parser(3), libcvc4compat(3) Additionally, the CVC4 wiki contains useful information about the design and internals of CVC4. It is maintained at http://cvc4.cs.stanford.edu/wiki/.