Modes 
          Some API functions require a configuration mode argument, e.g.,
          
           
            
             cvc5::Solver::blockModel()
            
           
          
          .
The following enum classes define such configuration modes.
         
- 
           
enum class
cvc5::modes::BlockModelsMode - 
           
std::ostream& cvc5::modes::operator<< (std::ostream& out, BlockModelsMode mode) - 
           
enum class
cvc5::modes::LearnedLitType - 
           
std::ostream& cvc5::modes::operator<< (std::ostream& out, LearnedLitType type) - 
           
enum class
cvc5::modes::ProofComponent - 
           
std::ostream& cvc5::modes::operator<< (std::ostream& out, ProofComponent pc) - 
           
enum class
cvc5::modes::FindSynthTarget - 
           
std::ostream& cvc5::modes::operator<< (std::ostream& out, FindSynthTarget target) 
- 
           
           
           
           
           
           
           
            
             enum
            
           
           
           
           
            
             class
            
           
           
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              BlockModelsMode
             
            
           
           
            
           
           
 - 
           
Mode for blocking models.
Specifies how models are blocked in Solver::blockModel and Solver::blockModelValues .
Values:
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                LITERALS
               
              
             
             
              
             
             
 - 
             
Block models based on the SAT skeleton.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                VALUES
               
              
             
             
              
             
             
 - 
             
Block models based on the concrete model values for the free variables.
 
 - 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                LITERALS
               
              
             
             
              
             
             
 
- 
           
           
           
           
           
           
           
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              operator
             
            
            
             
              <<
             
            
           
           
            (
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             out
            
           
           ,
           
            
             
              BlockModelsMode
             
            
           
           
           
           
            
             mode
            
           
           
            )
           
           
            
           
           
 - 
           
Serialize a BlockModelsMode to given stream.
- Parameters :
 - 
             
- 
               
out – The output stream
 - 
               
mode – The mode.
 
 - 
               
 - Returns :
 - 
             
The output stream
 
 
- 
           
           
           
           
           
           
           
            
             enum
            
           
           
           
           
            
             class
            
           
           
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              LearnedLitType
             
            
           
           
            
           
           
 - 
           
Types of learned literals.
Specifies categories of literals learned for the method Solver::getLearnedLiterals .
Note that a literal may conceptually belong to multiple categories. We classify literals based on the first criteria in this list that they meet.
Values:
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                PREPROCESS_SOLVED
               
              
             
             
              
             
             
 - 
             
An equality that was turned into a substitution during preprocessing.
In particular, literals in this category are of the form (= x t) where x does not occur in t.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                PREPROCESS
               
              
             
             
              
             
             
 - 
             
A top-level literal (unit clause) from the preprocessed set of input formulas.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                INPUT
               
              
             
             
              
             
             
 - 
             
A literal from the preprocessed set of input formulas that does not occur at top-level after preprocessing.
Typically), this is the most interesting category of literals to learn.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                SOLVABLE
               
              
             
             
              
             
             
 - 
             
An internal literal that is solvable for an input variable.
In particular, literals in this category are of the form (= x t) where x does not occur in t, the preprocessed set of input formulas contains the term x, but not the literal (= x t).
Note that solvable literals can be turned into substitutions during preprocessing.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                CONSTANT_PROP
               
              
             
             
              
             
             
 - 
             
An internal literal that can be made into a constant propagation for an input term.
In particular, literals in this category are of the form (= t c) where c is a constant, the preprocessed set of input formulas contains the term t, but not the literal (= t c).
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                INTERNAL
               
              
             
             
              
             
             
 - 
             
Any internal literal that does not fall into the above categories.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                UNKNOWN
               
              
             
             
              
             
             
 - 
             
Special case for when produce-learned-literals is not set.
 
 - 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                PREPROCESS_SOLVED
               
              
             
             
              
             
             
 
- 
           
           
           
           
           
           
           
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              operator
             
            
            
             
              <<
             
            
           
           
            (
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             out
            
           
           ,
           
            
             
              LearnedLitType
             
            
           
           
           
           
            
             type
            
           
           
            )
           
           
            
           
           
 - 
           
Serialize a LearnedLitType to given stream.
- Parameters :
 - 
             
- 
               
out – The output stream
 - 
               
type – The learned literal type.
 
 - 
               
 - Returns :
 - 
             
The output stream
 
 
- 
           
           
           
           
           
           
           
            
             enum
            
           
           
           
           
            
             class
            
           
           
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              ProofComponent
             
            
           
           
            
           
           
 - 
           
Components to include in a proof.
Values:
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                RAW_PREPROCESS
               
              
             
             
              
             
             
 - 
             
Proofs of G1 … Gn whose free assumptions are a subset of F1, … Fm, where:
- 
               
G1, … Gn are the preprocessed input formulas,
 - 
               
F1, … Fm are the input formulas.
 
