cvc4 man page

cvc4, pcvc4 — an automated theorem prover

Synopsis

cvc4 [ options ] [ file ]

pcvc4 [ options ] [ file ]

Description

cvc4 is an automated theorem prover for first-order formulas with respect to background theories of interest. pcvc4 is CVC4's "portfolio" variant, which is capable of running multiple CVC4 instances in parallel, configured differently.

With file , commands are read from file and executed.  CVC4 supports the SMT-LIB (versions 1.2 and 2.0) input format, as well as its own native “presentation language” (see cvc4(5) ), which is similar in many respects to CVC3's presentation language, but not identical.

If file is unspecified, standard input is read (and the CVC4 presentation language is assumed).  If file is unspecified and CVC4 is connected to a terminal, interactive mode is assumed.

Common Options

Each option marked with [*] has a --no-OPTIONNAME variant, which reverses the sense of the option.
--lang=LANG | -L LANG

force input language (default is "auto"; see --lang help)

--output-lang=LANG

force output language (default is "auto"; see --output-lang help)

--quiet | -q

decrease verbosity (may be repeated)

--stats

give statistics on exit [*]

--verbose | -v

increase verbosity (may be repeated)

--copyright

show CVC4 copyright information

--help | -h

full command line reference

--seed | -s

seed for random number generator

--show-config

show CVC4 static configuration

--version | -V

identify this CVC4 binary

--strict-parsing

be less tolerant of non-conforming inputs [*]

--cpu-time

measures CPU time if set to true and wall time if false (default false) [*]

--dump-to=FILE

all dumping goes to FILE (instead of stdout)

--dump=MODE

dump preprocessed assertions, etc., see --dump=help

--hard-limit

the resource limit is hard potentially leaving the smtEngine in an unsafe state (should be destroyed and rebuild after resourcing out) [*]

--incremental | -i

enable incremental solving [*]

--produce-assertions

keep an assertions list (enables get-assertions command) [*]

--produce-models | -m

support the get-value and get-model commands [*]

--rlimit-per=N

enable resource limiting per query

--rlimit=N

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

--tlimit-per=MS

enable time limiting per query (give milliseconds)

--tlimit=MS

enable time limiting (give milliseconds)

Arithmetic Theory Options

--approx-branch-depth

maximum branch depth the approximate solver is allowed to take

--arith-no-partial-fun

do not use partial function semantics for arithmetic (not SMT LIB compliant) [*]

--arith-prop-clauses

rows shorter than this are propagated as clauses

--arith-prop=MODE

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

--arith-rewrite-equalities

turns on the preprocessing rewrite turning equalities into a conjunction of inequalities [*]

--collect-pivot-stats

collect the pivot history [*]

--cut-all-bounded

turns on the integer solving step of periodically cutting all integer variables that have both upper and lower bounds [*]

--dio-decomps

let skolem variables for integer divisibility constraints leak from the dio solver [*]

--dio-repeat

handle dio solver constraints in mass or one at a time [*]

--dio-solver

turns on Linear Diophantine Equation solver (Griggio, JSAT 2012) [*]

--dio-turns

turns in a row dio solver cutting gets

--error-selection-rule=RULE

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

--fc-penalties

turns on degenerate pivot penalties [*]

--heuristic-pivots=N

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

--lemmas-on-replay-failure

attempt to use external lemmas if approximate solve integer failed [*]

--maxCutsInContext

maximum cuts in a given context before signalling a restart

--miplib-trick

turns on the preprocessing step of attempting to infer bounds on miplib problems [*]

--miplib-trick-subs=N

do substitution for miplib 'tmp' vars if defined in <= N eliminated vars

--new-prop

use the new row propagation system [*]

--nl-ext

extended approach to non-linear [*]

--nl-ext-ent-conf

check for entailed conflicts in non-linear solver [*]

--nl-ext-factor

use factoring inference in non-linear solver [*]

--nl-ext-inc-prec

whether to increment the precision for irrational function constraints [*]

--nl-ext-purify

purify non-linear terms at preprocess [*]

--nl-ext-rbound

use resolution-style inference for inferring new bounds [*]

--nl-ext-rewrite

do rewrites in non-linear solver [*]

--nl-ext-split-zero

intial splits on zero for all variables [*]

--nl-ext-tf-taylor-deg=N

initial degree of polynomials for Taylor approximation

--nl-ext-tf-tplanes

use non-terminating tangent plane strategy for transcendental functions for non-linear [*]

--nl-ext-tplanes

use non-terminating tangent plane strategy for non-linear [*]

--nl-ext-tplanes-interleave

interleave tangent plane strategy for non-linear [*]

--pb-rewrites

apply pseudo boolean rewrites [*]

--pivot-threshold=N

sets the number of pivots using --pivot-rule per basic variable per simplex instance before using variable order

--pp-assert-max-sub-size

threshold for substituting an equality in ppAssert

--prop-row-length=N

sets the maximum row length to be used in propagation

--replay-early-close-depth

multiples of the depths to try to close the approx log eagerly

