cvc4 man page

cvc4, pcvc4 — an automated theorem prover


cvc4 [ options ] [ file ]

pcvc4 [ options ] [ file ]


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)


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

--quiet | -q

decrease verbosity (may be repeated)


give statistics on exit [*]

--verbose | -v

increase verbosity (may be repeated)


show CVC4 copyright information

--help | -h

full command line reference

--seed | -s

seed for random number generator


show CVC4 static configuration

--version | -V

identify this CVC4 binary


be less tolerant of non-conforming inputs [*]


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


all dumping goes to FILE (instead of stdout)


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


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 [*]


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

--produce-models | -m

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


enable resource limiting per query


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


enable time limiting per query (give milliseconds)


enable time limiting (give milliseconds)

Arithmetic Theory Options


maximum branch depth the approximate solver is allowed to take


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


rows shorter than this are propagated as clauses


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


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


collect the pivot history [*]


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


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


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


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


turns in a row dio solver cutting gets


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


turns on degenerate pivot penalties [*]


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


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


maximum cuts in a given context before signalling a restart


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


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


use the new row propagation system [*]


extended approach to non-linear [*]


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


use factoring inference in non-linear solver [*]


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


purify non-linear terms at preprocess [*]


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


do rewrites in non-linear solver [*]


intial splits on zero for all variables [*]


initial degree of polynomials for Taylor approximation


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


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


interleave tangent plane strategy for non-linear [*]


apply pseudo boolean rewrites [*]


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


threshold for substituting an equality in ppAssert


sets the maximum row length to be used in propagation


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


number of solve integer attempts to skips after a numeric failure


maximum complexity of any coefficient while outputting replaying cut lemmas


number of solve integer attempts to skips after a numeric failure


maximum complexity of any coefficient while replaying cuts


threshold for a major tolerance failure by the approximate solver


threshold for a major tolerance failure by the approximate solver


threshold for a minor tolerance failure by the approximate solver


threshold for a minor tolerance failure by the approximate solver


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


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


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


round robin turn


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


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


infer equalities based on Shostak normalization [*]


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


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


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


attempt to use an approximate solver [*]


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


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

Arrays Theory Options


set different array option configurations - for developers only


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


turn on eager lemma generation for arrays [*]


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


turn on model-based array solver [*]


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


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


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


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

Base Options

--debug=TAG | -d TAG

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


exit after parsing input [*]


exit after preprocessing input [*]


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


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


hide statistics which are zero [*]

--trace=TAG | -t TAG

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


SMT-LIBv2 compliance mode (implies other options)

Bitvector Theory Options


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


choose bitblasting mode, see --bitblast=help


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


mcm benchmark abstraction (EXPERTS only) [*]


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


algebraic inferences for extended functions [*]


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


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


always return -1 on division by zero [*]


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


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


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


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


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


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


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


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


lazily rewrite extended functions like bv2nat and int2bv [*]


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


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


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


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


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


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

Datatypes Theory Options


do bisimilarity check for co-datatypes [*]


do binary splits for datatype constructor types [*]


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


do cyclicity check for datatypes [*]


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


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


introduce reference skolems for shorter explanations [*]


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


internally use shared selectors across multiple constructors [*]


do not preprocess away tester predicates [*]


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


use builtin kind for evaluation functions in sygus [*]


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


if and how to apply fairness for sygus


sygus experimental option [*]


simple sygus sym break lemmas [*]


dynamic sygus sym break lemmas [*]


lazily add symmetry breaking lemmas for terms [*]


sygus sym break lemmas based on pbe conjectures [*]


add relevancy conditions to symmetry breaking lemmas [*]

Decision Heuristics Options


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


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


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


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


choose decision mode, see --decision=help

Expression Package Options


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


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


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


print types with variables when printing exprs [*]


never type check expressions

Idl Options


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

Driver Options


continue executing commands, even on error [*]


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


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


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


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


force interactive/non-interactive mode [*]


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


show all available tags for debugging


show all available tags for tracing


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


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


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


Total number of threads for portfolio


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

Parser Options


memory map file input [*]

Printing Options


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


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

Proof Options


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


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


try to eliminate preprocessing holes in proofs [*]


turns on global letification in LFSC proofs [*]

Sat Layer Options


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


use Minisat elimination [*]


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


sets the random seed for the sat solver


refine theory conflict clauses (default false) [*]


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


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

Quantifiers Options


perform aggressive miniscoping for quantifiers [*]


turns on counterexample-based quantifier instantiation [*]


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


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


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


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


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


linearize adder chains for variables [*]


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


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


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


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


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


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


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


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


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


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


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


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


turns on recursive counterexample-based quantifier instantiation [*]


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


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


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


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


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


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


counterexample-guided quantifier instantiation for sygus [*]


abort if synthesis conjecture is not single invocation [*]


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


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


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


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


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


mode for processing single invocation synthesis conjectures


conditional rewriting of quantified formulas [*]


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


split quantified formulas that lead to variable eliminations [*]


filter based on active terms [*]


filter based on canonicity [*]


filter based on model [*]


generate candidate conjectures for inductive proofs [*]


number of ground terms to generate for model filtering


maximum depth of terms to consider for conjectures


number of conjectures to generate per instantiation round


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


do not filter conjectures [*]


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


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


whether to do heuristic E-matching [*]


eliminate extended arithmetic symbols in quantified formulas [*]


eliminate tautological disjuncts of quantified formulas [*]


use finite model finding heuristic for quantifier instantiation [*]