Note that G1 … Gn may be arbitrary formulas, not necessarily clauses.
 - 
               
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                PREPROCESS
               
              
             
             
              
             
             
 - 
             
Proofs of Gu1 … Gun whose free assumptions are Fu1, … Fum, where:
- 
               
Gu1, … Gun are clauses corresponding to input formulas used in the SAT proof,
 - 
               
Fu1, … Fum is the subset of the input formulas that are used in the SAT proof (i.e. the unsat core).
 
Note that Gu1 … Gun are clauses that are added to the SAT solver before its main search.
Only valid immediately after an unsat response.
 - 
               
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                SAT
               
              
             
             
              
             
             
 - 
             
A proof of false whose free assumptions are Gu1, … Gun, L1 … Lk, where:
- 
               
Gu1, … Gun, is a set of clauses corresponding to input formulas,
 - 
               
L1, …, Lk is a set of clauses corresponding to theory lemmas.
 
Only valid immediately after an unsat response.
 - 
               
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                THEORY_LEMMAS
               
              
             
             
              
             
             
 - 
             
Proofs of L1 … Lk where:
- 
               
L1, …, Lk are clauses corresponding to theory lemmas used in the SAT proof.
 
In contrast to proofs given for preprocess, L1 … Lk are clauses that are added to the SAT solver after its main search.
Only valid immediately after an unsat response.
 - 
               
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                FULL
               
              
             
             
              
             
             
 - 
             
A proof of false whose free assumptions are a subset of the input formulas F1), … Fm.
Only valid immediately after an unsat response.
 
 - 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                RAW_PREPROCESS
               
              
             
             
              
             
             
 
- 
           
           
           
           
           
           
           
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              operator
             
            
            
             
              <<
             
            
           
           
            (
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             out
            
           
           ,
           
            
             
              ProofComponent
             
            
           
           
           
           
            
             pc
            
           
           
            )
           
           
            
           
           
 - 
           
Serialize a ProofComponent to given stream.
- Parameters :
 - 
             
- 
               
out – The output stream
 - 
               
pc – The proof component.
 
 - 
               
 - Returns :
 - 
             
The output stream
 
 
- 
           
           
           
           
           
           
           
            
             enum
            
           
           
           
           
            
             class
            
           
           
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              FindSynthTarget
             
            
           
           
            
           
           
 - 
           
Find synthesis targets, used as an argument to Solver::findSynth . These specify various kinds of terms that can be found by this method.
Values:
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                ENUM
               
              
             
             
              
             
             
 - 
             
Find the next term in the enumeration of the target grammar.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                REWRITE
               
              
             
             
              
             
             
 - 
             
Find a pair of terms (t,s) in the target grammar which are equivalent but do not rewrite to the same term in the given rewriter (—sygus-rewrite=MODE). If so, the equality (= t s) is returned by findSynth.
This can be used to synthesize rewrite rules. Note if the rewriter is set to none (—sygus-rewrite=none), this indicates a possible rewrite when implementing a rewriter from scratch.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                REWRITE_UNSOUND
               
              
             
             
              
             
             
 - 
             
Find a term t in the target grammar which rewrites to a term s that is not equivalent to it. If so, the equality (= t s) is returned by findSynth.
This can be used to test the correctness of the given rewriter. Any returned rewrite indicates an unsoundness in the given rewriter.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                REWRITE_INPUT
               
              
             
             
              
             
             
 - 
             
Find a rewrite between pairs of terms (t,s) that are matchable with terms in the input assertions where t and s are equivalent but do not rewrite to the same term in the given rewriter (—sygus-rewrite=MODE).
This can be used to synthesize rewrite rules that apply to the current problem.
 
- 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                QUERY
               
              
             
             
              
             
             
 - 
             
Find a query over the given grammar. If the given grammar generates terms that are not Boolean, we consider equalities over terms from the given grammar.
The algorithm for determining which queries to generate is configured by —sygus-query-gen=MODE. Queries that are internally solved can be filtered by the option —sygus-query-gen-filter-solved.
 
 - 
             
             
             
             
             
             
             
              
               enumerator
              
             
             
             
             
              
               
                ENUM
               
              
             
             
              
             
             
 
- 
           
           
           
           
           
           
           
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             
              cvc5
             
            
            
             
              ::
             
            
            
             
              modes
             
            
            
             
              ::
             
            
           
           
            
             
              operator
             
            
            
             
              <<
             
            
           
           
            (
           
           
            
             std
            
           
           
            
             ::
            
           
           
            
             ostream
            
           
           
           
           
            
             &
            
           
           
            
             out
            
           
           ,
           
            
             
              FindSynthTarget
             
            
           
           
           
           
            
             target
            
           
           
            )
           
           
            
           
           
 - 
           
Serialize a FindSynthTarget to given stream.
- Parameters :
 - 
             
- 
               
out – The output stream
 - 
               
target – The synthesis find target.
 
 - 
               
 - Returns :
 - 
             
The output stream