--replay-failure-penalty

number of solve integer attempts to skips after a numeric failure

--replay-lemma-reject-cut

maximum complexity of any coefficient while outputting replaying cut lemmas

--replay-num-err-penalty

number of solve integer attempts to skips after a numeric failure

--replay-reject-cut

maximum complexity of any coefficient while replaying cuts

--replay-soi-major-threshold

threshold for a major tolerance failure by the approximate solver

--replay-soi-major-threshold-pen

threshold for a major tolerance failure by the approximate solver

--replay-soi-minor-threshold

threshold for a minor tolerance failure by the approximate solver

--replay-soi-minor-threshold-pen

threshold for a minor tolerance failure by the approximate solver

--restrict-pivots

have a pivot cap for simplex at effort levels below fullEffort [*]

--revert-arith-models-on-unsat

revert the arithmetic model to a known safe model on unsat if one is cached [*]

--rewrite-divk

rewrite division and mod when by a constant into linear terms [*]

--rr-turns

round robin turn

--se-solve-int

attempt to use the approximate solve integer method on standard effort [*]

--simplex-check-period=N

the number of pivots to do in simplex before rechecking for a conflict on all variables

--snorm-infer-eq

infer equalities based on Shostak normalization [*]

--soi-qe

use quick explain to minimize the sum of infeasibility conflicts [*]

--standard-effort-variable-order-pivots=N

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

--unate-lemmas=MODE

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

--use-approx

attempt to use an approximate solver [*]

--use-fcsimplex

use focusing and converging simplex (FMCAD 2013 submission) [*]

--use-soi

use sum of infeasibility simplex (FMCAD 2013 submission) [*]

Arrays Theory Options

--arrays-config

set different array option configurations - for developers only

--arrays-eager-index

turn on eager index splitting for generated array lemmas [*]

--arrays-eager-lemmas

turn on eager lemma generation for arrays [*]

--arrays-lazy-rintro1

turn on optimization to only perform RIntro1 rule lazily (see Jovanovic/Barrett 2012: Being Careful with Theory Combination) [*]

--arrays-model-based

turn on model-based array solver [*]

--arrays-optimize-linear

turn on optimization for linear array terms (see de Moura FMCAD 09 arrays paper) [*]

--arrays-prop

propagation effort for arrays: 0 is none, 1 is some, 2 is full

--arrays-reduce-sharing

use model information to reduce size of care graph for arrays [*]

--arrays-weak-equiv

use algorithm from Christ/Hoenicke (SMT 2014) [*]

Base Options

--debug=TAG | -d TAG

debug something (e.g. -d arith), can repeat

--parse-only

exit after parsing input [*]

--preprocess-only

exit after preprocessing input [*]

--print-success

print the "success" output required of SMT-LIBv2 [*]

--stats-every-query

in incremental mode, print stats after every satisfiability or validity query [*]

--stats-hide-zeros

hide statistics which are zero [*]

--trace=TAG | -t TAG

trace something (e.g. -t pushpop), can repeat

--smtlib-strict

SMT-LIBv2 compliance mode (implies other options)

Bitvector Theory Options

--bitblast-aig

bitblast by first converting to AIG (implies --bitblast=eager) [*]

--bitblast=MODE

choose bitblasting mode, see --bitblast=help

--bool-to-bv

convert booleans to bit-vectors of size 1 when possible [*]

--bv-abstraction

mcm benchmark abstraction (EXPERTS only) [*]

--bv-aig-simp=COMMAND

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

--bv-alg-extf

algebraic inferences for extended functions [*]

--bv-algebraic-budget

the budget allowed for the algebraic solver in number of SAT conflicts (EXPERTS only)

--bv-algebraic-solver

turn on the algebraic solver for the bit-vector theory (only if --bitblast=lazy) [*]

--bv-div-zero-const

always return -1 on division by zero [*]

--bv-eager-explanations

compute bit-blasting propagation explanations eagerly (EXPERTS only) [*]

--bv-eq-slicer=MODE

turn on the slicing equality solver for the bit-vector theory (only if --bitblast=lazy)

--bv-eq-solver

use the equality engine for the bit-vector theory (only if --bitblast=lazy) [*]

--bv-extract-arith

enable rewrite pushing extract [i:0] over arithmetic operations (can blow up) (EXPERTS only) [*]

--bv-gauss-elim

simplify formula via Gaussian Elimination if applicable (EXPERTS only) [*]

--bv-inequality-solver

turn on the inequality solver for the bit-vector theory (only if --bitblast=lazy) [*]

--bv-intro-pow2

introduce bitvector powers of two as a preprocessing pass (EXPERTS only) [*]

--bv-lazy-reduce-extf

reduce extended functions like bv2nat and int2bv at last call instead of full effort [*]

--bv-lazy-rewrite-extf

lazily rewrite extended functions like bv2nat and int2bv [*]

--bv-num-func=NUM

number of function symbols in conflicts that are generalized (EXPERTS only)

--bv-propagate