finite model finding on bounded quantification [*]


finite model finding on bounded integer quantification [*]


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


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


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


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


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


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


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


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


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


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


interleave full saturate instantiation with other techniques [*]


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


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


do global negation of input formula [*]


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


give priority to variable arguments over constant arguments [*]


merge term indices modulo equality [*]


generate additional triggers as needed during search [*]


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


record explanations for inferArithTriggerEq [*]


only input terms are assigned instantiation level zero [*]


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


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


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


internal propagation for instantiations for selecting relevant instances [*]


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


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


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


when to apply instantiation


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


split ites with dt testers as conditions [*]


ite lifting mode for quantified formulas


choose literal matching mode


do instantiation based on local theory extensions [*]


partially instantiate local theory quantifiers [*]


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


perform quantifiers macro expansion [*]


mode for quantifiers macro expansion


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


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


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


choose mode for model-based quantifier instantiation


miniscope quantifiers [*]


miniscope quantifiers for ground subformulas [*]


caching version of multi triggers [*]


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


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


select multi triggers when single triggers exist [*]


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


apply skolemization eagerly to bodies of quantified formulas [*]


apply skolemization to quantified formulas aggressively [*]


apply skolemization to nested quantified formulas [*]


prenex quantified formulas with user patterns [*]


prenex mode for quantified formulas


use pure theory terms as single triggers [*]


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


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


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


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


optimization, test qcf instances eagerly [*]


consider conflicts for nested quantifiers [*]


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


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


qcf experimental variable ordering [*]


infer alpha equivalence between quantified formulas [*]


perform anti-skolemization for quantified formulas [*]


enable conflict find mechanism for quantifiers [*]


what effort to apply conflict find mechanism


when to invoke conflict find mechanism for quantifiers


mode for dynamic quantifiers splitting


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


use matching heuristics for EPR instantiation [*]


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


use all available techniques for inductive reasoning [*]


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


selection mode for representatives in quantifiers engine


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


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


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


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


use rewrite rules module [*]


add one instance of rewrite rule per round [*]


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


statically add constants appearing in conjecture to grammars [*]


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


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


do unfolding of sygus evaluation functions [*]


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


use extended rewriter for sygus [*]


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


attempt to preprocess arbitrary inputs to sygus conjectures [*]


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


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


statically minimize sygus grammars [*]


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


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


direct evaluation of refinement lemmas for conflict analysis [*]


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


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


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


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


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


filter candidate rewrites based on congruence [*]


filter candidate rewrites based on matching [*]


filter candidate rewrites based on variable ordering [*]


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


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


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


number of points to consider when doing sygus rewriter sample testing


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


embed sygus templates into grammars [*]


Unification-based function synthesis [*]


which ground terms to consider for instantiation


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


selection mode to activate triggers


selection mode for triggers


policy for handling user-provided patterns for quantifier instantiation


enable simple variable elimination for quantified formulas [*]


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

Sep Options


check negated spatial assertions [*]


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


assume cardinality elements are distinct [*]


experimental flag for sep [*]


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


eliminate emp constraint at preprocess time [*]

Sets Options


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


send inferences as lemmas [*]


introduce proxy variables eagerly to shorten lemmas [*]


standard effort checks for relations [*]

SMT Layer Options


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


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


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


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


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


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


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


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


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


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


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


output proofs after every UNSAT/VALID response [*]


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


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


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


use extended rewriter as a preprocessing pass [*]


use aggressive extended rewriter as a preprocessing pass [*]


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


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


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


amount of resources spent when adding lemmas (EXPERTS only)


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


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


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


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


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


support the get-assignment command [*]


turn on unsat assumptions generation [*]


turn on unsat core generation [*]


turn on proof generation [*]


amount of resources spent for quantifier instantiations (EXPERTS only)


make multiple passes with nonclausal simplifier [*]


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


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


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


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


enables compressing ites after ite simplification [*]


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


enables simplifyWithCare in ite simplificiation [*]


choose simplification mode, see --simplification=help


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


use static learning (on by default) [*]


output mode for sygus


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


generate symmetry breaking constraints after symmetry detection [*]


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


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


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

Strings Theory Options


abort when a looping word equation is encountered [*]


use binary search when splitting strings [*]


check entailment between length terms to reduce splitting [*]


strings eager check [*]


strings eager length lemmas [*]


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


experimental features in the theory of strings [*]


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


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


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


strings split on empty string [*]


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


perform string preprocessing lazily [*]


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


strings length greater than zero lemmas [*]


strings length normalization lemma [*]


do length propagation based on constant splits [*]


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


internal option1 for strings: normal form [*]


internal option2 for strings: constant regexp splitting [*]


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


reduce looping word equations to regular expressions [*]


regression explanations for string lemmas [*]


strings split on empty string [*]


use uninterpreted functions when applying extended function reductions [*]

Theory Layer Options


assign values for uninterpreted functions in models [*]


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


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


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


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


enable support for higher-order reasoning [*]


apply extensionality on function symbols [*]


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


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


add splits eagerly for uf strong solver [*]


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


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


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


always use totality axioms for enforcing cardinality constraints [*]


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


apply symmetry breaking for totality axioms [*]


mode of operation for uf strong solver.

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


CVC4 reports all syntactic and semantic errors on standard error.


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.


This manual page refers to CVC4 version 1.6.


An issue tracker for the CVC4 project is maintained at


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

Referenced By

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

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

February 2019 CVC4 release 1.6 User Manuals