* Remove front end hack for sygus.
* Remove other hack, add sygus solution output mode.
* Clang format
* Minor
* Fix
* Minor
* Remove unused field.
opts.setOutputLanguage(language::toOutputLanguage(opts.getInputLanguage()));
}
- // if doing sygus, turn on CEGQI by default
- if(opts.getInputLanguage() == language::input::LANG_SYGUS ){
- if( !opts.wasSetByUserCeGuidedInst()) {
- opts.setCeGuidedInst(true);
- }
- if( !opts.wasSetByUserDumpSynth()) {
- opts.setDumpSynth(true);
- }
- }
-
// Determine which messages to show based on smtcomp_mode and verbosity
if(Configuration::isMuzzledBuild()) {
DebugChannel.setStream(&CVC4::null_os);
set_language.h \
simplification_mode.cpp \
simplification_mode.h \
+ sygus_out_mode.h \
theoryof_mode.cpp \
theoryof_mode.h \
ufss_mode.h
// TODO: Document these.
- void setCeGuidedInst(bool);
- void setDumpSynth(bool);
void setInputLanguage(InputLanguage);
void setInteractive(bool);
void setOut(std::ostream*);
\n\
";
-
theory::quantifiers::InstWhenMode OptionsHandler::stringToInstWhenMode(std::string option, std::string optarg) throw(OptionException) {
if(optarg == "pre-full") {
return theory::quantifiers::INST_WHEN_PRE_FULL;
}
}
+const std::string OptionsHandler::s_sygusSolutionOutModeHelp =
+ "\
+Modes for finite model finding bound minimization, supported by --sygus-out:\n\
+\n\
+status \n\
++ Print only status for check-synth calls.\n\
+\n\
+status-and-def (default) \n\
++ Print status followed by definition corresponding to solution.\n\
+\n\
+status-or-def \n\
++ Print status if infeasible, or definition corresponding to\n\
+ solution if feasible.\n\
+\n\
+sygus-standard \n\
++ Print based on SyGuS standard.\n\
+\n\
+";
+
+SygusSolutionOutMode OptionsHandler::stringToSygusSolutionOutMode(
+ std::string option, std::string optarg) throw(OptionException)
+{
+ if (optarg == "status")
+ {
+ return SYGUS_SOL_OUT_STATUS;
+ }
+ else if (optarg == "status-and-def")
+ {
+ return SYGUS_SOL_OUT_STATUS_AND_DEF;
+ }
+ else if (optarg == "status-or-def")
+ {
+ return SYGUS_SOL_OUT_STATUS_OR_DEF;
+ }
+ else if (optarg == "sygus-standard")
+ {
+ return SYGUS_SOL_OUT_STANDARD;
+ }
+ else if (optarg == "help")
+ {
+ puts(s_sygusSolutionOutModeHelp.c_str());
+ exit(1);
+ }
+ else
+ {
+ throw OptionException(std::string("unknown option for --sygus-out: `")
+ + optarg
+ + "'. Try --sygus-out help.");
+ }
+}
void OptionsHandler::setProduceAssertions(std::string option, bool value) throw() {
options::produceAssertions.set(value);
#include "options/arith_unate_lemma_mode.h"
#include "options/base_handlers.h"
#include "options/bv_bitblast_mode.h"
-#include "options/decision_mode.h"
#include "options/datatypes_modes.h"
+#include "options/decision_mode.h"
#include "options/language.h"
#include "options/option_exception.h"
#include "options/options.h"
#include "options/printer_modes.h"
#include "options/quantifiers_modes.h"
#include "options/simplification_mode.h"
+#include "options/sygus_out_mode.h"
#include "options/theoryof_mode.h"
#include "options/ufss_mode.h"
void notifyBeforeSearch(const std::string& option) throw(ModalException);
void notifyDumpMode(std::string option) throw(OptionException);
SimplificationMode stringToSimplificationMode(std::string option, std::string optarg) throw(OptionException);
+ SygusSolutionOutMode stringToSygusSolutionOutMode(
+ std::string option, std::string optarg) throw(OptionException);
void setProduceAssertions(std::string option, bool value) throw();
void proofEnabledBuild(std::string option, bool value) throw(OptionException);
void LFSCEnabledBuild(std::string option, bool value);
static const std::string s_qcfModeHelp;
static const std::string s_qcfWhenModeHelp;
static const std::string s_simplificationHelp;
+ static const std::string s_sygusSolutionOutModeHelp;
static const std::string s_cbqiBvIneqModeHelp;
static const std::string s_cegqiSingleInvHelp;
static const std::string s_sygusInvTemplHelp;
// TODO: Document these.
-void Options::setCeGuidedInst(bool value) {
- set(options::ceGuidedInst, value);
-}
-
-void Options::setDumpSynth(bool value) {
- set(options::dumpSynth, value);
-}
void Options::setInputLanguage(InputLanguage value) {
set(options::inputLanguage, value);
### synthesis options
option ceGuidedInst --cegqi bool :default false :read-write
- counterexample-guided quantifier instantiation
+ counterexample-guided quantifier instantiation for sygus
option cegqiSingleInvMode --cegqi-si=MODE CVC4::theory::quantifiers::CegqiSingleInvMode :default CVC4::theory::quantifiers::CEGQI_SI_MODE_NONE :include "options/quantifiers_modes.h" :handler stringToCegqiSingleInvMode :read-write
mode for processing single invocation synthesis conjectures
option cegqiSingleInvPartial --cegqi-si-partial bool :default false
output proofs after every UNSAT/VALID response
option dumpInstantiations --dump-instantiations bool :default false
output instantiations of quantified formulas after every UNSAT/VALID response
+option sygusOut --sygus-out=MODE SygusSolutionOutMode :default SYGUS_SOL_OUT_STATUS_AND_DEF :include "options/sygus_out_mode.h" :handler stringToSygusSolutionOutMode :read-write
+ output mode for sygus
option dumpSynth --dump-synth bool :read-write :default false
output solution for synthesis conjectures after every UNSAT/VALID response
option unsatCores produce-unsat-cores --produce-unsat-cores bool :predicate proofEnabledBuild :notify :notify notifyBeforeSearch
--- /dev/null
+/********************* */
+/*! \file sygus_out_mode.h
+ ** \verbatim
+ ** Top contributors (to current version):
+ ** Andrew Reynolds
+ ** This file is part of the CVC4 project.
+ ** Copyright (c) 2009-2017 by the authors listed in the file AUTHORS
+ ** in the top-level source directory) and their institutional affiliations.
+ ** All rights reserved. See the file COPYING in the top-level source
+ ** directory for licensing information.\endverbatim
+ **
+ ** \brief Options for sygus solution output.
+ **/
+
+#include "cvc4_public.h"
+
+#ifndef __CVC4__SMT__SYGUS_OUT_MODE_H
+#define __CVC4__SMT__SYGUS_OUT_MODE_H
+
+#include <iosfwd>
+
+namespace CVC4 {
+
+/** Mode for printing sygus solutions. */
+enum SygusSolutionOutMode
+{
+ /** print status */
+ SYGUS_SOL_OUT_STATUS,
+ /** (default) print status and solution */
+ SYGUS_SOL_OUT_STATUS_AND_DEF,
+ /** print status if infeasible, or solution if feasible */
+ SYGUS_SOL_OUT_STATUS_OR_DEF,
+ /** print output specified by sygus standard */
+ SYGUS_SOL_OUT_STANDARD,
+};
+
+} /* CVC4 namespace */
+
+#endif /* __CVC4__SMT__SYGUS_OUT_MODE_H */
d_expr() {
}
-CheckSynthCommand::CheckSynthCommand(const Expr& expr, bool inUnsatCore) throw() :
- d_expr(expr), d_inUnsatCore(inUnsatCore) {
+CheckSynthCommand::CheckSynthCommand(const Expr& expr) throw() :
+ d_expr(expr) {
}
Expr CheckSynthCommand::getExpr() const throw() {
try {
d_result = smtEngine->checkSynth(d_expr);
d_commandStatus = CommandSuccess::instance();
+ smt::SmtScope scope(smtEngine);
+ d_solution.clear();
+ // check whether we should print the status
+ if (d_result.asSatisfiabilityResult() != Result::UNSAT
+ || options::sygusOut() == SYGUS_SOL_OUT_STATUS_AND_DEF
+ || options::sygusOut() == SYGUS_SOL_OUT_STATUS)
+ {
+ if (options::sygusOut() == SYGUS_SOL_OUT_STANDARD)
+ {
+ d_solution << "(fail)" << endl;
+ }
+ else
+ {
+ d_solution << d_result << endl;
+ }
+ }
+ // check whether we should print the solution
+ if (d_result.asSatisfiabilityResult() == Result::UNSAT
+ && options::sygusOut() != SYGUS_SOL_OUT_STATUS)
+ {
+ // printing a synthesis solution is a non-constant
+ // method, since it invokes a sophisticated algorithm
+ // (Figure 5 of Reynolds et al. CAV 2015).
+ // Hence, we must call here print solution here,
+ // instead of during printResult.
+ smtEngine->printSynthSolution(d_solution);
+ }
} catch(exception& e) {
d_commandStatus = new CommandFailure(e.what());
}
if(! ok()) {
this->Command::printResult(out, verbosity);
} else {
- out << d_result << endl;
+ out << d_solution.str();
}
}
Command* CheckSynthCommand::exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap) {
- CheckSynthCommand* c = new CheckSynthCommand(d_expr.exportTo(exprManager, variableMap), d_inUnsatCore);
+ CheckSynthCommand* c = new CheckSynthCommand(d_expr.exportTo(exprManager, variableMap));
c->d_result = d_result;
return c;
}
Command* CheckSynthCommand::clone() const {
- CheckSynthCommand* c = new CheckSynthCommand(d_expr, d_inUnsatCore);
+ CheckSynthCommand* c = new CheckSynthCommand(d_expr);
c->d_result = d_result;
return c;
}
};/* class QueryCommand */
class CVC4_PUBLIC CheckSynthCommand : public Command {
-protected:
- Expr d_expr;
- Result d_result;
- bool d_inUnsatCore;
public:
CheckSynthCommand() throw();
- CheckSynthCommand(const Expr& expr, bool inUnsatCore = true) throw();
+ CheckSynthCommand(const Expr& expr) throw();
~CheckSynthCommand() throw() {}
Expr getExpr() const throw();
void invoke(SmtEngine* smtEngine);
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
+
+ protected:
+ /** the assertion of check-synth */
+ Expr d_expr;
+ /** result of the check-synth call */
+ Result d_result;
+ /** string stream that stores the output of the solution */
+ std::stringstream d_solution;
};/* class CheckSynthCommand */
// this is TRANSFORM in the CVC presentation language
options::bitvectorDivByZeroConst.set(options::inputLanguage()
== language::input::LANG_SMTLIB_V2_6);
}
+ if (options::inputLanguage() == language::input::LANG_SYGUS)
+ {
+ if (!options::ceGuidedInst.wasSetByUser())
+ {
+ options::ceGuidedInst.set(true);
+ }
+ }
if(options::forceLogicString.wasSetByUser()) {
d_logic = LogicInfo(options::forceLogicString());
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(declare-var n Int)
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
; SCRUBBER: sed -e 's/The fact in question: .*$/The fact in question: TERM/'
; EXPECT: (error "A non-linear fact was asserted to arithmetic in a linear logic.
; EXPECT: The fact in question: TERM
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun fb () Int ((Start Int ((Constant Int)))))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun findIdx ( (y1 Int) (y2 Int) (k1 Int)) Int ((Start Int ( 0 1 2 y1 y2 k1 (ite BoolExpr Start Start))) (BoolExpr Bool ((< Start Start) (<= Start Start) (> Start Start) (>= Start Start)))))
(declare-var x1 Int)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun findSum ( (y1 Int) (y2 Int) )Int ((Start Int ( 0 1 2 y1 y2 (+ Start Start) (ite BoolExpr Start Start))) (BoolExpr Bool ((< Start Start) (<= Start Start) (> Start Start) (>= Start Start)))))
(declare-var x1 Int)
; EXPECT: unsat
-; COMMAND-LINE: --sygus-inv-templ=post --no-dump-synth
+; COMMAND-LINE: --sygus-inv-templ=post --sygus-out=status
(set-logic LIA)
(synth-inv inv-f ((x Int) (y Int)))
; EXPECT: unsat
-; COMMAND-LINE: --sygus-inv-templ=pre --no-dump-synth
+; COMMAND-LINE: --sygus-inv-templ=pre --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic ALL_SUPPORTED)
(declare-var m Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
; EXPECT: unsat
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(declare-datatypes ((List 0)) (((cons (head Int) (tail List)) (nil))))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=none --no-dump-synth
+; COMMAND-LINE: --cegqi-si=none --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int ((+ Con Con) (+ Start Start) x))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(define-sort D (Enum (a b)))
(define-fun f ((x D)) Int (ite (= x D::a) 3 7))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi --no-dump-synth
+; COMMAND-LINE: --cegqi --sygus-out=status
(set-logic BV)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic BV)
(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic BV)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic BV)
(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-inv inv-f ((x Int) (y Int) (b Bool)))
(declare-primed-var x Int)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(define-fun g ((x Int)) Int (ite (= x 1) 15 19))
(synth-fun f ((x Int)) Int
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int) (y Int)) Int
((Start Int (x
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic ALL_SUPPORTED)
(declare-datatypes ((List 0)) (((cons (head Int) (tail List)) (nil))))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun max ((x Int) (y Int)) Int
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
; Synthesize the maximum of 2 integers, but property has 4 variables (requires 2 passes)
(set-logic LIA)
(synth-fun max2 ((x Int) (y Int)) Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int ((+ (+ Con Con) Con) x))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int ((+ Con Con) (+ (+ Start Start) Con) x))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth --nl-ext-tplanes
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status --nl-ext-tplanes
(set-logic NIA)
(synth-fun max ((x Int) (y Int)) Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun p ((x Int) (y Int)) Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic BV)
(define-fun parity ((a Bool) (b Bool) (c Bool) (d Bool)) Bool
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic BV)
(define-fun bit-reset ((x (BitVec 32)) (bit (BitVec 32))) (BitVec 32)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(synth-fun f ((x String)) String
((Start String (ntString))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(synth-fun f ((firstname String) (lastname String)) String
((Start String (ntString))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(define-fun cA ((x String) (y String)) String (str.++ (str.++ x "A") y))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(synth-fun f ((name String)) String
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(synth-fun f ((name String)) String
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic SLIA)
(synth-fun f ((firstname String) (lastname String)) String
((Start String (ntString))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=none --no-dump-synth
+; COMMAND-LINE: --cegqi-si=none --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int ((+ Term Term)))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=none --no-dump-synth
+; COMMAND-LINE: --cegqi-si=none --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int (Term (+ Start Start)))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=none --no-dump-synth
+; COMMAND-LINE: --cegqi-si=none --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int
((Start Int (Term (+ Start Start)))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun R ((y Int)) Bool)
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
;; f1 is x plus 2 ;; f2 is 2x plus 5
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=all --no-dump-synth
+; COMMAND-LINE: --cegqi-si=all --sygus-out=status
(set-logic LIA)
(synth-fun f1 ((x Int)) Int
(
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun f ((x Int)) Int ((Start Int ((- 1)))))
(declare-var x Int)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun inv ((x Int)) Bool
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(define-fun get-y ((currPoint Int)) Int
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun f ((x1 Int) (x2 Int)) Int
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun findSum ( (y1 Int) (y2 Int) )Int (
(Start Int ( 0 1 y1 y2 (+ Start Start) (ite BoolExpr Start Start)))
; EXPECT: unsat
-; COMMAND-LINE: --cegqi-si=none --no-dump-synth
+; COMMAND-LINE: --cegqi-si=none --sygus-out=status
(set-logic BV)
(define-fun hd01 ((x (BitVec 32))) (BitVec 32) (bvand x #x00000001))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic BV)
(define-fun shr1 ((x (BitVec 64))) (BitVec 64) (bvlshr x #x0000000000000001))
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun inv ((l Int)) Bool
(
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun inv ((i Int) (l Int)) Bool
(
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun eq1 ( (x Int) (y Int) ) Int
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth --nl-ext-tplanes
+; COMMAND-LINE: --sygus-out=status --nl-ext-tplanes
(set-logic NIA)
(synth-fun max ((x Int) (y Int)) Int
; EXPECT: unsat
-; COMMAND-LINE: --sygus-inv-templ=post --no-dump-synth
+; COMMAND-LINE: --sygus-inv-templ=post --sygus-out=status
(set-logic LIA)
(define-fun
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
; EXPECT: unsat
-; COMMAND-LINE: --no-dump-synth
+; COMMAND-LINE: --sygus-out=status
(set-logic LIA)
(synth-fun inv ((i Int) (y Int) (l Int)) Bool
(