use bit-vector propagation in the bit-blaster [*]

--bv-quick-xplain

minimize bv conflicts using the QuickXplain algorithm (EXPERTS only) [*]

--bv-sat-solver=MODE

choose which sat solver to use, see --bv-sat-solver=help (EXPERTS only)

--bv-skolemize

skolemize arguments for bv abstraction (only does something if --bv-abstraction is on) (EXPERTS only) [*]

--bv-to-bool

lift bit-vectors of size 1 to booleans when possible [*]

Datatypes Theory Options

--cdt-bisimilar

do bisimilarity check for co-datatypes [*]

--dt-binary-split

do binary splits for datatype constructor types [*]

--dt-blast-splits

when applicable, blast splitting lemmas for all variables at once [*]

--dt-cyclic

do cyclicity check for datatypes [*]

--dt-force-assignment

force the datatypes solver to give specific values to all datatypes terms before answering sat [*]

--dt-infer-as-lemmas

always send lemmas out instead of making internal inferences [*]

--dt-ref-sk-intro

introduce reference skolems for shorter explanations [*]

--dt-rewrite-error-sel

rewrite incorrectly applied selectors to arbitrary ground term (EXPERTS only) [*]

--dt-share-sel

internally use shared selectors across multiple constructors [*]

--dt-use-testers

do not preprocess away tester predicates [*]

--sygus-abort-size=N

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

--sygus-eval-builtin

use builtin kind for evaluation functions in sygus [*]

--sygus-fair-max

use max instead of sum for multi-function sygus conjectures [*]

--sygus-fair=MODE

if and how to apply fairness for sygus

--sygus-opt1

sygus experimental option [*]

--sygus-sym-break

simple sygus sym break lemmas [*]

--sygus-sym-break-dynamic

dynamic sygus sym break lemmas [*]

--sygus-sym-break-lazy

lazily add symmetry breaking lemmas for terms [*]

--sygus-sym-break-pbe

sygus sym break lemmas based on pbe conjectures [*]

--sygus-sym-break-rlv

add relevancy conditions to symmetry breaking lemmas [*]

Decision Heuristics Options

--decision-random-weight=N

assign random weights to nodes between 0 and N-1 (0: disable) (EXPERTS only)

--decision-threshold=N

ignore all nodes greater than threshold in first attempt to pick decision (EXPERTS only)

--decision-use-weight

use the weight nodes (locally, by looking at children) to direct recursive search (EXPERTS only) [*]

--decision-weight-internal=HOW

computer weights of internal nodes using children: off, max, sum, usr1 (meaning evolving) (EXPERTS only)

--decision=MODE

choose decision mode, see --decision=help

Expression Package Options

--default-dag-thresh=N

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

--default-expr-depth=N

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

--eager-type-checking

type check expressions immediately on creation (debug builds only) [*]

--print-expr-types

print types with variables when printing exprs [*]

--type-checking

never type check expressions

Idl Options

--idl-rewrite-equalities

enable rewriting equalities into two inequalities in IDL solver (default is disabled) [*]

Driver Options

--continued-execution

continue executing commands, even on error [*]

--early-exit

do not run destructors at exit; default on except in debug builds (EXPERTS only) [*]

--fallback-sequential

Switch to sequential mode (instead of printing an error) if it can't be solved in portfolio mode [*]

--filter-lemma-length=N

don't share (among portfolio threads) lemmas strictly longer than N

--incremental-parallel

Use parallel solver even in incremental mode (may print 'unknown's at times) [*]

--interactive

force interactive/non-interactive mode [*]

--segv-spin

spin on segfault/other crash waiting for gdb [*]

--show-debug-tags

show all available tags for debugging

--show-trace-tags

show all available tags for tracing

--tear-down-incremental=N

implement PUSH/POP/multi-query by destroying and recreating SmtEngine every N queries (EXPERTS only)

--thread-stack=N

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

--threadN=string

configures portfolio thread N (0..#threads-1)

--threads=N

Total number of threads for portfolio

--wait-to-join

wait for other threads to join before quitting (EXPERTS only) [*]

Parser Options

--mmap

memory map file input [*]

Printing Options

--inst-format=MODE

print format mode for instantiations, see --inst-format=help

--model-format=MODE

print format mode for models, see --model-format=help

Proof Options

--aggressive-core-min

turns on aggressive unsat core minimization (experimental) [*]

--allow-empty-dependencies

if unable to track the dependencies of a rewritten/preprocessed assertion, fail silently [*]

--fewer-preprocessing-holes

try to eliminate preprocessing holes in proofs [*]

--lfsc-letification

turns on global letification in LFSC proofs [*]

Sat Layer Options

--minisat-dump-dimacs

instead of solving minisat dumps the asserted clauses in Dimacs format [*]

--minisat-elimination

use Minisat elimination [*]

--random-freq=P

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

--random-seed=S

sets the random seed for the sat solver

--refine-conflicts

refine theory conflict clauses (default false) [*]

--restart-int-base=N

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

--restart-int-inc=F

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

Quantifiers Options

--ag-miniscope-quant

perform aggressive miniscoping for quantifiers [*]

--cbqi

turns on counterexample-based quantifier instantiation [*]

--cbqi-all

apply counterexample-based instantiation to all quantified formulas [*]

--cbqi-bv

use word-level inversion approach for counterexample-guided quantifier instantiation for bit-vectors [*]

--cbqi-bv-concat-inv

compute inverse for concat over equalities rather than producing an invertibility condition [*]

--cbqi-bv-ineq=MODE

choose mode for handling bit-vector inequalities with counterexample-guided instantiation

--cbqi-bv-interleave-value

interleave model value instantiation with word-level inversion approach [*]

--cbqi-bv-linear

linearize adder chains for variables [*]

--cbqi-bv-rm-extract

replaces extract terms with variables for counterexample-guided instantiation for bit-vectors [*]

--cbqi-bv-solve-nl

try to solve non-linear bv literals using model value projections [*]

--cbqi-full

turns on full effort counterexample-based quantifier instantiation, which may resort to model-value instantiation [*]

--cbqi-innermost

only process innermost quantified formulas in counterexample-based quantifier instantiation [*]

--cbqi-lit-dep

dependency lemmas for quantifier alternation in counterexample-based quantifier instantiation [*]

--cbqi-midpoint

choose substitutions based on midpoints of lower and upper bounds for counterexample-based quantifier instantiation [*]

--cbqi-min-bounds

use minimally constrained lower/upper bound for counterexample-based quantifier instantiation [*]

--cbqi-model

guide instantiations by model values for counterexample-based quantifier instantiation [*]

--cbqi-multi-inst

when applicable, do multi instantiations per quantifier per round in counterexample-based quantifier instantiation [*]

--cbqi-nested-qe

process nested quantified formulas with quantifier elimination in counterexample-based quantifier instantiation [*]

--cbqi-nopt

non-optimal bounds for counterexample-based quantifier instantiation [*]

--cbqi-prereg-inst

preregister ground instantiations in counterexample-based quantifier instantiation [*]

--cbqi-recurse

turns on recursive counterexample-based quantifier instantiation [*]

--cbqi-repeat-lit

solve literals more than once in counterexample-based quantifier instantiation [*]

--cbqi-round-up-lia

round up integer lower bounds in substitutions for counterexample-based quantifier instantiation [*]

--cbqi-sat

answer sat when quantifiers are asserted with counterexample-based quantifier instantiation [*]

--cbqi-use-inf-int

use integer infinity for vts in counterexample-based quantifier instantiation [*]

--cbqi-use-inf-real

use real infinity for vts in counterexample-based quantifier instantiation [*]

--cegis-sample=MODE

mode for using samples in the counterexample-guided inductive synthesis loop

--cegqi

counterexample-guided quantifier instantiation for sygus [*]

--cegqi-si-abort

abort if synthesis conjecture is not single invocation [*]

--cegqi-si-partial

combined techniques for synthesis conjectures that are partially single invocation [*]

--cegqi-si-reconstruct

reconstruct solutions for single invocation conjectures in original grammar [*]

--cegqi-si-reconstruct-const

include constants when reconstruct solutions for single invocation conjectures in original grammar [*]

--cegqi-si-sol-min-core

minimize solutions for single invocation conjectures based on unsat core [*]

--cegqi-si-sol-min-inst

minimize individual instantiations for single invocation conjectures based on unsat core [*]

--cegqi-si=MODE

mode for processing single invocation synthesis conjectures

--cond-rewrite-quant

conditional rewriting of quantified formulas [*]

--cond-var-split-agg-quant

aggressive split quantified formulas that lead to variable eliminations [*]

--cond-var-split-quant

split quantified formulas that lead to variable eliminations [*]

--conjecture-filter-active-terms

filter based on active terms [*]

--conjecture-filter-canonical

filter based on canonicity [*]

--conjecture-filter-model

filter based on model [*]

--conjecture-gen

generate candidate conjectures for inductive proofs [*]

--conjecture-gen-gt-enum=N

number of ground terms to generate for model filtering

--conjecture-gen-max-depth=N

maximum depth of terms to consider for conjectures

--conjecture-gen-per-round=N

number of conjectures to generate per instantiation round

--conjecture-gen-uee-intro

more aggressive merging for universal equality engine, introduces terms [*]

--conjecture-no-filter

do not filter conjectures [*]

--dt-stc-ind

apply strengthening for existential quantification over datatypes based on structural induction [*]

--dt-var-exp-quant

expand datatype variables bound to one constructor in quantifiers [*]

--e-matching

whether to do heuristic E-matching [*]

--elim-ext-arith-quant

eliminate extended arithmetic symbols in quantified formulas [*]

--elim-taut-quant

eliminate tautological disjuncts of quantified formulas [*]

--finite-model-find

use finite model finding heuristic for quantifier instantiation [*]

--fmf-bound

finite model finding on bounded quantification [*]

--fmf-bound-int

finite model finding on bounded integer quantification [*]

--fmf-bound-lazy

enforce bounds for bounded quantification lazily via use of proxy variables [*]

--fmf-bound-min-mode=MODE

mode for which types of bounds to minimize via first decision heuristics

--fmf-empty-sorts

allow finite model finding to assume sorts that do not occur in ground assertions are empty [*]

--fmf-fmc-simple

simple models in full model check for finite model finding [*]

--fmf-fresh-dc

use fresh distinguished representative when applying Inst-Gen techniques [*]

--fmf-fun

find models for recursively defined functions, assumes functions are admissible [*]

--fmf-fun-rlv

find models for recursively defined functions, assumes functions are admissible, allows empty type when function is irrelevant [*]

--fmf-inst-engine

use instantiation engine in conjunction with finite model finding [*]

--fmf-inst-gen

enable Inst-Gen instantiation techniques for finite model finding [*]

--fmf-inst-gen-one-quant-per-round

only perform Inst-Gen instantiation techniques on one quantifier per round [*]

--fs-interleave

interleave full saturate instantiation with other techniques [*]

--full-saturate-quant

when all other quantifier instantiation strategies fail, instantiate with ground terms from relevant domain, then arbitrary ground terms before answering unknown [*]

--full-saturate-quant-rd

whether to use relevant domain first for full saturation instantiation strategy [*]

--global-negate

do global negation of input formula [*]

--ho-matching

do higher-order matching algorithm for triggers with variable operators [*]

--ho-matching-var-priority

give priority to variable arguments over constant arguments [*]

--ho-merge-term-db

merge term indices modulo equality [*]

--increment-triggers

generate additional triggers as needed during search [*]

--infer-arith-trigger-eq

infer equalities for trigger terms based on solving arithmetic equalities [*]

--infer-arith-trigger-eq-exp

record explanations for inferArithTriggerEq [*]

--inst-level-input-only

only input terms are assigned instantiation level zero [*]

--inst-max-level=N

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

--inst-no-entail

do not consider instances of quantified formulas that are currently entailed [*]

--inst-no-model-true

do not consider instances of quantified formulas that are currently true in model, if it is available [*]

--inst-prop

internal propagation for instantiations for selecting relevant instances [*]

--inst-when-phase=N

instantiation rounds quantifiers takes (>=1) before allowing theory combination to happen

--inst-when-strict-interleave

ensure theory combination and standard quantifier effort strategies take turns [*]

--inst-when-tc-first

allow theory combination to happen once initially, before quantifier strategies are run [*]

--inst-when=MODE

when to apply instantiation

--int-wf-ind

apply strengthening for integers based on well-founded induction [*]

--ite-dtt-split-quant

split ites with dt testers as conditions [*]

--ite-lift-quant=MODE

ite lifting mode for quantified formulas

--literal-matching=MODE

choose literal matching mode

--local-t-ext

do instantiation based on local theory extensions [*]

--lte-partial-inst

partially instantiate local theory quantifiers [*]

--lte-restrict-inst-closure

treat arguments of inst closure as restricted terms for instantiation [*]

--macros-quant

perform quantifiers macro expansion [*]

--macros-quant-mode=MODE

mode for quantifiers macro expansion

--mbqi-interleave

interleave model-based quantifier instantiation with other techniques [*]

--mbqi-one-inst-per-round

only add one instantiation per quantifier per round for mbqi [*]

--mbqi-one-quant-per-round

only add instantiations for one quantifier per round for mbqi [*]

--mbqi=MODE

choose mode for model-based quantifier instantiation

--miniscope-quant

miniscope quantifiers [*]

--miniscope-quant-fv

miniscope quantifiers for ground subformulas [*]

--multi-trigger-cache

caching version of multi triggers [*]

--multi-trigger-linear

implementation of multi triggers where maximum number of instantiations is linear wrt number of ground terms [*]

--multi-trigger-priority

only try multi triggers if single triggers give no instantiations [*]

--multi-trigger-when-single

select multi triggers when single triggers exist [*]

--partial-triggers

use triggers that do not contain all free variables [*]

--pre-skolem-quant

apply skolemization eagerly to bodies of quantified formulas [*]

--pre-skolem-quant-agg

apply skolemization to quantified formulas aggressively [*]

--pre-skolem-quant-nested

apply skolemization to nested quantified formulas [*]

--prenex-quant-user

prenex quantified formulas with user patterns [*]

--prenex-quant=MODE

prenex mode for quantified formulas

--pure-th-triggers

use pure theory terms as single triggers [*]

--purify-dt-triggers

purify dt triggers, match all constructors of correct form instead of selectors [*]

--purify-triggers

purify triggers, e.g. f( x+1 ) becomes f( y ), x mapsto y-1 [*]

--qcf-all-conflict

add all available conflicting instances during conflict-based instantiation [*]

--qcf-eager-check-rd

optimization, eagerly check relevant domain of matched position [*]

--qcf-eager-test

optimization, test qcf instances eagerly [*]

--qcf-nested-conflict

consider conflicts for nested quantifiers [*]

--qcf-skip-rd

optimization, skip instances based on possibly irrelevant portions of quantified formulas [*]

--qcf-tconstraint

enable entailment checks for t-constraints in qcf algorithm [*]

--qcf-vo-exp

qcf experimental variable ordering [*]

--quant-alpha-equiv

infer alpha equivalence between quantified formulas [*]

--quant-anti-skolem

perform anti-skolemization for quantified formulas [*]

--quant-cf

enable conflict find mechanism for quantifiers [*]

--quant-cf-mode=MODE

what effort to apply conflict find mechanism

--quant-cf-when=MODE

when to invoke conflict find mechanism for quantifiers

--quant-dsplit-mode=MODE

mode for dynamic quantifiers splitting

--quant-epr

infer whether in effectively propositional fragment, use for cbqi [*]

--quant-epr-match

use matching heuristics for EPR instantiation [*]

--quant-fun-wd

assume that function defined by quantifiers are well defined [*]

--quant-ind

use all available techniques for inductive reasoning [*]

--quant-model-ee

use equality engine of model for last call effort [*]

--quant-rep-mode=MODE

selection mode for representatives in quantifiers engine

--quant-split

apply splitting to quantified formulas based on variable disjoint disjuncts [*]

--register-quant-body-terms

consider ground terms within bodies of quantified formulas for matching [*]

--relational-triggers

choose relational triggers such as x = f(y), x >= f(y) [*]

--relevant-triggers

prefer triggers that are more relevant based on SInE style analysis [*]

--rewrite-rules

use rewrite rules module [*]

--rr-one-inst-per-round

add one instance of rewrite rule per round [*]

--strict-triggers

only instantiate quantifiers with user patterns based on triggers [*]

--sygus-add-const-grammar

statically add constants appearing in conjecture to grammars [*]

--sygus-auto-unfold

enable approach which automatically unfolds transition systems for directly solving invariant synthesis problems [*]

--sygus-bool-ite-return-const

Only use Boolean constants for return values in unification-based function synthesis [*]

--sygus-eval-unfold

do unfolding of sygus evaluation functions [*]

--sygus-eval-unfold-bool

do unfolding of Boolean evaluation functions that appear in refinement lemmas [*]

--sygus-ext-rew

use extended rewriter for sygus [*]

--sygus-grammar-norm

statically normalize sygus grammars based on flattening (linearization) [*]

--sygus-inference

attempt to preprocess arbitrary inputs to sygus conjectures [*]

--sygus-inv-templ-when-sg

use invariant templates (with solution reconstruction) for syntax guided problems [*]

--sygus-inv-templ=MODE

template mode for sygus invariant synthesis (weaken pre-condition, strengthen post-condition, or none)

--sygus-min-grammar

statically minimize sygus grammars [*]

--sygus-pbe

enable approach which unifies conditional solutions, specialized for programming-by-examples (pbe) conjectures [*]

--sygus-qe-preproc

use quantifier elimination as a preprocessing step for sygus [*]

--sygus-ref-eval

direct evaluation of refinement lemmas for conflict analysis [*]

--sygus-repair-const

use approach to repair constants in sygus candidate solutions [*]

--sygus-rr

use sygus to enumerate and verify correctness of rewrite rules via sampling [*]

--sygus-rr-synth

use sygus to enumerate candidate rewrite rules via sampling [*]

--sygus-rr-synth-accel

add dynamic symmetry breaking clauses based on candidate rewrites [*]

--sygus-rr-synth-check

use satisfiability check to verify correctness of candidate rewrites [*]

--sygus-rr-synth-filter-cong

filter candidate rewrites based on congruence [*]

--sygus-rr-synth-filter-match

filter candidate rewrites based on matching [*]

--sygus-rr-synth-filter-order

filter candidate rewrites based on variable ordering [*]

--sygus-rr-verify

use sygus to verify the correctness of rewrite rules via sampling [*]

--sygus-rr-verify-abort

abort when sygus-rr-verify finds an instance of unsoundness [*]

--sygus-sample-grammar

when applicable, use grammar for choosing sample points [*]

--sygus-samples=N

number of points to consider when doing sygus rewriter sample testing

--sygus-stream

enumerate a stream of solutions instead of terminating after the first one [*]

--sygus-templ-embed-grammar

embed sygus templates into grammars [*]

--sygus-unif

Unification-based function synthesis [*]

--term-db-mode

which ground terms to consider for instantiation

--track-inst-lemmas

track instantiation lemmas (for proofs, unsat cores, qe and synthesis minimization) [*]

--trigger-active-sel

selection mode to activate triggers

--trigger-sel

selection mode for triggers

--user-pat=MODE

policy for handling user-provided patterns for quantifier instantiation

--var-elim-quant

enable simple variable elimination for quantified formulas [*]

--var-ineq-elim-quant

enable variable elimination based on infinite projection of unbound arithmetic variables [*]

Sep Options

--sep-check-neg

check negated spatial assertions [*]

--sep-child-refine

child-specific refinements of negated star, positive wand [*]

--sep-deq-c

assume cardinality elements are distinct [*]

--sep-exp

experimental flag for sep [*]

--sep-min-refine

only add refinement lemmas for minimal (innermost) assertions [*]

--sep-pre-skolem-emp

eliminate emp constraint at preprocess time [*]

Sets Options

--sets-ext

enable extended symbols such as complement and universe in theory of sets [*]

--sets-infer-as-lemmas

send inferences as lemmas [*]

--sets-proxy-lemmas

introduce proxy variables eagerly to shorten lemmas [*]

--sets-rel-eager

standard effort checks for relations [*]

SMT Layer Options

--abstract-values

in models, output arrays (and in future, maybe others) using abstract values, as required by the SMT-LIB standard [*]

--bitblast-step

amount of resources spent for each bitblast step (EXPERTS only)

--bv-sat-conflict-step

amount of resources spent for each sat conflict (bitvectors) (EXPERTS only)

--check-models

after SAT/INVALID/UNKNOWN, check that the generated model satisfies user assertions [*]

--check-proofs

after UNSAT/VALID, machine-check the generated proof [*]

--check-synth-sol

checks whether produced solutions to functions-to-synthesize satisfy the conjecture [*]

--check-unsat-cores

after UNSAT/VALID, produce and check an unsat core (expensive) [*]

--cnf-step

amount of resources spent for each call to cnf conversion (EXPERTS only)

--decision-step

amount of getNext decision calls in the decision engine (EXPERTS only)

--dump-instantiations

output instantiations of quantified formulas after every UNSAT/VALID response [*]

--dump-models

output models after every SAT/INVALID/UNKNOWN response [*]

--dump-proofs

output proofs after every UNSAT/VALID response [*]

--dump-synth

output solution for synthesis conjectures after every UNSAT/VALID response [*]

--dump-unsat-cores

output unsat cores after every UNSAT/VALID response [*]

--dump-unsat-cores-full

dump the full unsat core, including unlabeled assertions [*]

--ext-rew-prep

use extended rewriter as a preprocessing pass [*]

--ext-rew-prep-agg

use aggressive extended rewriter as a preprocessing pass [*]

--force-logic=LOGIC

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

--force-no-limit-cpu-while-dump

Force no CPU limit when dumping models and proofs [*]

--ite-simp

turn on ite simplification (Kim (and Somenzi) et al., SAT 2009) [*]

--lemma-step

amount of resources spent when adding lemmas (EXPERTS only)

--model-u-dt-enum

in models, output uninterpreted sorts as datatype enumerations [*]

--omit-dont-cares

When producing a model, omit variables whose value does not matter [*]

--on-repeat-ite-simp

do the ite simplification pass again if repeating simplification [*]

--parse-step

amount of resources spent for each command/expression parsing (EXPERTS only)

--preprocess-step

amount of resources spent for each preprocessing step in SmtEngine (EXPERTS only)

--produce-assignments

support the get-assignment command [*]

--produce-unsat-assumptions

turn on unsat assumptions generation [*]

--produce-unsat-cores

turn on unsat core generation [*]

--proof

turn on proof generation [*]

--quantifier-step

amount of resources spent for quantifier instantiations (EXPERTS only)

--repeat-simp

make multiple passes with nonclausal simplifier [*]

--restart-step

amount of resources spent for each theory restart (EXPERTS only)

--rewrite-apply-to-const

eliminate function applications, rewriting e.g. f(5) to a new symbol f_5 (EXPERTS only) [*]

--rewrite-step

amount of resources spent for each rewrite step (EXPERTS only)

--sat-conflict-step

amount of resources spent for each sat conflict (main sat solver) (EXPERTS only)

--simp-ite-compress

enables compressing ites after ite simplification [*]

--simp-ite-hunt-zombies

post ite compression enables zombie removal while the number of nodes is above this threshold

--simp-with-care

enables simplifyWithCare in ite simplificiation [*]

--simplification=MODE

choose simplification mode, see --simplification=help

--sort-inference

calculate sort inference of input problem, convert the input based on monotonic sorts [*]

--static-learning

use static learning (on by default) [*]

--sygus-out=MODE

output mode for sygus

--sygus-print-callbacks

use sygus print callbacks to print sygus terms in the user-provided form (disable for debugging) [*]

--symmetry-breaker-exp

generate symmetry breaking constraints after symmetry detection [*]

--theory-check-step

amount of resources spent for each theory check call (EXPERTS only)

--unconstrained-simp

turn on unconstrained simplification (see Bruttomesso/Brummayer PhD thesis) [*]

--no-simplification

turn off all simplification (same as --simplification=none)

Strings Theory Options

--strings-abort-loop

abort when a looping word equation is encountered [*]

--strings-binary-csp

use binary search when splitting strings [*]

--strings-check-entail-len

check entailment between length terms to reduce splitting [*]

--strings-eager

strings eager check [*]

--strings-eager-len

strings eager length lemmas [*]

--strings-eit

the eager intersection used by the theory of strings [*]

--strings-exp

experimental features in the theory of strings [*]

--strings-fmf

the finite model finding used by the theory of strings [*]

--strings-guess-model

use model guessing to avoid string extended function reductions [*]

--strings-infer-as-lemmas

always send lemmas out instead of making internal inferences [*]

--strings-infer-sym

strings split on empty string [*]

--strings-inm

internal for strings: ignore negative membership constraints (fragment checking is needed, left to users for now) [*]

--strings-lazy-pp

perform string preprocessing lazily [*]

--strings-lb=N

the strategy of LB rule application: 0-lazy, 1-eager, 2-no

--strings-len-geqz

strings length greater than zero lemmas [*]

--strings-len-norm

strings length normalization lemma [*]

--strings-lprop-csp

do length propagation based on constant splits [*]

--strings-min-prefix-explain

minimize explanations for prefix of normal forms in strings [*]

--strings-opt1

internal option1 for strings: normal form [*]

--strings-opt2

internal option2 for strings: constant regexp splitting [*]

--strings-print-ascii

the alphabet contains only printable characters from the standard extended ASCII [*]

--strings-process-loop

reduce looping word equations to regular expressions [*]

--strings-rexplain-lemmas

regression explanations for string lemmas [*]

--strings-sp-emp

strings split on empty string [*]

--strings-uf-reduct

use uninterpreted functions when applying extended function reductions [*]

Theory Layer Options

--assign-function-values

assign values for uninterpreted functions in models [*]

--condense-function-values

condense values for functions in models rather than explicitly representing them [*]

--theoryof-mode=MODE

mode for Theory::theoryof() (EXPERTS only)

--use-theory=NAME

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

--symmetry-breaker

use UF symmetry breaker (Deharbe et al., CADE 2011) [*]

--uf-ho

enable support for higher-order reasoning [*]

--uf-ho-ext

apply extensionality on function symbols [*]

--uf-ss-abort-card=N

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

--uf-ss-clique-splits

use cliques instead of splitting on demand to shrink model [*]

--uf-ss-eager-split

add splits eagerly for uf strong solver [*]

--uf-ss-fair

use fair strategy for finite model finding multiple sorts [*]

--uf-ss-fair-monotone

group monotone sorts when enforcing fairness for finite model finding [*]

--uf-ss-regions

disable region-based method for discovering cliques and splits in uf strong solver [*]

--uf-ss-totality

always use totality axioms for enforcing cardinality constraints [*]

--uf-ss-totality-limited=N

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

--uf-ss-totality-sym-break

apply symmetry breaking for totality axioms [*]

--uf-ss=MODE

mode of operation for uf strong solver.

Each option marked with [*] has a --no-OPTIONNAME variant, which reverses the sense of the option.

Diagnostics

CVC4 reports all syntactic and semantic errors on standard error.

History

The CVC4 effort is the culmination of fifteen years of theorem proving research, starting with the Stanford Validity Checker (SVC) in 1996.

SVC's successor, the Cooperating Validity Checker (CVC), had a more optimized internal design, produced proofs, used the Chaff SAT solver, and featured a number of usability enhancements.  Its name comes from the cooperative nature of decision procedures in Nelson-Oppen theory combination, which share amongst each other equalities between shared terms.

CVC Lite, first made available in 2003, was a rewrite of CVC that attempted to make CVC more flexible (hence the “lite”) while extending the feature set: CVCLite supported quantifiers where its predecessors did not. CVC3 was a major overhaul of portions of CVC Lite: it added better decision procedure implementations, added support for using MiniSat in the core, and had generally better performance.

CVC4 is the new version, the fifth generation of this validity checker line that is now celebrating fifteen years of heritage. It represents a complete re-evaluation of the core architecture to be both performant and to serve as a cutting-edge research vehicle for the next several years.  Rather than taking CVC3 and redesigning problem parts, we've taken a clean-room approach, starting from scratch.  Before using any designs from CVC3, we have thoroughly scrutinized, vetted, and updated them.  Many parts of CVC4 bear only a superficial resemblance, if any, to their correspondent in CVC3.

However, CVC4 is fundamentally similar to CVC3 and many other modern SMT solvers: it is a DPLL( T ) solver, with a SAT solver at its core and a delegation path to different decision procedure implementations, each in charge of solving formulas in some background theory.

The re-evaluation and ground-up rewrite was necessitated, we felt, by the performance characteristics of CVC3.  CVC3 has many useful features, but some core aspects of the design led to high memory use, and the use of heavyweight computation (where more nimble engineering approaches could suffice) makes CVC3 a much slower prover than other tools. As these designs are central to CVC3, a new version was preferable to a selective re-engineering, which would have ballooned in short order.

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

Referenced By

cvc4(5), libcvc4(3), libcvc4compat(3), libcvc4parser(3).

The man page pcvc4(1) is an alias of cvc4(1).

July 2018 CVC4 release 1.6 User Manuals