├── .ci ├── Dockerfile └── build.sh ├── .clang-format ├── .codeclimate.yml ├── .github ├── actions │ ├── compile │ │ └── action.yml │ ├── install_dependencies │ │ └── action.yml │ └── run_tests │ │ └── action.yml └── workflows │ ├── .github │ └── workflows │ │ └── CI.yml │ └── CI.yml ├── .gitignore ├── .gitlab-ci.yml ├── CMakeLists.txt ├── Dockerfile ├── LICENSE ├── README.md ├── cmake ├── GetGitRevisionDescription.cmake ├── GetGitRevisionDescription.cmake.in ├── apple-llvm-toolchain.cmake ├── clang-tidy.cmake ├── clang-time-trace.cmake ├── compiler-options.cmake ├── export.cmake ├── install.cmake ├── macros.cmake └── smtratmacros.cmake ├── doc ├── CMakeLists.txt ├── apidoc-html │ └── doxygen.conf.in ├── apidoc-pdf │ ├── doxygen.conf.in │ ├── doxygen.sty │ ├── footer.tex │ └── header.tex ├── examples │ ├── nra-sat.smt2 │ ├── qe.smt2 │ ├── qfnra-sat.smt2 │ └── qfnra-unsat.smt2 ├── literature.bib ├── logo.png ├── logo_old │ ├── .gitignore │ ├── commands.tex │ ├── logo.pdf │ ├── logo.tex │ ├── logo_content.tex │ └── packages.tex ├── manual │ ├── doxygen.conf.in │ ├── doxygen.sty │ ├── footer.tex │ └── header.tex ├── markdown │ ├── 01-introduction.md │ ├── 02-installation.md │ ├── 03-architecture.md │ ├── 04-modules.md │ ├── 05-strategies.md │ ├── 07-using-smtrat.md │ ├── 08-other-tools.md │ ├── 09-developers.md │ ├── CMakeLists.txt │ ├── developers │ │ ├── bugs.md │ │ ├── checkpoints.md │ │ ├── code-style.md │ │ ├── documentation.md │ │ ├── logging.md │ │ ├── settings.md │ │ ├── statistics-and-timing.md │ │ ├── testing.md │ │ └── validation.md │ └── modules │ │ ├── .gitignore │ │ └── modules.md.in ├── pictures │ ├── CMakeLists.txt │ ├── logo_smtrat.tex │ ├── module_in_strategy.tex │ ├── system_architecture.tex │ └── template.tex.in └── smtcomp-description │ ├── .gitignore │ ├── literature.bib │ ├── smtcomp-2019.pdf │ ├── smtcomp-2019.tex │ ├── smtcomp-2020.pdf │ ├── smtcomp-2020.tex │ ├── smtcomp-2021.pdf │ ├── smtcomp-2021.tex │ ├── smtcomp-2022.pdf │ ├── smtcomp-2022.tex │ ├── smtcomp-2023.pdf │ ├── smtcomp-2023.tex │ ├── smtcomp-2024.pdf │ └── smtcomp-2024.tex ├── resources ├── carl-required.version ├── carl-write-required-version.cmake ├── carl.cmake ├── carl │ └── CMakeLists.txt ├── mimalloc.cmake └── resources.cmake ├── smtrat.pc.in ├── src ├── CMakeLists.txt ├── cli │ ├── CLIStatistics.h │ ├── CMakeLists.txt │ ├── ExitCodes.h │ ├── ResourceLimitation.h │ ├── config.h.in │ ├── handle_options.h │ ├── parser │ │ ├── Attribute.h │ │ ├── Common.h │ │ ├── Identifier.h │ │ ├── InstructionHandler.h │ │ ├── Lexicon.h │ │ ├── Parser.h │ │ ├── ParserSettings.h │ │ ├── ParserWrapper.cpp │ │ ├── ParserWrapper.h │ │ ├── SExpression.h │ │ ├── Script.h │ │ ├── Sort.h │ │ ├── Term.h │ │ ├── VariantMap.h │ │ └── theories │ │ │ ├── AbstractTheory.h │ │ │ ├── Arithmetic.cpp │ │ │ ├── Arithmetic.h │ │ │ ├── Attribute.h │ │ │ ├── Bitvector.cpp │ │ │ ├── Bitvector.h │ │ │ ├── BooleanEncoding.cpp │ │ │ ├── BooleanEncoding.h │ │ │ ├── Common.h │ │ │ ├── Conversions.h │ │ │ ├── Core.cpp │ │ │ ├── Core.h │ │ │ ├── FunctionInstantiator.h │ │ │ ├── ParserState.h │ │ │ ├── Theories.h │ │ │ ├── TheoryTypes.h │ │ │ ├── Uninterpreted.cpp │ │ │ └── Uninterpreted.h │ ├── smtratSolver.cpp │ └── tools │ │ ├── ExecutionState.h │ │ ├── Executor.h │ │ ├── cnf_conversion.cpp │ │ ├── cnf_conversion.h │ │ ├── compile_information.cpp.in │ │ ├── compile_information.h │ │ ├── config.h.in │ │ ├── execute_smtlib.h │ │ ├── formula_analyzer.cpp │ │ ├── formula_analyzer.h │ │ ├── parser_dimacs.h │ │ ├── parser_opb.h │ │ ├── parser_smtlib.cpp │ │ ├── parser_smtlib.h │ │ ├── parser_smtlib_utils.h │ │ ├── preprocessor.cpp │ │ └── preprocessor.h ├── smtrat-analyzer │ ├── CMakeLists.txt │ ├── analyzers │ │ ├── cad_projections.cpp │ │ ├── cad_projections.h │ │ ├── cnf.cpp │ │ ├── cnf.h │ │ ├── formula_types.cpp │ │ ├── formula_types.h │ │ ├── utils.h │ │ ├── variables.cpp │ │ └── variables.h │ ├── settings.h │ ├── smtrat-analyzer.cpp │ ├── smtrat-analyzer.h │ └── statistics.h ├── smtrat-cad │ ├── CAD.h │ ├── CMakeLists.txt │ ├── Settings.h │ ├── common.h │ ├── debug │ │ ├── DotHelper.h │ │ └── TikzHistoryPrinter.h │ ├── lifting │ │ ├── LiftingTree.h │ │ ├── Sample.h │ │ ├── SampleComparator.h │ │ └── SampleIteratorQueue.h │ ├── projection │ │ ├── BaseProjection.h │ │ ├── PolynomialLiftingQueue.h │ │ ├── Projection.h │ │ ├── ProjectionComparator.h │ │ ├── ProjectionInformation.h │ │ ├── Projection_EC.h │ │ ├── Projection_F.h │ │ ├── Projection_Model.h │ │ ├── Projection_NO.h │ │ ├── Projection_NU.h │ │ ├── Projection_S.h │ │ └── Projection_utils.h │ ├── projectionoperator │ │ ├── Brown.h │ │ ├── Collins.h │ │ ├── Hong.h │ │ ├── Lazard.h │ │ ├── McCallum.h │ │ ├── McCallum_partial.h │ │ ├── ProjectionOperator.h │ │ └── utils.h │ ├── smtrat-cad.cpp │ ├── smtrat-cad.h │ ├── utils │ │ ├── CADConstraints.h │ │ ├── CADCore.h │ │ ├── CADPreprocessor.cpp │ │ ├── CADPreprocessor.h │ │ ├── ConflictGraph.cpp │ │ ├── ConflictGraph.h │ │ ├── DynamicPriorityQueue.h │ │ ├── MISGeneration.h │ │ ├── Origin.h │ │ ├── Preprocessor.cpp │ │ └── Preprocessor.h │ └── variableordering │ │ ├── triangular_ordering.cpp │ │ └── triangular_ordering.h ├── smtrat-cadcells │ ├── CADCellsStatistics.cpp │ ├── CADCellsStatistics.h │ ├── CMakeLists.txt │ ├── OCApproximationStatistics.h │ ├── algorithms │ │ ├── interval.h │ │ ├── level_covering.h │ │ └── unsat_intervals.h │ ├── common.h │ ├── datastructures │ │ ├── delineation.h │ │ ├── derivation.h │ │ ├── polynomials.h │ │ ├── projections.h │ │ ├── properties.h │ │ ├── representation.h │ │ ├── roots.cpp │ │ └── roots.h │ ├── helper_formula.h │ ├── operators │ │ ├── operator.h │ │ ├── operator_mccallum.h │ │ ├── operator_mccallum_filtered.h │ │ ├── operator_mccallum_pdel.h │ │ ├── properties.h │ │ ├── properties_util.h │ │ ├── rules.h │ │ ├── rules_constr.h │ │ ├── rules_covering.h │ │ ├── rules_filter.h │ │ ├── rules_filter_util.h │ │ ├── rules_null.h │ │ └── rules_pdel.h │ ├── representation │ │ ├── approximation │ │ │ ├── ApproximationSettings.h │ │ │ ├── PWLBuilder.h │ │ │ ├── PWLRefiner.h │ │ │ ├── criteria.h │ │ │ ├── polynomials.h │ │ │ ├── pwl.h │ │ │ └── ran_approximation.h │ │ ├── combinatorialopt │ │ │ ├── graph.h │ │ │ ├── matching.h │ │ │ ├── ordering.h │ │ │ ├── ordering_statistics.h │ │ │ └── resultant_cost_metrics.h │ │ ├── heuristics.h │ │ ├── heuristics_approximation.h │ │ ├── heuristics_cell.h │ │ ├── heuristics_combinatorialopt.h │ │ ├── heuristics_covering.h │ │ └── util.h │ ├── smtrat-cadcells.cpp │ └── smtrat-cadcells.h ├── smtrat-common │ ├── CMakeLists.txt │ ├── checkpoints │ │ └── Checkpoints.h │ ├── config.h.in │ ├── logging.h │ ├── model.h │ ├── settings │ │ ├── Settings.h │ │ ├── SettingsComponents.h │ │ ├── SettingsParser.cpp │ │ └── SettingsParser.h │ ├── smtrat-common.cpp │ ├── smtrat-common.h │ ├── statistics │ │ ├── Statistics.h │ │ └── StatisticsSettings.h │ ├── types.h │ └── validation │ │ ├── Validation.h │ │ ├── ValidationCollector.h │ │ ├── ValidationPoint.h │ │ ├── ValidationPrinter.h │ │ └── ValidationSettings.h ├── smtrat-coveringng │ ├── Algorithm.h │ ├── Algorithm_NuCAD.h │ ├── CMakeLists.txt │ ├── CoveringNGStatistics.cpp │ ├── CoveringNGStatistics.h │ ├── FormulaEvaluation.h │ ├── FormulaEvaluationComplexity.h │ ├── FormulaEvaluationGraph.cpp │ ├── FormulaEvaluationGraph.h │ ├── Sampling.h │ ├── Simplification.cpp │ ├── Simplification.h │ ├── VariableOrdering.h │ └── types.h ├── smtrat-expressions │ ├── Expression.cpp │ ├── Expression.h │ ├── ExpressionContent.cpp │ ├── ExpressionContent.h │ ├── ExpressionConverter.h │ ├── ExpressionHash.h │ ├── ExpressionPool.cpp │ ├── ExpressionPool.h │ ├── ExpressionTest.h │ ├── ExpressionTypes.h │ ├── ExpressionVisitor.h │ ├── README.md │ └── simplifier │ │ ├── BaseSimplifier.h │ │ ├── DuplicateSimplifier.h │ │ ├── MergeSimplifier.h │ │ ├── NegationSimplifier.h │ │ ├── Simplifier.h │ │ └── SingletonSimplifier.h ├── smtrat-fmplex │ ├── CMakeLists.txt │ ├── Matrix.h │ ├── Node.h │ ├── eliminate.cpp │ ├── eliminate.h │ ├── fmplex.cpp │ └── fmplex.h ├── smtrat-max-smt │ ├── CMakeLists.txt │ ├── MaxSMT.h │ ├── MaxSMT_FuMalikIncremental.h │ ├── MaxSMT_LinearSearch.h │ ├── MaxSMT_MSU3.h │ ├── smtrat-max-smt.cpp │ └── smtrat-max-smt.h ├── smtrat-mcsat │ ├── CMakeLists.txt │ ├── assignments │ │ ├── SequentialAssignment.h │ │ ├── arithmetic │ │ │ ├── AAFStatistics.h │ │ │ ├── AssignmentFinder.cpp │ │ │ ├── AssignmentFinder.h │ │ │ ├── AssignmentFinder_arithmetic.h │ │ │ ├── AssignmentFinder_ctx.h │ │ │ ├── Covering.h │ │ │ └── RootIndexer.h │ │ └── smtaf │ │ │ ├── AssignmentFinder.h │ │ │ ├── AssignmentFinder_SMT.cpp │ │ │ ├── AssignmentFinder_SMT.h │ │ │ └── SMTAFStatistics.h │ ├── explanations │ │ ├── FastParallelExplanation.h │ │ ├── FullParallelExplanation.h │ │ ├── ParallelExplanation.h │ │ ├── SequentialExplanation.h │ │ ├── fm │ │ │ ├── ConflictGenerator.h │ │ │ ├── Explanation.cpp │ │ │ ├── Explanation.h │ │ │ └── FMStatistics.h │ │ ├── icp │ │ │ ├── Dependencies.h │ │ │ ├── Explanation.cpp │ │ │ ├── Explanation.h │ │ │ ├── ICPStatistics.h │ │ │ └── IntervalPropagation.h │ │ ├── nlsat │ │ │ ├── Explanation.cpp │ │ │ ├── Explanation.h │ │ │ ├── ExplanationGenerator.h │ │ │ └── NLSATStatistics.h │ │ ├── onecell │ │ │ ├── Explanation.h │ │ │ ├── OCStatistics.h │ │ │ └── onecell.h │ │ ├── onecellcad │ │ │ ├── Assertables.h │ │ │ ├── OCStatistics.h │ │ │ ├── RealAlgebraicPoint.h │ │ │ ├── levelwise │ │ │ │ ├── Explanation.cpp │ │ │ │ ├── Explanation.h │ │ │ │ └── OneCellCAD.h │ │ │ ├── recursive │ │ │ │ ├── Explanation.cpp │ │ │ │ ├── Explanation.h │ │ │ │ ├── OneCellCAD.h │ │ │ │ └── OpenCAD.h │ │ │ ├── utils.cpp │ │ │ └── utils.h │ │ └── vs │ │ │ ├── Explanation.cpp │ │ │ ├── Explanation.h │ │ │ ├── ExplanationGenerator.h │ │ │ ├── VSHelper.h │ │ │ └── VSStatistics.h │ ├── smtrat-mcsat.cpp │ ├── smtrat-mcsat.h │ ├── utils │ │ ├── Bookkeeping.cpp │ │ ├── Bookkeeping.h │ │ ├── ClauseChain.cpp │ │ ├── ClauseChain.h │ │ ├── ConstraintCategorization.h │ │ └── RootExpr.h │ └── variableordering │ │ ├── VariableOrdering.h │ │ ├── feature_based.h │ │ ├── greedy_max_univariate.h │ │ └── helper.h ├── smtrat-modules │ ├── .gitignore │ ├── BEModule │ │ ├── BEModule.h │ │ ├── BEModule.md │ │ ├── BEModule.tpp │ │ ├── BESettings.h │ │ ├── CMakeLists.txt │ │ └── Instantiation.cpp.in │ ├── BVModule │ │ ├── BVDirectEncoder.h │ │ ├── BVModule.h │ │ ├── BVModule.md │ │ ├── BVModule.tpp │ │ ├── BVSettings.h │ │ ├── CMakeLists.txt │ │ └── Instantiation.cpp.in │ ├── CMakeLists.txt │ ├── CNFerModule │ │ ├── CMakeLists.txt │ │ ├── CNFerModule.h │ │ ├── CNFerModule.md │ │ ├── CNFerModule.tpp │ │ └── CNFerModuleStatistics.h │ ├── CSplitModule │ │ ├── Bimap.h │ │ ├── CMakeLists.txt │ │ ├── CSplitModule.h │ │ ├── CSplitModule.md │ │ ├── CSplitModule.tpp │ │ ├── CSplitSettings.h │ │ └── Instantiation.cpp.in │ ├── CoCoAGBModule │ │ ├── CMakeLists.txt │ │ ├── CoCoAGBModule.h │ │ ├── CoCoAGBModule.md │ │ ├── CoCoAGBModule.tpp │ │ ├── CoCoAGBSettings.h │ │ └── Instantiation.cpp.in │ ├── CoveringNGModule │ │ ├── CMakeLists.txt │ │ ├── CoveringNGModule.h │ │ ├── CoveringNGModule.tpp │ │ ├── CoveringNGSettings.h │ │ └── Instantiation.cpp.in │ ├── CubeLIAModule │ │ ├── CMakeLists.txt │ │ ├── CubeLIAModule.h │ │ ├── CubeLIAModule.md │ │ ├── CubeLIAModule.tpp │ │ ├── CubeLIASettings.h │ │ └── Instantiation.cpp.in │ ├── CurryModule │ │ ├── CMakeLists.txt │ │ ├── CurryModule.h │ │ ├── CurryModule.md │ │ ├── CurryModule.tpp │ │ ├── CurrySettings.h │ │ └── Instantiation.cpp.in │ ├── EMModule │ │ ├── CMakeLists.txt │ │ ├── EMModule.h │ │ ├── EMModule.md │ │ ├── EMModule.tpp │ │ ├── EMSettings.h │ │ └── Instantiation.cpp.in │ ├── ESModule │ │ ├── CMakeLists.txt │ │ ├── ESModule.h │ │ ├── ESModule.md │ │ ├── ESModule.tpp │ │ ├── ESSettings.h │ │ └── Instantiation.cpp.in │ ├── FPPModule │ │ ├── CMakeLists.txt │ │ ├── FPPModule.h │ │ ├── FPPModule.md │ │ ├── FPPModule.tpp │ │ ├── FPPSettings.h │ │ ├── FPPStatistics.h │ │ └── Instantiation.cpp.in │ ├── GBModule │ │ ├── CHANGELOG │ │ ├── CMakeLists.txt │ │ ├── GBCalculationStatistics.cpp │ │ ├── GBCalculationStatistics.h │ │ ├── GBModule.h │ │ ├── GBModule.md │ │ ├── GBModule.tpp │ │ ├── GBModuleState.h │ │ ├── GBModuleStatistics.cpp │ │ ├── GBModuleStatistics.h │ │ ├── GBSettings.h │ │ ├── InequalitiesTable.h │ │ ├── InequalitiesTable.tpp │ │ ├── Instantiation.cpp.in │ │ ├── RewriteRules.h │ │ ├── UsingDeclarations.h │ │ └── VariableRewriteRule.h │ ├── GBPPModule │ │ ├── CMakeLists.txt │ │ ├── GBPPModule.h │ │ ├── GBPPModule.md │ │ ├── GBPPModule.tpp │ │ ├── GBPPSettings.h │ │ └── Instantiation.cpp.in │ ├── ICEModule │ │ ├── CMakeLists.txt │ │ ├── ForwardHyperGraph.h │ │ ├── ForwardHyperGraph.tpp │ │ ├── ICEModule.h │ │ ├── ICEModule.md │ │ ├── ICEModule.tpp │ │ ├── ICESettings.h │ │ └── Instantiation.cpp.in │ ├── ICPModule │ │ ├── CMakeLists.txt │ │ ├── ContractionCandidate.cpp │ │ ├── ContractionCandidate.h │ │ ├── ContractionCandidateManager.cpp │ │ ├── ContractionCandidateManager.h │ │ ├── HistoryNode.h │ │ ├── ICPModule.h │ │ ├── ICPModule.md │ │ ├── ICPModule.tpp │ │ ├── ICPSettings.h │ │ ├── IcpVariable.h │ │ ├── Instantiation.cpp.in │ │ ├── utils.cpp │ │ └── utils.h │ ├── IncWidthModule │ │ ├── CMakeLists.txt │ │ ├── IncWidthModule.h │ │ ├── IncWidthModule.md │ │ ├── IncWidthModule.tpp │ │ ├── IncWidthSettings.h │ │ └── Instantiation.cpp.in │ ├── IntBlastModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── IntBlastModule.h │ │ ├── IntBlastModule.md │ │ ├── IntBlastModule.tpp │ │ ├── IntBlastSettings.h │ │ ├── PolyTree.cpp │ │ ├── PolyTree.h │ │ ├── PolyTreePool.cpp │ │ └── PolyTreePool.h │ ├── IntEqModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── IntEqModule.h │ │ ├── IntEqModule.md │ │ ├── IntEqModule.tpp │ │ └── IntEqSettings.h │ ├── LRAModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── LRAModule.h │ │ ├── LRAModule.md │ │ ├── LRAModule.tpp │ │ ├── LRAModuleStatistics.h │ │ ├── LRASettings.h │ │ └── tableau │ │ │ ├── Bound.h │ │ │ ├── Bound.tpp │ │ │ ├── Numeric.cpp │ │ │ ├── Numeric.h │ │ │ ├── Tableau.h │ │ │ ├── Tableau.tpp │ │ │ ├── TableauSettings.h │ │ │ ├── Value.h │ │ │ ├── Value.tpp │ │ │ ├── Variable.h │ │ │ └── Variable.tpp │ ├── LVEModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── LVEModule.h │ │ ├── LVEModule.md │ │ ├── LVEModule.tpp │ │ ├── LVESettings.h │ │ ├── LVEStatistics.h │ │ └── utils.h │ ├── MCBModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── MCBModule.h │ │ ├── MCBModule.md │ │ ├── MCBModule.tpp │ │ └── MCBSettings.h │ ├── NRAILModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── LOG.h │ │ ├── MonomialMappingByVariablePool.h │ │ ├── NRAILModule.h │ │ ├── NRAILModule.md │ │ ├── NRAILModule.tpp │ │ ├── NRAILSettings.h │ │ ├── Util.h │ │ ├── dto │ │ │ ├── RationalCapsule.cpp │ │ │ ├── RationalCapsule.h │ │ │ ├── VariableCapsule.cpp │ │ │ └── VariableCapsule.h │ │ └── factory │ │ │ ├── AxiomFactory.cpp │ │ │ └── AxiomFactory.h │ ├── NewCADModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── NewCADModule.h │ │ ├── NewCADModule.md │ │ ├── NewCADModule.tpp │ │ ├── NewCADSettings.h.in │ │ └── NewCADStatistics.h │ ├── NewCoveringModule │ │ ├── Backend.h │ │ ├── CMakeLists.txt │ │ ├── Helper.h │ │ ├── Instantiation.cpp.in │ │ ├── LevelWiseInformation.h │ │ ├── NewCoveringModule.h │ │ ├── NewCoveringModule.md │ │ ├── NewCoveringModule.tpp │ │ ├── NewCoveringSettings.h │ │ ├── NewCoveringStatistics.h │ │ └── Sampling.h │ ├── NewGBPPModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── NewGBPPModule.h │ │ ├── NewGBPPModule.tpp │ │ └── NewGBPPSettings.h │ ├── NuCADModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── NuCADModule.h │ │ ├── NuCADModule.tpp │ │ └── NuCADSettings.h │ ├── PBGaussModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── PBGaussModule.h │ │ ├── PBGaussModule.md │ │ ├── PBGaussModule.tpp │ │ └── PBGaussSettings.h │ ├── PBPPModule │ │ ├── CMakeLists.txt │ │ ├── Encoders │ │ │ ├── CardinalityEncoder.cpp │ │ │ ├── CardinalityEncoder.h │ │ │ ├── ExactlyOneCommanderEncoder.cpp │ │ │ ├── ExactlyOneCommanderEncoder.h │ │ │ ├── LongFormulaEncoder.cpp │ │ │ ├── LongFormulaEncoder.h │ │ │ ├── MixedSignEncoder.cpp │ │ │ ├── MixedSignEncoder.h │ │ │ ├── PseudoBoolEncoder.cpp │ │ │ ├── PseudoBoolEncoder.h │ │ │ ├── PseudoBoolNormalizer.cpp │ │ │ ├── PseudoBoolNormalizer.h │ │ │ ├── RNSEncoder.cpp │ │ │ ├── RNSEncoder.h │ │ │ ├── ShortFormulaEncoder.cpp │ │ │ ├── ShortFormulaEncoder.h │ │ │ ├── TotalizerEncoder.cpp │ │ │ └── TotalizerEncoder.h │ │ ├── Instantiation.cpp.in │ │ ├── PBPPModule.h │ │ ├── PBPPModule.md │ │ ├── PBPPModule.tpp │ │ ├── PBPPSettings.h │ │ └── PBPPStatistics.h │ ├── PFEModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── PFEModule.h │ │ ├── PFEModule.md │ │ ├── PFEModule.tpp │ │ └── PFESettings.h │ ├── PNFerModule │ │ ├── CMakeLists.txt │ │ ├── PNFerModule.cpp │ │ ├── PNFerModule.h │ │ └── PNFerModule.md │ ├── SATModule │ │ ├── Alg.h │ │ ├── Alloc.h │ │ ├── CMakeLists.txt │ │ ├── ClauseChecker.h │ │ ├── Heap.h │ │ ├── Instantiation.cpp.in │ │ ├── IntTypes.h │ │ ├── Map.h │ │ ├── Options.cpp │ │ ├── Options.h │ │ ├── Queue.h │ │ ├── SATModule.h │ │ ├── SATModule.md │ │ ├── SATModule.tpp │ │ ├── SATModuleStatistics.h │ │ ├── SATSettings.h │ │ ├── SATSettings.old.txt │ │ ├── SolverTypes.h │ │ ├── Sort.h │ │ ├── VarScheduler.h │ │ ├── VarSchedulerForwardDeclarations.h │ │ ├── Vec.h │ │ ├── XAlloc.h │ │ └── mcsat │ │ │ ├── BaseBackend.h │ │ │ ├── MCSATMixin.h │ │ │ ├── MCSATMixin.tpp │ │ │ ├── MCSATSettings.h │ │ │ ├── MCSATStatistics.h │ │ │ └── VarSchedulerMcsat.h │ ├── STropModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── STropModule.h │ │ ├── STropModule.md │ │ ├── STropModule.tpp │ │ ├── STropModuleStatistics.h │ │ ├── STropSettings.h │ │ └── Subtropical.h │ ├── SimplexModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── SimplexModule.h │ │ ├── SimplexModule.md │ │ ├── SimplexModule.tpp │ │ ├── SimplexSettings.h │ │ ├── SimplexStatistics.h │ │ └── simplex │ │ │ ├── Bound.h │ │ │ ├── DeltaValue.h │ │ │ ├── DeltaValue.tpp │ │ │ ├── SparseVector.h │ │ │ ├── Tableau.h │ │ │ ├── Tableau.tpp │ │ │ └── VariableInfo.h │ ├── SplitSOSModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── SplitSOSModule.h │ │ ├── SplitSOSModule.md │ │ ├── SplitSOSModule.tpp │ │ └── SplitSOSSettings.h │ ├── SymmetryModule │ │ ├── CMakeLists.txt │ │ ├── Instantiation.cpp.in │ │ ├── SymmetryModule.h │ │ ├── SymmetryModule.md │ │ ├── SymmetryModule.tpp │ │ └── SymmetrySettings.h │ └── VSModule │ │ ├── CMakeLists.txt │ │ ├── Condition.cpp │ │ ├── Condition.h │ │ ├── Instantiation.cpp.in │ │ ├── State.cpp │ │ ├── State.h │ │ ├── Substitute.cpp │ │ ├── Substitute.h │ │ ├── Substitution.cpp │ │ ├── Substitution.h │ │ ├── VSModule.h │ │ ├── VSModule.md │ │ ├── VSModule.tpp │ │ ├── VSSettings.h │ │ ├── VSSettings.h.old.txt │ │ └── VSStatistics.h ├── smtrat-optimization │ ├── CMakeLists.txt │ ├── Optimization.h │ ├── smtrat-optimization.cpp │ └── smtrat-optimization.h ├── smtrat-qe │ ├── CMakeLists.txt │ ├── QEQuery.h │ ├── Statistics.h │ ├── cad │ │ ├── CAD.h │ │ ├── CADElimination.cpp │ │ ├── CADElimination.h │ │ ├── Projection.h │ │ ├── qe.cpp │ │ └── qe.h │ ├── coverings │ │ ├── Settings.h │ │ ├── config.h.in │ │ ├── qe.cpp │ │ ├── qe.h │ │ └── util │ │ │ ├── to_formula.cpp │ │ │ └── to_formula.h │ ├── fm │ │ ├── FMQEStatistics.h │ │ ├── FourierMotzkinQE.cpp │ │ ├── FourierMotzkinQE.h │ │ ├── eigen_helpers.h │ │ ├── qe.cpp │ │ └── qe.h │ ├── fmplex │ │ ├── FMplexQE.cpp │ │ ├── FMplexQE.h │ │ ├── FMplexQEStatistics.h │ │ ├── Node.h │ │ ├── qe.cpp │ │ └── qe.h │ ├── nucad │ │ ├── Settings.h │ │ ├── config.h.in │ │ ├── qe.cpp │ │ ├── qe.h │ │ └── util │ │ │ ├── to_formula.cpp │ │ │ └── to_formula.h │ ├── smtrat-qe.cpp │ ├── smtrat-qe.h │ └── util │ │ ├── EqualitySubstitution.h │ │ ├── Matrix.h │ │ ├── VariableIndex.h │ │ ├── quantifier_splitting.h │ │ └── redundancies.h ├── smtrat-solver │ ├── CMakeLists.txt │ ├── Manager.cpp │ ├── Manager.h │ ├── Module.cpp │ ├── Module.h │ ├── ModuleInput.cpp │ ├── ModuleInput.h │ ├── PModule.cpp │ ├── PModule.h │ ├── StrategyGraph.h │ ├── ThreadPool.cpp │ ├── ThreadPool.h │ └── smtrat-solver.h ├── smtrat-strategies │ ├── CMakeLists.txt │ ├── config.h.in │ ├── smtrat-strategies.cpp │ ├── smtrat-strategies.h │ └── strategies │ │ ├── AllModulesStrategy.h │ │ ├── Approximation │ │ ├── NOOP.h │ │ ├── PWL2Segments.h │ │ ├── PWL4Segments.h │ │ ├── PWL6Segments.h │ │ ├── Simple.h │ │ ├── Taylor.h │ │ └── common.h │ │ ├── BVSolver.h │ │ ├── CoveringNG │ │ ├── Default.h │ │ ├── DefaultAPX.h │ │ ├── DefaultBC.h │ │ ├── DefaultBCFilter.h │ │ ├── DefaultBCFilterEW.h │ │ ├── DefaultBCFilterIncomplete.h │ │ ├── DefaultBCpdel.h │ │ ├── DefaultCompound.h │ │ ├── GBDefault.h │ │ ├── PPBooleanExploration.h │ │ ├── PPBooleanExplorationOnlyBool.h │ │ ├── PPBooleanExplorationWithBool.h │ │ ├── PPBooleanOff.h │ │ ├── PPBooleanPartialPropagationSotd.h │ │ ├── PPBooleanPartialPropagationTdeg.h │ │ ├── PPBooleanPropagation.h │ │ ├── PPDefault.h │ │ ├── PPFilterBoundsOnly.h │ │ ├── PPFilterBoundsOnlyComplete.h │ │ ├── PPFilterNoop.h │ │ ├── PPGBDefault.h │ │ ├── PPImplicantsLevelSize.h │ │ ├── PPImplicantsLevelSotd.h │ │ ├── PPImplicantsPickeringTotal.h │ │ ├── PPImplicantsSizeOnly.h │ │ ├── PPImplicantsSotd.h │ │ ├── PPImplicantsSotdReverse.h │ │ ├── PPImplicantsTdeg.h │ │ ├── PPImplicantsVars.h │ │ ├── PPImplicantsVarsVarorderSplitting.h │ │ ├── PPInprocessingOn.h │ │ ├── PPSATDefault.h │ │ ├── PPSTropDefault.h │ │ ├── PPVarorderPickering.h │ │ └── PPVarorderUnivariate.h │ │ ├── Default.h │ │ ├── Filter │ │ ├── BCAll.h │ │ ├── BCBc.h │ │ ├── BCBoundsOnly.h │ │ ├── BCBoundsOnlyIntersect.h │ │ ├── BCDeg10.h │ │ ├── BCDeg2.h │ │ ├── BCDeg5.h │ │ ├── BCIndep.h │ │ ├── BCIntersect.h │ │ ├── BCIrred.h │ │ ├── BCIrredIndep.h │ │ ├── BCIrredIndepRational.h │ │ ├── BCIrredIndepRationalBounds.h │ │ ├── BCIrredIndepRationalIntersect.h │ │ ├── BCNoop.h │ │ ├── BCRational.h │ │ ├── LDBBoundsOnly.h │ │ ├── LDBBoundsOnlyComplete.h │ │ ├── LDBNoop.h │ │ └── LDBNoopComplete.h │ │ ├── LRASolver.h │ │ ├── MCSAT │ │ ├── NL.h │ │ ├── OC.h │ │ ├── OCNewBC.h │ │ ├── OCNewBCincomplete.h │ │ ├── OCNewBCpdel.h │ │ ├── OCNewBCpdelIncomplete.h │ │ ├── OCNewCompound.h │ │ ├── OCNewLDB.h │ │ ├── OCNewLDBCovering.h │ │ ├── OCNewLDBCoveringCache.h │ │ ├── OCNewLDBCoveringCacheGlobal.h │ │ ├── OCNewLDBpdel.h │ │ ├── OCNewOptimalFB.h │ │ ├── OCNewOptimalNM.h │ │ ├── OCNewOptimalNR.h │ │ ├── OCNewOptimalNV.h │ │ ├── OCNewOptimalSOTD.h │ │ ├── OCNewOptimalTDE.h │ │ ├── OCNewOptimalTDUB.h │ │ ├── OCNewOptimalVD.h │ │ ├── PPDefault.h │ │ ├── PPFMICPVSOCAPX.h │ │ ├── PPFMICPVSOCBC.h │ │ └── PPOC.h │ │ ├── MIS │ │ ├── Exact.h │ │ ├── Greedy.h │ │ ├── GreedyExact.h │ │ ├── GreedyPre.h │ │ ├── GreedyWeighted.h │ │ ├── Hybrid.h │ │ └── Trivial.h │ │ ├── NIA │ │ ├── NIABB.h │ │ ├── NIABlast.h │ │ └── NIASolver.h │ │ ├── NRARefinement │ │ ├── Solver.h │ │ ├── Solver1.h │ │ ├── Solver10.h │ │ ├── Solver11.h │ │ ├── Solver12.h │ │ ├── Solver13.h │ │ ├── Solver14.h │ │ ├── Solver15.h │ │ ├── Solver16.h │ │ ├── Solver17.h │ │ ├── Solver18.h │ │ ├── Solver19.h │ │ ├── Solver2.h │ │ ├── Solver20.h │ │ ├── Solver21.h │ │ ├── Solver22.h │ │ ├── Solver23.h │ │ ├── Solver24.h │ │ ├── Solver25.h │ │ ├── Solver3.h │ │ ├── Solver4.h │ │ ├── Solver5.h │ │ ├── Solver6.h │ │ ├── Solver7.h │ │ ├── Solver8.h │ │ └── Solver9.h │ │ ├── NewCAD │ │ ├── Brown.h │ │ ├── Collins.h │ │ ├── FOS.h │ │ ├── FU.h │ │ ├── FU_SC.h │ │ ├── FU_SI.h │ │ ├── FU_SInf.h │ │ ├── FU_SL.h │ │ ├── FU_SR.h │ │ ├── FU_SZ.h │ │ ├── Hong.h │ │ ├── LOLS.h │ │ ├── LOLT.h │ │ ├── LOLTA.h │ │ ├── LOLTS.h │ │ ├── LOLTSA.h │ │ ├── LOS.h │ │ ├── LOT.h │ │ ├── LOTLSA.h │ │ ├── LOTS.h │ │ ├── LOTSA.h │ │ ├── McCallum.h │ │ ├── McCallumPartial.h │ │ ├── NO.h │ │ ├── NRA_CAD.h │ │ ├── NRA_ICPVSCAD.h │ │ ├── NRA_LRAVSCAD.h │ │ ├── NRA_VSCAD.h │ │ ├── NU.h │ │ ├── Naive.h │ │ ├── Only.h │ │ ├── POD.h │ │ ├── POLD.h │ │ ├── POPD.h │ │ ├── POSD.h │ │ ├── PP.h │ │ ├── PPRR.h │ │ ├── PPVE.h │ │ ├── PPVERR.h │ │ ├── SAT.h │ │ ├── SO.h │ │ └── SU.h │ │ ├── NewCADEQ │ │ ├── B.h │ │ ├── BD.h │ │ ├── BR.h │ │ ├── BRD.h │ │ ├── BRI.h │ │ ├── BRID.h │ │ ├── BS.h │ │ ├── BSD.h │ │ ├── BSI.h │ │ ├── BSID.h │ │ ├── R.h │ │ ├── RD.h │ │ ├── RI.h │ │ ├── RID.h │ │ ├── S.h │ │ ├── SD.h │ │ ├── SI.h │ │ └── SID.h │ │ ├── NewCovering │ │ ├── Backtracking.h │ │ ├── FilterBoundsOnly.h │ │ ├── Incomplete.h │ │ ├── Incremental.h │ │ ├── IncrementalBacktracking.h │ │ ├── PPComplete.h │ │ ├── PPFilterBoundsOnly.h │ │ ├── PPFilterBoundsOnlyComplete.h │ │ ├── PPIncomplete.h │ │ └── Vanilla.h │ │ ├── NuCAD │ │ ├── Default.h │ │ ├── DefaultBCFilter.h │ │ ├── DefaultBCFilterEW.h │ │ └── PPDefault.h │ │ ├── OnlyCAD.h │ │ ├── OnlyGB.h │ │ ├── OnlySAT.h │ │ ├── OnlyVS.h │ │ ├── Optimization │ │ ├── MAXSATBackendStrategy.h │ │ ├── MAXSMTPBPPStrategy.h │ │ └── OptimizationStrategy.h │ │ ├── Preprocessing │ │ ├── BVPreprocessing.h │ │ ├── OptimizationPreprocessing.h │ │ ├── PBPreprocessing.h │ │ ├── PreprocessingOne.h │ │ └── PreprocessingTwo.h │ │ ├── PseudoBool │ │ ├── PBPPStrategy.h │ │ ├── PBPPStrategy2.h │ │ ├── PBPPStrategyBasic.h │ │ ├── PBPPStrategyGauss.h │ │ ├── PBPPStrategyGroe_Norm_PB_LIA.h │ │ ├── PBPPStrategyGroe_PB_LIA.h │ │ ├── PBPPStrategyGroebner.h │ │ ├── PBPPStrategyLIA.h │ │ ├── PBPPStrategyLIAOnly.h │ │ ├── PBPPStrategyLIA_ICP.h │ │ ├── PBPPStrategyLIA_VS.h │ │ ├── PBPPStrategyNorm_LIA.h │ │ ├── PBPPStrategyNorm_LIA_ICP.h │ │ ├── PBPPStrategyNorm_LIA_VS.h │ │ ├── PBPPStrategyNorm_PB_LIA.h │ │ ├── PBPPStrategyPB_LIA.h │ │ ├── PBPPStrategyRNS.h │ │ ├── PBPPStrategyWithCardConstr.h │ │ └── PBPPStrategyWithMixedConstr.h │ │ ├── SMTCOMP.h │ │ ├── STrop │ │ ├── BackendsOnly.h │ │ ├── CADBackendsOnly.h │ │ ├── Formula.h │ │ ├── FormulaAlt.h │ │ ├── FormulaAltOutputOnly.h │ │ ├── FormulaAltWCADBackends.h │ │ ├── FormulaAltWCADBackendsFull.h │ │ ├── FormulaOutputOnly.h │ │ ├── FormulaWBackends.h │ │ ├── FormulaWBackendsFull.h │ │ ├── FormulaWCADBackends.h │ │ ├── FormulaWCADBackendsFull.h │ │ ├── FormulaWMCSAT.h │ │ ├── Incremental.h │ │ ├── IncrementalWBackends.h │ │ ├── IncrementalWCADBackends.h │ │ ├── MCSATOnly.h │ │ ├── TransformationEQ.h │ │ ├── TransformationEQOutputOnly.h │ │ ├── TransformationEQWBackends.h │ │ └── TransformationEQWCADBackends.h │ │ └── Simplex.h ├── smtrat-unsat-cores │ ├── CMakeLists.txt │ ├── UnsatCore.h │ ├── UnsatCore_ModelExclusion.h │ ├── smtrat-unsat-cores.cpp │ └── smtrat-unsat-cores.h ├── smtrat-variablebounds │ ├── CMakeLists.txt │ ├── VariableBounds.h │ ├── VariableBounds.tpp │ ├── smtrat-variablebounds.cpp │ └── smtrat-variablebounds.h └── tests │ ├── CMakeLists.txt │ ├── Common.cpp │ ├── fourierMotzkinQE │ ├── CMakeLists.txt │ └── Test_fmqe.cpp │ ├── horner │ └── HornerSchemeTest.cpp │ ├── mcsat │ ├── CMakeLists.txt │ ├── Test_Explanation_ICP.cpp │ └── Test_MCSAT.cpp │ ├── mcsatvs │ ├── CMakeLists.txt │ ├── Test_ExplanationGenerator.cpp │ ├── Test_MCSATVS.cpp │ └── Test_McsatVSBug.cpp │ ├── nlsat │ ├── CMakeLists.txt │ ├── Test_AssignmentFinder.cpp │ ├── Test_Checkpoints_Sample1.cpp │ ├── Test_Explanation_FM.cpp │ ├── Test_NLSAT.cpp │ └── Test_SATModule.cpp │ ├── onecellcad │ ├── CMakeLists.txt │ ├── Test_OneCellCAD.cpp │ ├── Test_OneCellCADBug.cpp │ └── Test_OpenCad.cpp │ ├── pseudobool │ ├── CMakeLists.txt │ ├── Test_CardinalityEncoder.cpp │ └── Test_Encoder.cpp │ ├── smtrat-cadcells │ ├── CMakeLists.txt │ ├── compound_bounds.cpp │ ├── datastructures_polynomials.cpp │ ├── filter_util.cpp │ └── single_cell.cpp │ └── smtrat-mcsat │ ├── CMakeLists.txt │ └── explanation_onecell.cpp └── utilities └── writeModules.py /.ci/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu:latest 2 | 3 | ENV DEBIAN_FRONTEND=noninteractive 4 | RUN apt-get update -y ; apt-get install -y make texinfo time uuid-dev libboost-all-dev cmake flex bison ghostscript libclang-13-dev lmodern texinfo texlive texlive-font-utils texlive-latex-extra texlive-plain-generic python3-pip python3-setuptools 5 | RUN apt-get update -y ; apt-get install -y git libtool libgmp-dev python3 6 | RUN apt-get update -y ; apt-get install -y clang-14 clang-13 g++-12 g++-11 libc++-dev 7 | RUN apt-get update -y ; apt-get install -y imagemagick curl libgtest-dev 8 | RUN apt-get update -y ; apt-get install -y doxygen doxygen-doc doxygen-gui graphviz doxygen-latex libiconv-hook-dev doxygen-latex doxygen-doc doxygen-gui xapian-tools 9 | 10 | RUN git config --global user.email "runner@ths.rwth-aachen.de" -------------------------------------------------------------------------------- /.clang-format: -------------------------------------------------------------------------------- 1 | Language: Cpp 2 | BasedOnStyle: LLVM 3 | 4 | AccessModifierOffset: -4 5 | AllowShortFunctionsOnASingleLine: Empty 6 | AllowShortIfStatementsOnASingleLine: true 7 | AlwaysBreakTemplateDeclarations: true 8 | BreakStringLiterals: false 9 | ColumnLimit: 0 10 | IndentWidth: 4 11 | PointerAlignment: Left 12 | SpaceAfterTemplateKeyword: false 13 | SpacesInContainerLiterals: false 14 | TabWidth: 4 15 | UseTab: Always 16 | -------------------------------------------------------------------------------- /.codeclimate.yml: -------------------------------------------------------------------------------- 1 | plugins: 2 | cppcheck: 3 | enabled: true 4 | -------------------------------------------------------------------------------- /.github/actions/compile/action.yml: -------------------------------------------------------------------------------- 1 | name: Build 2 | description: Build smtrat 3 | inputs: 4 | build-env: 5 | description: "Environment variables for the build" 6 | required: true 7 | default: "" 8 | 9 | runs: 10 | using: "composite" 11 | steps: 12 | - name: Configure CMake 13 | shell: bash 14 | run: | 15 | echo "::group::Configure CMake" 16 | export ${{inputs.build-env}} 17 | cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} 18 | echo "::group::Configure CMake done" 19 | - name: Build smtrat 20 | shell: bash 21 | run: | 22 | echo "::group::Build smtrat" 23 | cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target all -j$(nproc) 24 | echo "::group::Build smtrat done" 25 | -------------------------------------------------------------------------------- /.github/actions/install_dependencies/action.yml: -------------------------------------------------------------------------------- 1 | name: Install Dependencies 2 | description: Install all necessary dependencies for smtrat 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Install Linux Dependencies 7 | if: runner.os == 'Linux' 8 | shell: bash 9 | run: | 10 | echo "::group::Install Linux Dependencies" 11 | sudo apt update 12 | sudo apt install -y libgmp-dev libboost-all-dev libeigen3-dev libreadline-dev libgtest-dev clang-12 13 | echo "::group::Install Linux Dependencies done" 14 | 15 | - name: "Install macOS Dependencies" 16 | if: runner.os == 'macOS' 17 | shell: bash 18 | run: | 19 | echo "::group::Install macOS Dependencies" 20 | brew install gmp boost eigen readline flex gnu-sed cln 21 | echo "::group::Install macOS Dependencies done" -------------------------------------------------------------------------------- /.github/actions/run_tests/action.yml: -------------------------------------------------------------------------------- 1 | name: Run tests 2 | description: Run all tests for smtrat 3 | 4 | runs: 5 | using: "composite" 6 | steps: 7 | - name: Build Tests 8 | shell: bash 9 | run: | 10 | echo "::group::Build Tests" 11 | cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target all-tests -j$(nproc) 12 | echo "::group::Build Tests done" 13 | 14 | - name: Run CTest 15 | shell: bash 16 | run: | 17 | echo "::group::Run CTest" 18 | cd build 19 | if ! ctest -C ${{env.BUILD_TYPE}} -j$(nproc) --output-on-failure 20 | then 21 | echo "::error::Tests failed" 22 | ctest --output-on-failure --rerun-failed 23 | fi 24 | echo "::group::Run CTest done" -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | *~ 3 | **/config.h 4 | **/config.txt 5 | **/compile_information.cpp 6 | /build/ 7 | /cmake-build-debug/ 8 | /.idea/ 9 | .vscode 10 | /nbproject/ 11 | /src/smtrat-modules/NewCADModule/NewCADSettings.h 12 | CMakeCache.txt 13 | CMakeFiles/cmake.check_cache 14 | **.pyc 15 | src/smtrat-modules/null.cpp 16 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ubuntu:latest as lib-base 2 | ARG DEBIAN_FRONTEND=noninteractive 3 | RUN apt-get update && \ 4 | apt-get -y --no-install-recommends install \ 5 | cmake \ 6 | make \ 7 | clang \ 8 | g++ \ 9 | git \ 10 | patch \ 11 | libgmp3-dev \ 12 | libeigen3-dev \ 13 | libboost-all-dev \ 14 | ca-certificates 15 | 16 | FROM lib-base as builder 17 | COPY . /smtrat-src/ 18 | WORKDIR /smtrat-src/build/ 19 | RUN cmake -D USE_MIMALLOC=ON .. 20 | RUN make mimalloc-EP 21 | RUN make smtrat-static 22 | WORKDIR /smtrat-src/ 23 | 24 | FROM builder as smtrat 25 | ENV LD_PRELOAD=/smtrat-src/resources/lib/mimalloc-1.6/libmimalloc.so 26 | ENTRYPOINT [ "/smtrat-src/build/smtrat-static" ] -------------------------------------------------------------------------------- /cmake/clang-time-trace.cmake: -------------------------------------------------------------------------------- 1 | option(CLANG_TIME_TRACE "Enable clang profiling." OFF) 2 | 3 | if(CLANG_TIME_TRACE) 4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftime-trace") 5 | endif() -------------------------------------------------------------------------------- /cmake/export.cmake: -------------------------------------------------------------------------------- 1 | option(EXPORT_TO_CMAKE "Export the project to CMake for easy inclusion" ON) 2 | 3 | export(EXPORT smtrat-targets FILE "${PROJECT_BINARY_DIR}/smtratTargets.cmake") 4 | 5 | if(EXPORT_TO_CMAKE) 6 | # Export the package for use from the build-tree 7 | # (this registers the build-tree with a global CMake-registry) 8 | export(PACKAGE smtrat) 9 | endif() 10 | -------------------------------------------------------------------------------- /cmake/install.cmake: -------------------------------------------------------------------------------- 1 | include(GNUInstallDirs) 2 | 3 | install( 4 | DIRECTORY 5 | ${CMAKE_SOURCE_DIR}/src/lib 6 | ${CMAKE_SOURCE_DIR}/src/smtrat-common 7 | ${CMAKE_SOURCE_DIR}/src/smtrat-qe 8 | DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/smtrat 9 | FILES_MATCHING REGEX ".*\.(h|tpp)$" 10 | ) 11 | 12 | #install( 13 | # EXPORT smtratTar 14 | # RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} 15 | # LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} 16 | # ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} 17 | #) 18 | 19 | #install(FILES ${CMAKE_BINARY_DIR}/carlConfig.install.cmake DESTINATION ${CMAKE_INSTALL_DIR} RENAME carlConfig.cmake) 20 | #install(FILES ${CMAKE_BINARY_DIR}/carlConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DIR}) 21 | install(EXPORT smtrat-targets FILE smtratTargets.cmake DESTINATION ${CMAKE_INSTALL_DIR}) 22 | -------------------------------------------------------------------------------- /doc/apidoc-pdf/footer.tex: -------------------------------------------------------------------------------- 1 | % Latex footer for doxygen 1.9.1 2 | %--- End generated contents --- 3 | 4 | % Index 5 | \backmatter 6 | \newpage 7 | \phantomsection 8 | \clearemptydoublepage 9 | \addcontentsline{toc}{chapter}{\indexname} 10 | \printindex 11 | 12 | \end{document} 13 | -------------------------------------------------------------------------------- /doc/examples/nra-sat.smt2: -------------------------------------------------------------------------------- 1 | (set-logic NRA) 2 | (assert (forall ((x Real)) (exists ((y Real)) (and (= (* x x) y) (>= y 0))))) 3 | (check-sat) -------------------------------------------------------------------------------- /doc/examples/qe.smt2: -------------------------------------------------------------------------------- 1 | (set-logic NRA) 2 | (declare-fun t () Real) 3 | (assert (forall ((x Real)) (exists ((y Real)) (and (= (* x x) y) (>= y t))))) 4 | (apply qe) -------------------------------------------------------------------------------- /doc/examples/qfnra-sat.smt2: -------------------------------------------------------------------------------- 1 | (set-info :smt-lib-version 2.6) 2 | (set-logic QF_NRA) 3 | 4 | (set-info :category "crafted") 5 | (set-info :status sat) 6 | (declare-fun x () Real) 7 | (declare-fun y () Real) 8 | (declare-fun z () Real) 9 | (assert (< (+ (+ (* x x) (* y y)) (* z z)) 1)) 10 | (assert (< (+ (+ (* x x) (* (- y (/ 3 2)) (- y (/ 3 2)))) (* x x)) 1)) 11 | (check-sat) 12 | (exit) 13 | -------------------------------------------------------------------------------- /doc/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/logo.png -------------------------------------------------------------------------------- /doc/logo_old/.gitignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.fls 3 | *.fdb_latexmk 4 | *.log 5 | *.out 6 | *.synctex.gz -------------------------------------------------------------------------------- /doc/logo_old/logo.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/logo_old/logo.pdf -------------------------------------------------------------------------------- /doc/logo_old/logo.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,10pt,titlepage]{scrbook} 2 | 3 | \input{./packages.tex} 4 | \input{./commands.tex} 5 | 6 | 7 | 8 | \begin{document} 9 | \begin{titlepage} 10 | \begin{center} 11 | \input{./logo_content.tex} 12 | \end{center} 13 | \end{titlepage} 14 | \end{document} 15 | -------------------------------------------------------------------------------- /doc/logo_old/packages.tex: -------------------------------------------------------------------------------- 1 | \usepackage{amssymb,amsmath} % math symbols 2 | \usepackage{amstext} 3 | \usepackage{amsthm} 4 | \usepackage{amsfonts} 5 | \usepackage{hyperref} 6 | \usepackage{cleveref} 7 | \usepackage{tikz} % draw graphs and many more 8 | \usetikzlibrary{calc} 9 | \usepackage{xcolor} 10 | \usepackage{xspace} 11 | \usepackage{verbatim} 12 | \usepackage{enumerate} 13 | \usepackage{multirow} 14 | \usepackage{float} 15 | \restylefloat{figure} 16 | \usepackage{mathptmx} 17 | \usepackage{lmodern} 18 | \usepackage{fix-cm} 19 | \usetikzlibrary{positioning} 20 | 21 | \usepackage[inline]{enumitem} -------------------------------------------------------------------------------- /doc/manual/footer.tex: -------------------------------------------------------------------------------- 1 | % Latex footer for doxygen 1.9.1 2 | %--- End generated contents --- 3 | 4 | % Index 5 | \backmatter 6 | \newpage 7 | \phantomsection 8 | \clearemptydoublepage 9 | \addcontentsline{toc}{chapter}{\indexname} 10 | \printindex 11 | 12 | \end{document} 13 | -------------------------------------------------------------------------------- /doc/markdown/08-other-tools.md: -------------------------------------------------------------------------------- 1 | # Other tools {#tools} 2 | 3 | ## Delta debugging 4 | 5 | *Note: Our legacy delta tool has been moved to [its own repository](https://github.com/ths-rwth/delta)*. 6 | 7 | ## Analyzer 8 | 9 | The `smtrat-analyzer` library can analyze static properties input formulas (such as number of variables, degrees, CAD projections, ...). 10 | 11 | To use it from the CLI, build smtrat using `CLI_ENABLE_ANALYZER=ON` and `SMTRAT_DEVOPTION_Statistics=ON`. A single input file can be analyzed by running `./smtrat --analyze.enabled --stats.print input.smt2`; properties will be printed as statistics object, note that the solver will not be called. For further options, see `./smtrat --help`. 12 | 13 | ## Preprocessing 14 | 15 | WIP -------------------------------------------------------------------------------- /doc/markdown/09-developers.md: -------------------------------------------------------------------------------- 1 | # Developers information {#devguide} 2 | 3 | - @subpage code-style 4 | - @subpage documentation 5 | - @subpage settings 6 | - @subpage logging 7 | - @subpage statistics-and-timing 8 | - @subpage testing 9 | - @subpage validation 10 | - @subpage checkpoints 11 | - @subpage bugs 12 | - @ref tools -------------------------------------------------------------------------------- /doc/markdown/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(MODULE_INCLUDES "") 2 | ListSubDirs(MODULES ${CMAKE_SOURCE_DIR}/src/smtrat-modules) 3 | foreach(module ${MODULES}) 4 | if(EXISTS ${CMAKE_SOURCE_DIR}/src/smtrat-modules/${module}/${module}.md) 5 | set(MODULE_INCLUDES "${MODULE_INCLUDES} @subpage ${module}\n") 6 | endif() 7 | endforeach() 8 | 9 | configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/modules/modules.md.in ${CMAKE_CURRENT_SOURCE_DIR}/modules/modules.md ) 10 | -------------------------------------------------------------------------------- /doc/markdown/developers/code-style.md: -------------------------------------------------------------------------------- 1 | ## Code style {#code-style} 2 | 3 | Please follow the code style rules from CArL documentation. 4 | 5 | For SMT-RAT, we follow a different rule for naming files and namespaces: 6 | 7 | * Every file should represent a *module*. 8 | * Every (sub-)folder has its own namespace. -------------------------------------------------------------------------------- /doc/markdown/developers/settings.md: -------------------------------------------------------------------------------- 1 | ## Settings {#settings} 2 | 3 | As described in @ref sec::modules, each module has a settings template parameter. 4 | 5 | ### Dynamic settings 6 | 7 | These settings are considered at compile time. For certain purposes, it is unhandy to recompile SMT-RAT for every parameter. For this, module parameters can be set 8 | * via the command line using `--module.parameter key1=value1 --module.parameter key2=value2 ...` or 9 | * via the `set-option` command of SMT-LIB: `(set-option :key "value")`. 10 | 11 | These parameters can be accessed (most appropriately in a settings object of a module) via `int my_setting = settings_module().get("my_module.my_setting", 2)` or `std::string my_setting = settings_module().get("my_module.my_setting", "default_value")`. Note that the second parameter is the default value also specifying the type of the setting to which it is parsed. -------------------------------------------------------------------------------- /doc/markdown/developers/testing.md: -------------------------------------------------------------------------------- 1 | ## Testing {#testing} 2 | 3 | SMT-RAT and CArL use [GoogleTest](http://google.github.io/googletest/) for unit testing. To do so, go to the `src/tests/` folder and create a test analogously to the other tests (i.e. creating a new folder, adapting the `CMakeList.txt` in the new folder and in the `tests` folder). *Note that in the SMT-RAT repository are some obsolete tests.* 4 | 5 | ### Utilities 6 | 7 | For creating CArL data structure in unit tests, we refer to `carl-io/parser/Parser.h`. -------------------------------------------------------------------------------- /doc/markdown/modules/.gitignore: -------------------------------------------------------------------------------- 1 | modules.md 2 | -------------------------------------------------------------------------------- /doc/markdown/modules/modules.md.in: -------------------------------------------------------------------------------- 1 | ## Available modules {#available-modules} 2 | 3 | SMT-RAT comes with the following modules that are documented in some more detail below: 4 | 5 | ${MODULE_INCLUDES} 6 | -------------------------------------------------------------------------------- /doc/pictures/template.tex.in: -------------------------------------------------------------------------------- 1 | \documentclass{standalone} 2 | \usepackage{tikz} 3 | \usetikzlibrary{calc, positioning} 4 | 5 | \begin{document} 6 | 7 | \input{@FILENAME@} 8 | 9 | \end{document} -------------------------------------------------------------------------------- /doc/smtcomp-description/.gitignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.bbl 3 | *.blg 4 | *.log 5 | *.fdb_latexmk 6 | *.fls 7 | *.out 8 | *.synctex.gz -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2019.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2019.pdf -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2020.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2020.pdf -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2021.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2021.pdf -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2022.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2022.pdf -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2023.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2023.pdf -------------------------------------------------------------------------------- /doc/smtcomp-description/smtcomp-2024.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/doc/smtcomp-description/smtcomp-2024.pdf -------------------------------------------------------------------------------- /resources/carl-required.version: -------------------------------------------------------------------------------- 1 | 25.02 -------------------------------------------------------------------------------- /resources/carl-write-required-version.cmake: -------------------------------------------------------------------------------- 1 | 2 | cmake_minimum_required (VERSION 3.2 FATAL_ERROR) 3 | 4 | include(${CARL_DIR}/../cmake/carlmacros.cmake) 5 | 6 | set_version(0 1) 7 | 8 | file(WRITE ${DEST_FILE} "${PROJECT_VERSION}") 9 | 10 | message(STATUS "Stored ${PROJECT_VERSION} as required version.") 11 | -------------------------------------------------------------------------------- /resources/carl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | project(CArL-config-EP) 2 | cmake_minimum_required(VERSION 3.3) 3 | 4 | include(ExternalProject) 5 | set_directory_properties(PROPERTIES EP_PREFIX ${TARGETDIR}) 6 | 7 | set(CMAKE_OPTIONS -DBOOST_INCLUDEDIR=${BOOST_INCLUDEDIR} -DUSE_BLISS=ON -DUSE_COCOA=ON -DEXPORT_TO_CMAKE=OFF) 8 | if(USE_GINAC) 9 | set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -DUSE_CLN=ON -DUSE_GINAC=ON") 10 | endif() 11 | 12 | ExternalProject_Add( 13 | CArL-EP-download 14 | SOURCE_DIR ${TARGETDIR}/src/CArL-EP 15 | BINARY_DIR ${TARGETDIR}/src/CArL-EP-build 16 | GIT_REPOSITORY https://github.com/ths-rwth/carl 17 | GIT_TAG ${CARL_REQUIRED_VERSION} 18 | CMAKE_ARGS -DCMAKE_INSTALL_PREFIX= -DCMAKE_PREFIX_PATH= ${CMAKE_OPTIONS} 19 | BUILD_COMMAND "" 20 | INSTALL_COMMAND "" 21 | ) 22 | -------------------------------------------------------------------------------- /smtrat.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=@CMAKE_INSTALL_PREFIX@/bin 3 | libdir=@CMAKE_INSTALL_PREFIX@/lib 4 | includedir=@CMAKE_INSTALL_PREFIX@/include/smt-rat 5 | 6 | Name: @PROJECT_FULLNAME@ 7 | Description: @PROJECT_DESCRIPTION@ 8 | Version: @PROJECT_VERSION@ 9 | Libs: -L@DOLLAR@{libdir} -l@PROJECT_NAME@ 10 | Cflags: -I@DOLLAR@{includedir} 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /src/cli/CLIStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef SMTRAT_DEVOPTION_Statistics 6 | 7 | namespace smtrat { 8 | namespace cli { 9 | 10 | class CLIStatistics : public Statistics { 11 | public: 12 | carl::statistics::Timer parsing; 13 | void collect() { 14 | Statistics::addKeyValuePair("parsing", parsing); 15 | } 16 | }; 17 | 18 | static auto& statistics() { 19 | SMTRAT_STATISTICS_INIT_STATIC(CLIStatistics, stats, "cli"); 20 | return stats; 21 | } 22 | 23 | } 24 | } 25 | #endif 26 | -------------------------------------------------------------------------------- /src/cli/ExitCodes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * File: ExitCodes.h 3 | * Author: Sebastian Junges 4 | * 5 | * Created on November 19, 2012, 10:42 AM 6 | */ 7 | 8 | #pragma once 9 | 10 | constexpr int SMTRAT_EXIT_UNDEFINED = -1; 11 | constexpr int SMTRAT_EXIT_USERABORT = 0; 12 | constexpr int SMTRAT_EXIT_SUCCESS = 1; 13 | constexpr int SMTRAT_EXIT_SAT = 2; 14 | constexpr int SMTRAT_EXIT_UNSAT = 3; 15 | constexpr int SMTRAT_EXIT_UNKNOWN = 4; 16 | constexpr int SMTRAT_EXIT_WRONG_ANSWER = 5; 17 | constexpr int SMTRAT_EXIT_GENERALERROR = 6; 18 | constexpr int SMTRAT_EXIT_UNEXPECTED_ANSWER = 7; 19 | constexpr int SMTRAT_EXIT_UNEXPECTED_INPUT = 8; 20 | constexpr int SMTRAT_EXIT_NOSUCHFILE = 9; 21 | constexpr int SMTRAT_EXIT_PARSERFAILURE = 10; 22 | constexpr int SMTRAT_EXIT_TIMEOUT = 11; 23 | constexpr int SMTRAT_EXIT_MEMOUT = 12; 24 | 25 | -------------------------------------------------------------------------------- /src/cli/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define LICENSE_CONTENT R"licenseString(@LICENSE_CONTENT_IN@)licenseString" 4 | 5 | #cmakedefine LOGGING 6 | 7 | #ifdef _MSC_VER 8 | #define __VS 9 | #endif 10 | 11 | #ifdef _WIN32 12 | #define __WIN 13 | #endif 14 | -------------------------------------------------------------------------------- /src/cli/parser/Identifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Common.h" 4 | #include "Lexicon.h" 5 | 6 | namespace smtrat { 7 | namespace parser { 8 | 9 | struct IdentifierParser: public qi::grammar { 10 | IdentifierParser(): IdentifierParser::base_type(main, "identifier") { 11 | main = symbol[qi::_val = px::construct(qi::_1)] | indexed[qi::_val = qi::_1]; 12 | main.name("identifier"); 13 | indexed = (qi::lit("(") >> qi::lit("_") >> symbol >> +numeral >> qi::lit(")"))[qi::_val = px::construct(qi::_1, qi::_2)]; 14 | indexed.name("indexed symbol"); 15 | } 16 | SymbolParser symbol; 17 | NumeralParser numeral; 18 | qi::rule main; 19 | qi::rule indexed; 20 | }; 21 | 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/cli/parser/ParserWrapper.cpp: -------------------------------------------------------------------------------- 1 | #include "ParserWrapper.h" 2 | 3 | #include "Parser.h" 4 | 5 | namespace smtrat { 6 | bool parseSMT2File(parser::InstructionHandler& handler, bool queueInstructions, std::istream& input) { 7 | parser::SMTLIBParser parser(handler, queueInstructions); 8 | return parser.parse(input); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/cli/parser/ParserWrapper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "InstructionHandler.h" 4 | 5 | namespace smtrat { 6 | 7 | bool parseSMT2File(parser::InstructionHandler& handler, bool queueInstructions, std::istream& input); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/cli/parser/theories/BooleanEncoding.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Common.h" 4 | #include "AbstractTheory.h" 5 | #include "ParserState.h" 6 | 7 | namespace smtrat { 8 | namespace parser { 9 | 10 | /** 11 | * Implements the theory of bitvectors. 12 | */ 13 | struct BooleanEncodingTheory: public AbstractTheory { 14 | BooleanEncodingTheory(ParserState* state); 15 | }; 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/cli/tools/cnf_conversion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat { 6 | 7 | int convert_to_cnf_dimacs(const std::string& filename, const std::string& outfile); 8 | int convert_to_cnf_smtlib(const std::string& filename, const std::string& outfile); 9 | 10 | } -------------------------------------------------------------------------------- /src/cli/tools/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #cmakedefine CLI_ENABLE_ANALYZER 4 | #cmakedefine CLI_ENABLE_CNF_CONVERSION 5 | #cmakedefine CLI_ENABLE_DIMACS_PARSER 6 | #cmakedefine CLI_ENABLE_FORMULAPARSER 7 | #cmakedefine CLI_ENABLE_OPB_PARSER 8 | #cmakedefine CLI_ENABLE_PREPROCESSOR 9 | #cmakedefine CLI_ENABLE_QUANTIFIER_ELIMINATION -------------------------------------------------------------------------------- /src/cli/tools/formula_analyzer.cpp: -------------------------------------------------------------------------------- 1 | #include "formula_analyzer.h" 2 | 3 | #include "config.h" 4 | #include 5 | 6 | #ifdef CLI_ENABLE_ANALYZER 7 | 8 | #include "parser_smtlib_utils.h" 9 | #include "execute_smtlib.h" 10 | 11 | namespace smtrat { 12 | 13 | int analyze_file(const std::string& filename) { 14 | auto e = parseformula::FormulaCollector(); 15 | executeFile(filename, e); 16 | 17 | auto& stats = analyze_formula(e.getFormula()); 18 | 19 | if (e.has_info("status")) { 20 | stats.add("answer", e.get_info("status")); 21 | } 22 | 23 | return 0; 24 | } 25 | 26 | } 27 | 28 | #else 29 | 30 | namespace smtrat { 31 | 32 | int analyze_file(const std::string&) { 33 | return 0; 34 | } 35 | 36 | } 37 | 38 | #endif -------------------------------------------------------------------------------- /src/cli/tools/formula_analyzer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | 8 | int analyze_file(const std::string& filename); 9 | 10 | } -------------------------------------------------------------------------------- /src/cli/tools/parser_smtlib.cpp: -------------------------------------------------------------------------------- 1 | #include "parser_smtlib.h" 2 | 3 | #include "config.h" 4 | #include 5 | 6 | #ifdef CLI_ENABLE_FORMULAPARSER 7 | 8 | #include "execute_smtlib.h" 9 | #include "parser_smtlib_utils.h" 10 | 11 | namespace smtrat { 12 | 13 | FormulaT parse_smtlib(const std::string& filename) { 14 | auto e = parseformula::FormulaCollector(); 15 | executeFile(filename, e); 16 | return e.getFormula(); 17 | } 18 | 19 | } 20 | 21 | #else 22 | 23 | namespace smtrat { 24 | 25 | FormulaT parse_smtlib(const std::string&) { 26 | SMTRAT_LOG_ERROR("smtrat", "This version of SMT-RAT was compiled without support for stand-alone formula parsing. Please enable it by setting the corresponding CMake option."); 27 | return FormulaT(); 28 | } 29 | 30 | } 31 | 32 | #endif -------------------------------------------------------------------------------- /src/cli/tools/parser_smtlib.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | /** 10 | * Loads the smt2 file specified in filename and returns the formula. 11 | * This function ignores most SMT-LIB commands but simply accumulated all asserted formulas. 12 | */ 13 | FormulaT parse_formula(const std::string& filename); 14 | 15 | } -------------------------------------------------------------------------------- /src/cli/tools/preprocessor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat { 6 | 7 | /** 8 | * Loads the smt2 file specified in filename and runs the preprocessing strategy. 9 | * The resulting (simplified) problem is written to outfile (or stdout if outfile is empty). 10 | */ 11 | int preprocess_file(const std::string& filename, const std::string& outfile); 12 | 13 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-analyzer_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-analyzer "${PROJECT_VERSION_LIB}" "${smtrat-analyzer_sources}" "resources") 10 | target_include_dirs_from(smtrat-analyzer-objects "" PUBLIC smtrat-cad-shared smtrat-common-shared) 11 | target_link_libraries(smtrat-analyzer-shared smtrat-cad-shared smtrat-common-shared) 12 | target_link_libraries(smtrat-analyzer-static smtrat-cad-static smtrat-common-static) 13 | 14 | install_libraries(smtrat smtrat-analyzer-shared smtrat-analyzer-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-analyzer/analyzers/cad_projections.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../statistics.h" 4 | 5 | #include 6 | 7 | namespace smtrat::analyzer { 8 | 9 | void analyze_cad_projections(const FormulaT& f, AnalyzerStatistics& stats); 10 | 11 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/analyzers/cnf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../statistics.h" 4 | 5 | #include 6 | 7 | namespace smtrat::analyzer { 8 | 9 | void analyze_cnf(const FormulaT& f, AnalyzerStatistics& stats); 10 | 11 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/analyzers/formula_types.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../statistics.h" 4 | 5 | #include 6 | 7 | namespace smtrat::analyzer { 8 | 9 | void analyze_formula_types(const FormulaT& f, AnalyzerStatistics& stats); 10 | 11 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/analyzers/variables.cpp: -------------------------------------------------------------------------------- 1 | #include "variables.h" 2 | 3 | namespace smtrat::analyzer { 4 | 5 | void analyze_variables(const FormulaT& f, AnalyzerStatistics& stats) { 6 | carl::carlVariables vars; 7 | carl::variables(f,vars); 8 | 9 | stats.add("num_variables", vars.size()); 10 | stats.add("num_variables_boolean", vars.boolean().size()); 11 | stats.add("num_variables_theory", vars.integer().size() + vars.real().size() + vars.bitvector().size() + vars.uninterpreted().size()); 12 | stats.add("num_variables_arithmetic_real", vars.real().size()); 13 | stats.add("num_variables_arithmetic_int", vars.integer().size()); 14 | stats.add("num_variables_arithmetic", vars.integer().size() + vars.real().size()); 15 | stats.add("num_variables_bitvector", vars.bitvector().size()); 16 | stats.add("num_variables_uninterpreted", vars.uninterpreted().size()); 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/analyzers/variables.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../statistics.h" 4 | 5 | #include 6 | 7 | namespace smtrat::analyzer { 8 | 9 | void analyze_variables(const FormulaT& f, AnalyzerStatistics& stats); 10 | 11 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/smtrat-analyzer.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-analyzer.h" 2 | 3 | #include "analyzers/cad_projections.h" 4 | #include "analyzers/formula_types.h" 5 | #include "analyzers/variables.h" 6 | #include "analyzers/cnf.h" 7 | 8 | namespace smtrat { 9 | 10 | analyzer::AnalyzerStatistics& analyze_formula(const FormulaT& f) { 11 | analyzer::AnalyzerStatistics& stats = statistics_get("analyzer"); 12 | 13 | analyzer::analyze_variables(f, stats); 14 | analyzer::analyze_formula_types(f, stats); 15 | analyzer::analyze_cad_projections(f, stats); 16 | analyzer::analyze_cnf(f, stats); 17 | 18 | return stats; 19 | } 20 | 21 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/smtrat-analyzer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "settings.h" 4 | #include "statistics.h" 5 | 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | analyzer::AnalyzerStatistics& analyze_formula(const FormulaT& f); 11 | 12 | } -------------------------------------------------------------------------------- /src/smtrat-analyzer/statistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat::analyzer { 6 | 7 | struct AnalyzerStatistics: public Statistics { 8 | public: 9 | template 10 | void add(const std::string& key, const T& value) { 11 | addKeyValuePair(key, value); 12 | } 13 | }; 14 | 15 | } -------------------------------------------------------------------------------- /src/smtrat-cad/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-cad_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-cad "${PROJECT_VERSION_LIB}" "${smtrat-cad_sources}" "resources") 10 | target_include_dirs_from(smtrat-cad-objects "" PUBLIC smtrat-common-shared smtrat-variablebounds-shared carl-covering-shared carl-formula-shared) 11 | target_link_libraries(smtrat-cad-shared smtrat-common-shared smtrat-variablebounds-shared carl-covering-shared carl-formula-shared) 12 | target_link_libraries(smtrat-cad-static smtrat-common-static smtrat-variablebounds-static carl-covering-static carl-formula-static) 13 | 14 | install_libraries(smtrat smtrat-cad-shared smtrat-cad-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-cad/common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace smtrat { 8 | namespace cad { 9 | using carl::operator<<; 10 | 11 | using RAN = smtrat::RAN; 12 | using ConstraintSelection = carl::Bitset; 13 | using OptionalID = std::optional; 14 | using Assignment = std::map; 15 | using SampleLiftedWith = carl::Bitset; 16 | using SampleRootOf = carl::Bitset; 17 | using UPoly = carl::UnivariatePolynomial; 18 | } 19 | } -------------------------------------------------------------------------------- /src/smtrat-cad/debug/DotHelper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | namespace cad { 8 | namespace debug { 9 | 10 | struct DotSubgraph { 11 | std::string name; 12 | std::vector nodes; 13 | DotSubgraph(const std::string& n): name(n) {} 14 | void add(const std::string& n) { 15 | nodes.push_back(n); 16 | } 17 | friend std::ostream& operator<<(std::ostream& os, const DotSubgraph& dsg) { 18 | os << "subgraph " << dsg.name << " { rank = same; "; 19 | for (const auto& n: dsg.nodes) { 20 | os << n << "; "; 21 | } 22 | return os << "}"; 23 | } 24 | }; 25 | 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/smtrat-cad/projection/Projection_utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../common.h" 4 | 5 | namespace smtrat::cad::projection { 6 | 7 | /// Checks whether a polynomial can safely be ignored. 8 | inline bool canBeRemoved(const UPoly& p) { 9 | return carl::is_zero(p) || p.is_number(); 10 | } 11 | /// Checks whether a polynomial can safely be forwarded to the next level. 12 | inline bool canBeForwarded(std::size_t, const UPoly& p) { 13 | return carl::is_constant(p); 14 | } 15 | 16 | } -------------------------------------------------------------------------------- /src/smtrat-cad/smtrat-cad.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-cad.h" -------------------------------------------------------------------------------- /src/smtrat-cad/smtrat-cad.h: -------------------------------------------------------------------------------- 1 | #pragma once -------------------------------------------------------------------------------- /src/smtrat-cad/variableordering/triangular_ordering.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace smtrat::cad::variable_ordering { 8 | 9 | std::vector triangular_ordering(const std::vector& polys); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /src/smtrat-cadcells/CADCellsStatistics.cpp: -------------------------------------------------------------------------------- 1 | #include "CADCellsStatistics.h" 2 | 3 | #ifdef SMTRAT_DEVOPTION_Statistics 4 | namespace smtrat { 5 | namespace cadcells { 6 | CADCellsStatistics &statistics() { 7 | static CADCellsStatistics &stats = statistics_get("smtrat-cadcells"); 8 | return stats; 9 | } 10 | } 11 | } 12 | #endif 13 | -------------------------------------------------------------------------------- /src/smtrat-cadcells/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-cadcells_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-cadcells "${PROJECT_VERSION_LIB}" "${smtrat-cadcells_sources}" "resources") 10 | target_include_dirs_from(smtrat-cadcells-objects "" PUBLIC smtrat-common-shared carl-covering-shared carl-formula-shared) 11 | target_link_libraries(smtrat-cadcells-shared smtrat-common-shared carl-covering-shared carl-formula-shared) 12 | target_link_libraries(smtrat-cadcells-static smtrat-common-static carl-covering-static carl-formula-static) 13 | 14 | install_libraries(smtrat smtrat-cadcells-shared smtrat-cadcells-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-cadcells/datastructures/roots.cpp: -------------------------------------------------------------------------------- 1 | #include "roots.h" 2 | 3 | namespace smtrat::cadcells::datastructures { 4 | const boost::container::flat_set IndexedRootOrdering::empty_result = boost::container::flat_set(); 5 | } -------------------------------------------------------------------------------- /src/smtrat-cadcells/operators/rules_covering.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace smtrat::cadcells::operators::rules { 4 | 5 | template 6 | void covering_holds(datastructures::DelineatedDerivation

& /*deriv*/, const datastructures::CoveringDescription& covering, const datastructures::IndexedRootOrdering& ordering) { 7 | SMTRAT_LOG_TRACE("smtrat.cadcells.operators.rules", "holds(" << covering << ")"); 8 | for (auto it = covering.cells().begin(); it != covering.cells().end()-1; it++) { 9 | assert(ordering.is_projective() || ordering.holds_transitive(std::next(it)->lower().value(), it->upper().value(), false)); 10 | } 11 | } 12 | 13 | } -------------------------------------------------------------------------------- /src/smtrat-cadcells/representation/combinatorialopt/graph.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | #include "../../datastructures/roots.h" 8 | 9 | namespace smtrat::cadcells::representation::combinatorialopt::util { 10 | 11 | typedef std::pair RootPair; 12 | 13 | struct EdgeProperties { 14 | size_t index; 15 | int weight; 16 | std::optional root_pair_below, root_pair_above; 17 | }; 18 | 19 | typedef boost::adjacency_list 24 | Graph; 25 | 26 | } // namespace smtrat::cadcells::representation::util 27 | -------------------------------------------------------------------------------- /src/smtrat-cadcells/representation/heuristics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../datastructures/representation.h" 4 | 5 | /** 6 | * @brief Heuristics for computing representations. 7 | * 8 | */ 9 | namespace smtrat::cadcells::representation {} 10 | 11 | #include "util.h" 12 | #include "heuristics_cell.h" 13 | #include "heuristics_covering.h" 14 | #include "heuristics_approximation.h" 15 | #include "heuristics_combinatorialopt.h" 16 | -------------------------------------------------------------------------------- /src/smtrat-cadcells/smtrat-cadcells.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/src/smtrat-cadcells/smtrat-cadcells.cpp -------------------------------------------------------------------------------- /src/smtrat-common/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-common_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-common ${PROJECT_VERSION_LIB} "${smtrat-common_sources}" "resources") 10 | target_include_dirs_from(smtrat-common-objects "" PUBLIC carl-arith-shared carl-formula-shared carl-settings-shared carl-statistics-shared) 11 | target_link_libraries(smtrat-common-shared PUBLIC carl-arith-shared carl-formula-shared carl-settings-shared carl-statistics-shared) 12 | target_link_libraries(smtrat-common-static PUBLIC carl-arith-static carl-formula-static carl-settings-static carl-statistics-static) 13 | 14 | install_libraries(smtrat smtrat-common-shared smtrat-common-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-common/checkpoints/Checkpoints.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../config.h" 4 | #include 5 | 6 | namespace smtrat { 7 | #ifdef SMTRAT_DEVOPTION_Checkpoints 8 | #define SMTRAT_ADD_CHECKPOINT(channel,description,forced,...) carl::checkpoints::CheckpointVerifier::getInstance().push(channel, description, forced, __VA_ARGS__); 9 | #define SMTRAT_CHECKPOINT(channel,description,...) carl::checkpoints::CheckpointVerifier::getInstance().expect(channel, description, __VA_ARGS__); 10 | #define SMTRAT_CLEAR_CHECKPOINT(channel) carl::checkpoints::CheckpointVerifier::getInstance().clear(channel); 11 | #else 12 | #define SMTRAT_ADD_CHECKPOINT(channel,description,forced,...) 13 | #define SMTRAT_CHECKPOINT(channel,description,...) 14 | #define SMTRAT_CLEAR_CHECKPOINT(channel) 15 | #endif 16 | } 17 | -------------------------------------------------------------------------------- /src/smtrat-common/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define EXTERNALIZE_CLASSES 4 | 5 | #cmakedefine USE_NSS 6 | 7 | #cmakedefine SMTRAT_DEVOPTION_Validation 8 | #cmakedefine SMTRAT_DEVOPTION_Statistics 9 | #cmakedefine SMTRAT_DEVOPTION_Checkpoints 10 | #cmakedefine SMTRAT_DEVOPTION_Expensive 11 | 12 | #cmakedefine SMTRAT_STRAT_PARALLEL_MODE 13 | #cmakedefine USE_GINAC 14 | 15 | #cmakedefine LOGGING 16 | 17 | #ifdef _MSC_VER 18 | #define __VS 19 | #endif 20 | 21 | #ifdef _WIN32 22 | #define __WIN 23 | #endif 24 | -------------------------------------------------------------------------------- /src/smtrat-common/settings/SettingsComponents.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "SettingsParser.h" 4 | 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | namespace smtrat { 11 | 12 | class SettingsComponents: public carl::Singleton { 13 | private: 14 | std::vector> mHooks; 15 | public: 16 | void add(std::function&& f) { 17 | mHooks.emplace_back(f); 18 | } 19 | void add_to_parser(SettingsParser& parser) const { 20 | for (const auto& f: mHooks) { 21 | f(parser); 22 | } 23 | } 24 | }; 25 | 26 | } // smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-common/settings/SettingsParser.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | 8 | class SettingsParser: public carl::settings::SettingsParser, public carl::Singleton { 9 | friend carl::Singleton; 10 | 11 | SettingsParser(); 12 | }; 13 | 14 | } // smtrat 15 | -------------------------------------------------------------------------------- /src/smtrat-common/smtrat-common.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-common.h" 2 | 3 | #ifdef EXTERNALIZE_CLASSES 4 | namespace carl { 5 | 6 | template class MultivariatePolynomial; 7 | template class Constraint; 8 | template class Formula; 9 | 10 | } 11 | #endif 12 | -------------------------------------------------------------------------------- /src/smtrat-common/smtrat-common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "config.h" 4 | #include "types.h" 5 | #include "logging.h" 6 | #include "settings/Settings.h" 7 | #include "validation/Validation.h" 8 | #include "checkpoints/Checkpoints.h" 9 | 10 | 11 | #ifdef EXTERNALIZE_CLASSES 12 | namespace carl { 13 | 14 | extern template class MultivariatePolynomial; 15 | extern template class Constraint; 16 | extern template class Formula; 17 | 18 | } 19 | #endif 20 | -------------------------------------------------------------------------------- /src/smtrat-coveringng/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-coveringng_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-coveringng "${PROJECT_VERSION_LIB}" "${smtrat-coveringng_sources}" "resources") 10 | target_include_dirs_from(smtrat-coveringng-objects "" PUBLIC smtrat-common-shared smtrat-cadcells-shared smtrat-mcsat-shared) 11 | target_link_libraries(smtrat-coveringng-shared smtrat-common-shared smtrat-cadcells-shared smtrat-mcsat-shared) 12 | target_link_libraries(smtrat-coveringng-static smtrat-common-static smtrat-cadcells-static smtrat-mcsat-static) 13 | 14 | install_libraries(smtrat smtrat-coveringng-shared smtrat-coveringng-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-coveringng/CoveringNGStatistics.cpp: -------------------------------------------------------------------------------- 1 | #include "CoveringNGStatistics.h" 2 | 3 | #ifdef SMTRAT_DEVOPTION_Statistics 4 | namespace smtrat::covering_ng{ 5 | CoveringNGStatistics &statistics() { 6 | static CoveringNGStatistics &stats = statistics_get("smtrat-coveringng"); 7 | return stats; 8 | } 9 | } 10 | #endif 11 | -------------------------------------------------------------------------------- /src/smtrat-coveringng/Simplification.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "types.h" 4 | 5 | namespace smtrat::covering_ng { 6 | 7 | void simplify(ParameterTree& tree); 8 | 9 | } -------------------------------------------------------------------------------- /src/smtrat-expressions/ExpressionContent.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | #include "ExpressionContent.h" 3 | 4 | namespace smtrat { 5 | namespace expression { 6 | 7 | void ExpressionContent::updateHash() { 8 | hash = std::hash()(content); 9 | } 10 | 11 | } 12 | } 13 | */ 14 | -------------------------------------------------------------------------------- /src/smtrat-expressions/README.md: -------------------------------------------------------------------------------- 1 | This is dead code. 2 | 3 | The expressions were meant as an alternative to carl::Formula. Instead of having own theory constraints for each theory, here, everything is stored in a single tree structure. This would make theory combinations easier (think of a variable being interpreted both as uninterpreted and as arithmetic variable); furthermore, handling ite expression is easer: currently, we need to resolve ite expressions within the theory in the parser, leading to bad performance on some examples. -------------------------------------------------------------------------------- /src/smtrat-expressions/simplifier/DuplicateSimplifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "BaseSimplifier.h" 4 | #include "../ExpressionPool.h" 5 | 6 | namespace smtrat { 7 | namespace expression { 8 | namespace simplifier { 9 | 10 | struct DuplicateSimplifier: public BaseSimplifier { 11 | const ExpressionContent* simplify(const NaryExpression& expr) const { 12 | if (expr.type == IFF) return nullptr; 13 | if (expr.type == XOR) return nullptr; 14 | Expressions expressions(expr.expressions.begin(), expr.expressions.end()); 15 | auto it = std::unique(expressions.begin(), expressions.end()); 16 | if (it == expressions.end()) return nullptr; 17 | expressions.erase(it, expressions.end()); 18 | return ExpressionPool::create(expr.type, std::move(expressions)); 19 | } 20 | }; 21 | 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/smtrat-expressions/simplifier/NegationSimplifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "BaseSimplifier.h" 4 | #include "../ExpressionPool.h" 5 | 6 | namespace smtrat { 7 | namespace expression { 8 | namespace simplifier { 9 | 10 | struct NegationSimplifier: public BaseSimplifier { 11 | const ExpressionContent* simplify(const UnaryExpression& expr) const { 12 | if (expr.type != NOT) return nullptr; 13 | return expr.expression.getContent().negation; 14 | } 15 | }; 16 | 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/smtrat-expressions/simplifier/SingletonSimplifier.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "BaseSimplifier.h" 4 | #include "../ExpressionPool.h" 5 | 6 | namespace smtrat { 7 | namespace expression { 8 | namespace simplifier { 9 | 10 | struct SingletonSimplifier: public BaseSimplifier { 11 | const ExpressionContent* simplify(const NaryExpression& expr) const { 12 | if (expr.type == IFF) return nullptr; 13 | if (expr.expressions.size() == 1) { 14 | return expr.expressions.front().getContentPtr(); 15 | } 16 | return nullptr; 17 | } 18 | }; 19 | 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-fmplex/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-fmplex_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-fmplex "${PROJECT_VERSION_LIB}" "${smtrat-fmplex_sources}" "resources") 10 | target_include_dirs_from(smtrat-fmplex-objects "" PUBLIC carl-formula-shared carl-arith-shared) 11 | target_link_libraries(smtrat-fmplex-shared carl-formula-shared carl-arith-shared) 12 | target_link_libraries(smtrat-fmplex-static carl-formula-static carl-arith-static) 13 | 14 | install_libraries(smtrat smtrat-fmplex-shared smtrat-fmplex-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-max-smt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-max-smt_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-max-smt ${PROJECT_VERSION_LIB} "${smtrat-max-smt_sources}" "resources") 10 | target_include_dirs_from(smtrat-max-smt-objects "" PUBLIC smtrat-common-shared carl-arith-shared) 11 | target_link_libraries(smtrat-max-smt-shared smtrat-common-shared carl-arith-shared) 12 | target_link_libraries(smtrat-max-smt-static smtrat-common-static carl-arith-static) 13 | 14 | install_libraries(smtrat smtrat-max-smt-shared smtrat-max-smt-static) 15 | 16 | -------------------------------------------------------------------------------- /src/smtrat-max-smt/smtrat-max-smt.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-max-smt.h" -------------------------------------------------------------------------------- /src/smtrat-max-smt/smtrat-max-smt.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "MaxSMT.h" 6 | #include "MaxSMT_LinearSearch.h" 7 | #include "MaxSMT_MSU3.h" 8 | #include "MaxSMT_FuMalikIncremental.h" -------------------------------------------------------------------------------- /src/smtrat-mcsat/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-mcsat_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-mcsat "${PROJECT_VERSION_LIB}" "${smtrat-mcsat_sources}" "resources") 10 | target_include_dirs_from(smtrat-mcsat-objects "" PUBLIC smtrat-common-shared) 11 | target_link_libraries(smtrat-mcsat-shared 12 | smtrat-common-shared 13 | smtrat-solver-shared 14 | smtrat-module-LRAModule-LRASettings1-shared 15 | smtrat-cadcells-shared 16 | rt 17 | ) 18 | target_link_libraries(smtrat-mcsat-static 19 | smtrat-common-static 20 | smtrat-solver-static 21 | smtrat-module-LRAModule-LRASettings1-static 22 | smtrat-cadcells-static 23 | rt 24 | ) 25 | 26 | install_libraries(smtrat smtrat-mcsat-shared smtrat-mcsat-static) 27 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/assignments/arithmetic/AAFStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef SMTRAT_DEVOPTION_Statistics 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | 10 | class AAFStatistics: public Statistics { 11 | private: 12 | std::size_t mCalled = 0; 13 | std::size_t mSuccess = 0; 14 | public: 15 | bool enabled() const { 16 | return (mCalled > 0) || (mSuccess > 0); 17 | } 18 | void collect() { 19 | Statistics::addKeyValuePair("called", mCalled); 20 | Statistics::addKeyValuePair("success", mSuccess); 21 | } 22 | 23 | void called() { 24 | ++mCalled; 25 | } 26 | 27 | void success() { 28 | ++mSuccess; 29 | } 30 | 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/assignments/smtaf/SMTAFStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef SMTRAT_DEVOPTION_Statistics 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | 10 | class SMTAFStatistics: public Statistics { 11 | private: 12 | std::size_t mCalled = 0; 13 | std::size_t mSuccess = 0; 14 | public: 15 | bool enabled() const { 16 | return (mCalled > 0) || (mSuccess > 0); 17 | } 18 | void collect() { 19 | Statistics::addKeyValuePair("called", mCalled); 20 | Statistics::addKeyValuePair("success", mSuccess); 21 | } 22 | 23 | void called() { 24 | ++mCalled; 25 | } 26 | 27 | void success() { 28 | ++mSuccess; 29 | } 30 | 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/fm/Explanation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "FMStatistics.h" 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | namespace fm { 10 | 11 | struct DefaultSettings { 12 | static constexpr bool use_all_constraints = false; 13 | }; 14 | struct IgnoreCoreSettings { 15 | static constexpr bool use_all_constraints = true; 16 | }; 17 | 18 | template 19 | struct Explanation { 20 | 21 | #ifdef SMTRAT_DEVOPTION_Statistics 22 | FMStatistics& mStatistics = statistics_get("mcsat-explanation-fm"); 23 | #endif 24 | 25 | std::optional operator()(const mcsat::Bookkeeping& data, carl::Variable var, const FormulasT& reason, bool force_use_core) const; 26 | 27 | }; 28 | 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/fm/FMStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef SMTRAT_DEVOPTION_Statistics 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | 10 | class FMStatistics : public Statistics { 11 | private: 12 | std::size_t mExplanationCalled = 0; 13 | std::size_t mExplanationSuccess = 0; 14 | 15 | public: 16 | bool enabled() const { 17 | return (mExplanationCalled > 0) || (mExplanationSuccess > 0); 18 | } 19 | void collect() { 20 | Statistics::addKeyValuePair("explanation_called", mExplanationCalled); 21 | Statistics::addKeyValuePair("explanation_success", mExplanationSuccess); 22 | } 23 | 24 | void explanationCalled() { 25 | ++mExplanationCalled; 26 | } 27 | 28 | void explanationSuccess() { 29 | ++mExplanationSuccess; 30 | } 31 | }; 32 | 33 | } // namespace mcsat 34 | } // namespace smtrat 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/icp/Explanation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "ICPStatistics.h" 7 | 8 | namespace smtrat { 9 | namespace mcsat { 10 | namespace icp { 11 | 12 | struct Explanation { 13 | #ifdef SMTRAT_DEVOPTION_Statistics 14 | ICPStatistics& mStatistics = statistics_get("mcsat-explanation-icp"); 15 | #endif 16 | 17 | std::optional operator()(const mcsat::Bookkeeping& data, carl::Variable var, const FormulasT& reason, bool force_use_core) const; 18 | }; 19 | 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/icp/ICPStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef SMTRAT_DEVOPTION_Statistics 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | 10 | class ICPStatistics : public Statistics { 11 | private: 12 | std::size_t mExplanationCalled = 0; 13 | std::size_t mExplanationSuccess = 0; 14 | 15 | public: 16 | bool enabled() const { 17 | return (mExplanationCalled > 0) || (mExplanationSuccess > 0); 18 | } 19 | void collect() { 20 | Statistics::addKeyValuePair("explanation_called", mExplanationCalled); 21 | Statistics::addKeyValuePair("explanation_success", mExplanationSuccess); 22 | } 23 | 24 | void explanationCalled() { 25 | ++mExplanationCalled; 26 | } 27 | 28 | void explanationSuccess() { 29 | ++mExplanationSuccess; 30 | } 31 | }; 32 | 33 | } // namespace mcsat 34 | } // namespace smtrat 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/onecellcad/utils.cpp: -------------------------------------------------------------------------------- 1 | #include "utils.h" 2 | 3 | #ifdef SMTRAT_DEVOPTION_Statistics 4 | namespace smtrat { 5 | namespace mcsat { 6 | namespace onecellcad { 7 | OCStatistics &getStatistic() { 8 | static OCStatistics &mStatistics = statistics_get("mcsat-explanation-onecellcad"); 9 | return mStatistics; 10 | } 11 | } 12 | } 13 | } 14 | #endif 15 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/explanations/vs/Explanation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "VSStatistics.h" 4 | 5 | #include 6 | 7 | namespace smtrat { 8 | namespace mcsat { 9 | namespace vs { 10 | 11 | struct Explanation { 12 | 13 | #ifdef SMTRAT_DEVOPTION_Statistics 14 | VSStatistics& mStatistics = statistics_get("mcsat-explanation-vs"); 15 | #endif 16 | 17 | std::optional operator()(const mcsat::Bookkeeping& data, carl::Variable var, const FormulasT& reason, bool) const; 18 | }; 19 | 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-mcsat/smtrat-mcsat.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-mcsat.h" -------------------------------------------------------------------------------- /src/smtrat-mcsat/smtrat-mcsat.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "utils/Bookkeeping.h" 4 | #include "utils/ClauseChain.h" 5 | #include "utils/ConstraintCategorization.h" 6 | 7 | #include 8 | 9 | namespace smtrat { 10 | namespace mcsat { 11 | 12 | using ModelValues = std::vector>; 13 | using AssignmentOrConflict = std::variant; 14 | using Explanation = std::variant; 15 | 16 | inline FormulaT resolveExplanation(const Explanation& expl) { 17 | if (std::holds_alternative(expl)) { 18 | return std::get(expl); 19 | } else { 20 | return std::get(expl).resolve(); 21 | } 22 | } 23 | 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/smtrat-modules/.gitignore: -------------------------------------------------------------------------------- 1 | */*Instantiation.cpp 2 | Instantiation.h -------------------------------------------------------------------------------- /src/smtrat-modules/BEModule/BEModule.md: -------------------------------------------------------------------------------- 1 | # BEModule {#BEModule} 2 | 3 | 4 | -------------------------------------------------------------------------------- /src/smtrat-modules/BEModule/BESettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file BESettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-09-09 6 | * Created on 2015-09-09. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct BESettings1 14 | { 15 | static constexpr auto moduleName = "BEModule"; 16 | /** 17 | * Example for a setting. 18 | */ 19 | static const bool example_setting = true; 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-modules/BEModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(BEModule/BEModule.h) 3 | ModuleName(BEModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/BEModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/BVModule/BVModule.md: -------------------------------------------------------------------------------- 1 | BVModule {#BVModule} 2 | ===== 3 | 4 | This module implements an encoder for bitvector formulae to propositional logic. 5 | It is described in more detail in @cite Krueger2015. -------------------------------------------------------------------------------- /src/smtrat-modules/BVModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(BVModule/BVModule.h) 3 | ModuleName(BVModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/BVModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/CNFerModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(CNFerModule/CNFerModule.h) 3 | ModuleName(CNFerModule) 4 | ModuleClass(CNFerModule) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/CNFerModule/CNFerModule.md: -------------------------------------------------------------------------------- 1 | # CNFerModule {#CNFerModule} 2 | 3 | Transforms its received formula into conjunctive normal form CNF. 4 | 5 | ### Efficiency 6 | The worst case complexity of this module is polynomial in the number of operators in the formula to transform. 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/CSplitModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(CSplitModule/CSplitModule.h) 4 | ModuleName(CSplitModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | set(DEPEND-shared smtrat-module-LRAModule-LRASettings1-shared smtrat-module-SATModule-SATSettings1-shared PARENT_SCOPE) 9 | set(DEPEND-static smtrat-module-LRAModule-LRASettings1-static smtrat-module-SATModule-SATSettings1-static PARENT_SCOPE) 10 | -------------------------------------------------------------------------------- /src/smtrat-modules/CSplitModule/CSplitModule.md: -------------------------------------------------------------------------------- 1 | # CSplitModule {#CSplitModule} 2 | 3 | Implements solving for nonlinear integer arithmetic using incremental linearization. This module was implemented in @cite Sali2018 based on @cite Borralleras2012. -------------------------------------------------------------------------------- /src/smtrat-modules/CSplitModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CSplitInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2017-11-01 6 | * Created on 2017-11-01. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/CoCoAGBModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(CoCoAGBModule/CoCoAGBModule.h) 4 | ModuleName(CoCoAGBModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/CoCoAGBModule/CoCoAGBModule.md: -------------------------------------------------------------------------------- 1 | # CoCoAGBModule {#CoCoAGBModule} 2 | 3 | Uses Gröbner bases for theory solving, very much like smtrat::GBModule. 4 | However, for the underlying implementation of Gröbner bases, this module does not use carl::groebner but CoCoALib. -------------------------------------------------------------------------------- /src/smtrat-modules/CoCoAGBModule/CoCoAGBSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CoCoAGBSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2017-11-29 6 | * Created on 2017-11-29. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct CoCoAGBSettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "CoCoAGBModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool convert_inequalities = false; 21 | 22 | static constexpr bool always_return_unknown = false; 23 | }; 24 | 25 | struct CoCoAGBSettings2: CoCoAGBSettings1 { 26 | static constexpr bool always_return_unknown = true; 27 | }; 28 | } 29 | -------------------------------------------------------------------------------- /src/smtrat-modules/CoCoAGBModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CoCoAGBInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2017-11-29 6 | * Created on 2017-11-29. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/CoveringNGModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(CoveringNGModule/CoveringNGModule.h) 4 | ModuleName(CoveringNGModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | 9 | set(DEPEND-static smtrat-coveringng-static PARENT_SCOPE) 10 | set(DEPEND-shared smtrat-coveringng-shared PARENT_SCOPE) -------------------------------------------------------------------------------- /src/smtrat-modules/CoveringNGModule/CoveringNGModule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "CoveringNGSettings.h" 5 | 6 | namespace smtrat { 7 | 8 | template 9 | class CoveringNGModule : public Module { 10 | private: 11 | 12 | 13 | public: 14 | using SettingsType = Settings; 15 | 16 | CoveringNGModule(const ModuleInput* _formula, Conditionals& _conditionals, Manager* _manager = nullptr); 17 | 18 | ~CoveringNGModule(); 19 | 20 | bool informCore(const FormulaT& _constraint); 21 | bool addCore(ModuleInput::const_iterator _subformula); 22 | void removeCore(ModuleInput::const_iterator _subformula); 23 | void updateModel() const; 24 | Answer checkCore(); 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-modules/CoveringNGModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | ${INSTANTIATIONS} 5 | } 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/CubeLIAModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(CubeLIAModule/CubeLIAModule.h) 4 | ModuleName(CubeLIAModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | set(DEPEND-shared smtrat-module-LRAModule-LRASettings1-shared PARENT_SCOPE) 9 | set(DEPEND-static smtrat-module-LRAModule-LRASettings1-static PARENT_SCOPE) 10 | -------------------------------------------------------------------------------- /src/smtrat-modules/CubeLIAModule/CubeLIAModule.md: -------------------------------------------------------------------------------- 1 | # CubeLIAModule {#CubeLIAModule} 2 | 3 | Implements cube-based tests for linear integer arithmetic based on @cite Bromberger2016. -------------------------------------------------------------------------------- /src/smtrat-modules/CubeLIAModule/CubeLIASettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CubeLIASettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-11-24 6 | * Created on 2015-11-24. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct CubeLIASettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "CubeLIAModule"; 17 | /** 18 | * 19 | */ 20 | static const bool exclude_unsatisfiable_cube_space = false; 21 | 22 | }; 23 | } 24 | -------------------------------------------------------------------------------- /src/smtrat-modules/CubeLIAModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CubeLIAInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-11-24 6 | * Created on 2015-11-24. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/CurryModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(CurryModule/CurryModule.h) 4 | ModuleName(CurryModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/CurryModule/CurryModule.md: -------------------------------------------------------------------------------- 1 | # CurryModule {#CurryModule} 2 | 3 | Implements curryfiyng preprcessing as described in @cite Nieuwenhuis2007. -------------------------------------------------------------------------------- /src/smtrat-modules/CurryModule/CurrySettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CurrySettings.h 3 | * @author Henrich Lauko 4 | * @author Dominika Krejci 5 | * 6 | * @version 2018-11-18 7 | * Created on 2018-11-18. 8 | */ 9 | 10 | #pragma once 11 | 12 | namespace smtrat 13 | { 14 | struct CurrySettings1 15 | { 16 | /// Name of the Module 17 | static constexpr auto moduleName = "CurryModule"; 18 | /** 19 | * Example for a setting. 20 | */ 21 | static const bool example_setting = true; 22 | }; 23 | } 24 | -------------------------------------------------------------------------------- /src/smtrat-modules/CurryModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file CurryInstantiation.cpp.in 3 | * @author Henrich Lauko 4 | * @author Dominika Krejci 5 | * 6 | * @version 2018-11-18 7 | * Created on 2018-11-18. 8 | */ 9 | 10 | #include "${Prefix}Module.tpp" 11 | 12 | namespace smtrat { 13 | ${INSTANTIATIONS} 14 | } 15 | -------------------------------------------------------------------------------- /src/smtrat-modules/EMModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(EMModule/EMModule.h) 3 | ModuleName(EMModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/EMModule/EMModule.md: -------------------------------------------------------------------------------- 1 | # EMModule {#EMModule} 2 | 3 | This module addempts to eliminate multiple factors from equations and inequations. -------------------------------------------------------------------------------- /src/smtrat-modules/EMModule/EMSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file EMSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-09-10 6 | * Created on 2015-09-10. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct EMSettings1 14 | { 15 | static constexpr auto moduleName = "EMModule"; 16 | /** 17 | * Example for a setting. 18 | */ 19 | static const bool example_setting = true; 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-modules/EMModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/ESModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(ESModule/ESModule.h) 3 | ModuleName(ESModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/ESModule/ESModule.md: -------------------------------------------------------------------------------- 1 | # ESModule {#ESModule} 2 | 3 | Uses equations (or Boolean assertions) to eliminate variables from the remaining formula. Let the formula have the form \f$ e \land \varphi' \f$, then we use knowledge gained from \f$ e \f$ to simplify \f$ \varphi' \f$. If \f$ e \f$ is an arithmetic equation such that we can rewrite it to the form \f$ x = t \f$ (with \f$ x \f$ a variable) then we substitute \f$ t \f$ for \f$ x \f$ into \f$ \varphi' \f$. Otherwise we simply replace \f$ e \f$ with \f$ true \f$ in \f$ \varphi' \f$. 4 | This is done recursively in the formula. -------------------------------------------------------------------------------- /src/smtrat-modules/ESModule/ESSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file ESSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-09-09 6 | * Created on 2015-09-09. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct ESSettingsDefault 14 | { 15 | static constexpr auto moduleName = "ESModule"; 16 | 17 | static const std::size_t substitution_bitsize_limit = 0; // no limit 18 | }; 19 | 20 | struct ESSettingsLimitSubstitution 21 | { 22 | static constexpr auto moduleName = "ESModule"; 23 | 24 | // limit the bitsize of substitution to avoid explosion of coefficients 25 | static const std::size_t substitution_bitsize_limit = 500; 26 | }; 27 | } 28 | -------------------------------------------------------------------------------- /src/smtrat-modules/ESModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/FPPModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(FPPModule/FPPModule.h) 3 | ModuleName(FPPModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | 7 | set(DEPEND-shared smtrat-strategy-Preprocessing_PreprocessingOne-shared smtrat-strategy-Preprocessing_PreprocessingTwo-shared PARENT_SCOPE) 8 | set(DEPEND-static smtrat-strategy-Preprocessing_PreprocessingOne-static smtrat-strategy-Preprocessing_PreprocessingTwo-static PARENT_SCOPE) -------------------------------------------------------------------------------- /src/smtrat-modules/FPPModule/FPPModule.md: -------------------------------------------------------------------------------- 1 | # FPPModule {#FPPModule} 2 | 3 | This module implements a generic preprocessing facility. 4 | It runs a given strategy on the input and retrieves the simplified formula using the facilities of the [Manager](@ref smtrat::Manager) class. 5 | This process is iterated until a fix point is reached -- no further simplification was done by the strategy -- or a predefined number of iterations was performed. 6 | The resulting simplified formula is then forwarded to the backend. 7 | 8 | The strategy should be a linear sequence of preprocessing modules, as passing simplified formulas back to the caller is not possible in a meaningful way for general [Module](@ref smtrat::Module) classes. 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/FPPModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/CHANGELOG: -------------------------------------------------------------------------------- 1 | Version 0.5.0 2 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(GBModule/GBModule.h) 3 | ModuleName(GBModule) 4 | ModuleVersion(0 5 0) 5 | ModuleSettingsName(output) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/GBModule.md: -------------------------------------------------------------------------------- 1 | # GBModule {#GBModule} 2 | 3 | Implements the Gröbner bases based procedure as presented in @cite Junges2013. In general, this procedure can detect only the unsatisfiability of a conjunction of equations. This module also supports the usage of these equations to further simplify all constraints in the conjunction of constraints forming its input and passes these simplified constraints to its backends. However, it cannot be guaranteed that backends perform better on the simplified constraints than on the constraints before simplification. 4 | 5 | ### Efficiency 6 | The worst case complexity of the underlying procedure is exponential in the number of variables of the input constraints. In the case that the conjunction of constraints to check for satisfiability contains equations, this module can be more efficient than other modules for NRA on finding out inconsistency. -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/UsingDeclarations.h: -------------------------------------------------------------------------------- 1 | /* 2 | * File: UsingDeclarations.h 3 | * Author: Sebastian Junges 4 | * 5 | * Created on January 7, 2013, 3:28 PM 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | #include 12 | 13 | typedef carl::BitVector BitVector; 14 | 15 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBModule/VariableRewriteRule.h: -------------------------------------------------------------------------------- 1 | /* 2 | * File: VariableRewriteRule.h 3 | * Author: Sebastian Junges 4 | * 5 | * Created on January 7, 2013 6 | */ 7 | 8 | 9 | #pragma once 10 | 11 | #include "UsingDeclarations.h" 12 | 13 | 14 | namespace smtrat{ 15 | class VariableRewriteRule { 16 | public: 17 | VariableRewriteRule(unsigned varNr, const TermT& term, const carl::BitVector& reasons ) 18 | : mVarNr(varNr), mTerm(term), mReasons(reasons) 19 | { 20 | 21 | } 22 | 23 | ~VariableRewriteRule() 24 | { 25 | 26 | } 27 | protected: 28 | /// Rewrite a variable (identified by this number) 29 | unsigned mVarNr; 30 | /// Rewrite with this term 31 | TermT mTerm; 32 | /// Based on this origins 33 | carl::BitVector mReasons; 34 | }; 35 | } 36 | 37 | 38 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBPPModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(GBPPModule/GBPPModule.h) 4 | ModuleName(GBPPModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/GBPPModule/GBPPModule.md: -------------------------------------------------------------------------------- 1 | # GBPPModule {#GBPPModule} 2 | 3 | Uses Gröbner basis computations to simplify the input formula. 4 | The underlying implementation of Gröbner bases is used from carl::groebner. 5 | 6 | The fundamental idea is as follows: 7 | Separate the input formula into equalities and inequalities and compute the Gröbner basis of the equalities. 8 | Now we can replace the equalities with the Gröbner basis (if this "seems easier") and also simplify the inequalities using the Gröbner basis. -------------------------------------------------------------------------------- /src/smtrat-modules/GBPPModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file GBPPInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2018-03-09 6 | * Created on 2018-03-09. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICEModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(ICEModule/ICEModule.h) 4 | ModuleName(ICEModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICEModule/ICEModule.md: -------------------------------------------------------------------------------- 1 | # ICEModule {#ICEModule} 2 | 3 | This module tries to find simple chains of inequalities that can be combined to form a cycle. It converts constraints of the form \f$ x \geq y + z \f$ to a hypergraph (with an edge going from \f$ x \f$ to \f$ y,z \f$) and uses the coefficients as edge weights. 4 | If this hypergraph contains cycles, these can be used to infer additional constraints on the individual variables. In particular, zero cycles induce equality of variables while negative cycles reveal conflicts. 5 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICEModule/ICESettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file ICESettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-11-24 6 | * Created on 2015-11-24. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct ICESettings1 14 | { 15 | static constexpr auto moduleName = "ICEModule"; 16 | 17 | static constexpr bool dumpAsDot = false; 18 | static constexpr auto dotFilename = "licgraph.dot"; 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICEModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file ICEInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-11-24 6 | * Created on 2015-11-24. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICPModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(ICPModule/ICPModule.h) 3 | ModuleName(ICPModule) 4 | ModuleVersion(1 0 0) 5 | EndDefineModule() 6 | 7 | set(DEPEND-shared smtrat-module-LRAModule-LRASettingsICP-shared PARENT_SCOPE) 8 | set(DEPEND-static smtrat-module-LRAModule-LRASettingsICP-static PARENT_SCOPE) 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/ICPModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/IncWidthModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(IncWidthModule/IncWidthModule.h) 3 | ModuleName(IncWidthModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/IncWidthModule/IncWidthModule.md: -------------------------------------------------------------------------------- 1 | # IncWidthModule {#IncWidthModule} 2 | 3 | This module is meant to be used for solving nonlinear integer arithmetic problems by encoding them into bitvector arithmetic formulas (as done in smtrat::IntBlastModule), as described in @cite Krueger2015 and @cite Kremer2016, both (heavily) inspired by @cite Fuhs2007. 4 | This approach heavily benefits from knowing bounds on individual variables, both in terms of its ability to find infeasibility and its performance in general. 5 | 6 | In this module, we use smtrat::ICPModule to infer new bounds and call the backend incrementally with growing bounds until the computed upper bounds are met. -------------------------------------------------------------------------------- /src/smtrat-modules/IncWidthModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/IntBlastModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(IntBlastModule/IntBlastModule.h) 3 | ModuleName(IntBlastModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | 7 | set(DEPEND-shared smtrat-module-ICPModule-ICPSettings1-shared smtrat-strategy-BVSolver-shared PARENT_SCOPE) 8 | set(DEPEND-static smtrat-module-ICPModule-ICPSettings1-static smtrat-strategy-BVSolver-static PARENT_SCOPE) 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/IntBlastModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/IntBlastModule/IntBlastModule.md: -------------------------------------------------------------------------------- 1 | # IntBlastModule {#IntBlastModule} 2 | 3 | This module implements encoding nonlinear integer arithmetic problems into bitvector arithmetic formulas as described in @cite Krueger2015 and @cite Kremer2016, both (heavily) inspired by @cite Fuhs2007. -------------------------------------------------------------------------------- /src/smtrat-modules/IntEqModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(IntEqModule/IntEqModule.h) 3 | ModuleName(IntEqModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/IntEqModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/IntEqModule/IntEqModule.md: -------------------------------------------------------------------------------- 1 | # IntEqModule {#IntEqModule} 2 | 3 | Implements the SMT compliant equation elimination method presented in @cite Griggio2012. 4 | Hence, this module either determines that the equations of an instance are unsatisfiable 5 | or calculates a certain number of substitutions for variables. The latter can be used to 6 | eliminate the equations by substituting every variable for which a substitution exists 7 | by its substitution. The set of constraints that we obtain with this procedure, not containing equations 8 | anymore, is passed to the backends. -------------------------------------------------------------------------------- /src/smtrat-modules/IntEqModule/IntEqSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file IntEqSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2014-11-24 6 | * Created on 2014-11-24. 7 | */ 8 | 9 | 10 | #pragma once 11 | 12 | namespace smtrat 13 | { 14 | struct IntEqSettings1 15 | { 16 | static constexpr auto moduleName = "IntEqModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool example_setting = true; 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-modules/LRAModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(LRAModule/LRAModule.h) 3 | ModuleName(LRAModule) 4 | ModuleVersion(1 0 0) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/LRAModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/LVEModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(LVEModule/LVEModule.h) 4 | ModuleName(LVEModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/LVEModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file LVEInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2019-02-20 6 | * Created on 2019-02-20. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/LVEModule/LVEModule.md: -------------------------------------------------------------------------------- 1 | # LVEModule {#LVEModule} 2 | 3 | This module aims to eliminate lone variables that only occur once. 4 | We call a variable a lone variable if it only occurs in a single constraint. 5 | Furthermore we only try to eliminate the variable if this constraint is a top-level constraint. 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/LVEModule/LVESettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file LVESettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2019-02-20 6 | * Created on 2019-02-20. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct LVESettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "LVEModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool example_setting = true; 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-modules/LVEModule/LVEStatistics.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #ifdef SMTRAT_DEVOPTION_Statistics 5 | #include 6 | 7 | namespace smtrat 8 | { 9 | class LVEStatistics : public Statistics { 10 | public: 11 | std::size_t lone_variables = 0; 12 | std::size_t eliminated = 0; 13 | 14 | std::size_t elim_linear = 0; 15 | std::size_t elim_factors = 0; 16 | 17 | void collect() { 18 | Statistics::addKeyValuePair("lone_variables", lone_variables); 19 | Statistics::addKeyValuePair("eliminated", eliminated); 20 | Statistics::addKeyValuePair("elim_linear", elim_linear); 21 | Statistics::addKeyValuePair("elim_factors", elim_factors); 22 | } 23 | }; 24 | } 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/smtrat-modules/MCBModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(MCBModule/MCBModule.h) 4 | ModuleName(MCBModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/MCBModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file MCBInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-12-10 6 | * Created on 2015-12-10. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/MCBModule/MCBModule.md: -------------------------------------------------------------------------------- 1 | # MCBModule {#MCBModule} 2 | 3 | This module attempts to detect logic structures that essentially encode a multiple-choice on an arithmetic variable. It extracts this information and translates it to a Boolean structure, thereby eliminating the arithmetic variable. -------------------------------------------------------------------------------- /src/smtrat-modules/MCBModule/MCBSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file MCBSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-12-10 6 | * Created on 2015-12-10. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct MCBSettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "MCBModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool example_setting = true; 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(AbstractModule/AbstractModule.h) 4 | ModuleName(AbstractModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file AbstractInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2018-07-12 6 | * Created on 2018-07-12. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/LOG.h: -------------------------------------------------------------------------------- 1 | 2 | #pragma once 3 | 4 | namespace smtrat { 5 | class LOG : public carl::Singleton{ 6 | friend class carl::Singleton; 7 | 8 | public: 9 | bool debugEnabled = false; 10 | bool isDebugEnabled() { 11 | return debugEnabled; 12 | } 13 | }; 14 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/NRAILModule.md: -------------------------------------------------------------------------------- 1 | # NRAILModule {#NRAILModule} 2 | 3 | This module implements incremental linearization as described in @cite Zaman2019, roughly following @cite Cimatti2017 and @cite Irfan2018. 4 | In addition, it implements an ICP-based axiom instantiation. -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/Util.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "unordered_map" 5 | #include 6 | 7 | 8 | namespace smtrat 9 | { 10 | typedef std::unordered_map::iterator MonomialMapIterator; 11 | typedef std::unordered_map MonomialMap; 12 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/dto/RationalCapsule.cpp: -------------------------------------------------------------------------------- 1 | #include "RationalCapsule.h" 2 | 3 | namespace smtrat { 4 | 5 | RationalCapsule::RationalCapsule(const Rational &aRational, const Rational &bRational, 6 | const Rational &cRational) : aRational(aRational), bRational(bRational), 7 | cRational(cRational) {} 8 | 9 | const smtrat::Rational &smtrat::RationalCapsule::getARational() const { 10 | return aRational; 11 | } 12 | 13 | const smtrat::Rational &smtrat::RationalCapsule::getBRational() const { 14 | return bRational; 15 | } 16 | 17 | const smtrat::Rational &smtrat::RationalCapsule::getCRational() const { 18 | return cRational; 19 | } 20 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/dto/RationalCapsule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat { 6 | 7 | class RationalCapsule { 8 | public: 9 | RationalCapsule(const Rational &aRational, const Rational &bRational, 10 | const Rational &cRational); 11 | Rational aRational = aRational; 12 | Rational bRational = bRational; 13 | Rational cRational = cRational; 14 | 15 | const Rational &getARational() const; 16 | 17 | const Rational &getBRational() const; 18 | 19 | const Rational &getCRational() const; 20 | 21 | }; 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/dto/VariableCapsule.cpp: -------------------------------------------------------------------------------- 1 | #include "VariableCapsule.h" 2 | 3 | namespace smtrat { 4 | 5 | VariableCapsule::VariableCapsule(const carl::Variable &xVariable, const carl::Variable &yVariable, 6 | const carl::Variable &zVariable) : xVariable(xVariable), yVariable(yVariable), 7 | zVariable(zVariable) {} 8 | 9 | const carl::Variable &VariableCapsule::getXVariable() const { 10 | return xVariable; 11 | } 12 | 13 | const carl::Variable &VariableCapsule::getYVariable() const { 14 | return yVariable; 15 | } 16 | 17 | const carl::Variable &VariableCapsule::getZVariable() const { 18 | return zVariable; 19 | } 20 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/dto/VariableCapsule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat 6 | { 7 | 8 | class VariableCapsule { 9 | 10 | public: 11 | VariableCapsule(const carl::Variable &xVariable, const carl::Variable &yVariable, 12 | const carl::Variable &zVariable); 13 | carl::Variable xVariable; 14 | carl::Variable yVariable; 15 | carl::Variable zVariable; 16 | const carl::Variable &getXVariable() const; 17 | const carl::Variable &getYVariable() const; 18 | const carl::Variable &getZVariable() const; 19 | 20 | }; 21 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NRAILModule/factory/AxiomFactory.h: -------------------------------------------------------------------------------- 1 | /** 2 | * Class to create the formulas for axioms. 3 | * @author Aklima Zaman 4 | * @since 2018-09-24 5 | * @version 2018-09-24 6 | */ 7 | 8 | #pragma once 9 | 10 | 11 | #include "../dto/VariableCapsule.h" 12 | #include 13 | #include "../Util.h" 14 | #include "../../../smtrat-common/model.h" 15 | #include "../dto/RationalCapsule.h" 16 | 17 | namespace smtrat { 18 | 19 | class AxiomFactory { 20 | 21 | public: 22 | enum AxiomType { ZERO, TANGENT_PLANE, MONOTONICITY, CONGRUENCE, ICP }; 23 | static FormulasT createFormula(AxiomType axiomType, Model linearizedModel, MonomialMap monomialMap); 24 | }; 25 | 26 | } -------------------------------------------------------------------------------- /src/smtrat-modules/NewCADModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(NewCADModule/NewCADModule.h) 3 | ModuleName(NewCADModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | 7 | set(DEPEND-shared smtrat-cad-shared PARENT_SCOPE) 8 | set(DEPEND-static smtrat-cad-static PARENT_SCOPE) 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewCADModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file NewCADInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2016-02-23 6 | * Created on 2016-02-23. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewCADModule/NewCADModule.md: -------------------------------------------------------------------------------- 1 | # NewCADModule {#NewCADModule} 2 | 3 | This module is based on the implementation in smtrat::cad. 4 | It is described in @cite Kremer2019 in some detail. -------------------------------------------------------------------------------- /src/smtrat-modules/NewCoveringModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(NewCoveringModule/NewCoveringModule.h) 4 | ModuleName(NewCoveringModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | 9 | set(DEPEND-static smtrat-cadcells-static PARENT_SCOPE) 10 | set(DEPEND-shared smtrat-cadcells-shared PARENT_SCOPE) -------------------------------------------------------------------------------- /src/smtrat-modules/NewCoveringModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file NewCoveringInstantiation.cpp.in 3 | * @author Philip Kroll 4 | * 5 | * @version 2021-07-08 6 | * Created on 2021-07-08. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewGBPPModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(NewGBPPModule/NewGBPPModule.h) 4 | ModuleName(NewGBPPModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewGBPPModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | ${INSTANTIATIONS} 5 | } 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewGBPPModule/NewGBPPModule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "NewGBPPSettings.h" 4 | #include 5 | 6 | namespace smtrat { 7 | template 8 | class NewGBPPModule : public PModule { 9 | 10 | public: 11 | typedef Settings SettingsType; 12 | NewGBPPModule(const ModuleInput* _formula, Conditionals& _conditionals, Manager* _manager = nullptr); 13 | ~NewGBPPModule(); 14 | void updateModel() const { mModel.clear(); }; 15 | Answer checkCore(); 16 | }; 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-modules/NewGBPPModule/NewGBPPSettings.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace smtrat { 4 | struct NewGBPPSettings1 { 5 | static constexpr auto moduleName = "NewGBPPModule"; 6 | }; 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/NuCADModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(NuCADModule/NuCADModule.h) 4 | ModuleName(NuCADModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | 9 | set(DEPEND-static smtrat-coveringng-static PARENT_SCOPE) 10 | set(DEPEND-shared smtrat-coveringng-shared PARENT_SCOPE) -------------------------------------------------------------------------------- /src/smtrat-modules/NuCADModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | ${INSTANTIATIONS} 5 | } 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/NuCADModule/NuCADModule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "NuCADSettings.h" 5 | 6 | namespace smtrat { 7 | 8 | template 9 | class NuCADModule : public Module { 10 | private: 11 | 12 | 13 | public: 14 | using SettingsType = Settings; 15 | 16 | NuCADModule(const ModuleInput* _formula, Conditionals& _conditionals, Manager* _manager = nullptr); 17 | 18 | ~NuCADModule(); 19 | 20 | bool informCore(const FormulaT& _constraint); 21 | bool addCore(ModuleInput::const_iterator _subformula); 22 | void removeCore(ModuleInput::const_iterator _subformula); 23 | void updateModel() const; 24 | Answer checkCore(); 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBGaussModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(PBGaussModule/PBGaussModule.h) 4 | ModuleName(PBGaussModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBGaussModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file PBGaussInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2017-05-03 6 | * Created on 2017-05-03. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBGaussModule/PBGaussModule.md: -------------------------------------------------------------------------------- 1 | # PBGaussModule {#PBGaussModule} 2 | 3 | This module tries to simplify pseudo-Boolean problems using Gauss as described in @cite Grobelna2017. 4 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBGaussModule/PBGaussSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file PBGaussSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2017-05-03 6 | * Created on 2017-05-03. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct PBGaussSettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "PBGaussModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool example_setting = true; 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(PBPPModule/PBPPModule.h) 4 | ModuleName(PBPPModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/Encoders/ExactlyOneCommanderEncoder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "PseudoBoolEncoder.h" 4 | #include "CardinalityEncoder.h" 5 | 6 | namespace smtrat { 7 | 8 | class ExactlyOneCommanderEncoder : public PseudoBoolEncoder { 9 | private: 10 | CardinalityEncoder mCardinalityEncoder; 11 | 12 | public: 13 | ExactlyOneCommanderEncoder() : PseudoBoolEncoder () {} 14 | 15 | Rational encodingSize(const ConstraintT& constraint); 16 | 17 | bool canEncode(const ConstraintT& constraint); 18 | 19 | std::string name() { return "ExactlyOneCommanderEncoder"; } 20 | 21 | protected: 22 | std::optional doEncode(const ConstraintT& constraint); 23 | 24 | private: 25 | std::map> partition(carl::Variables); 26 | 27 | }; 28 | 29 | } 30 | 31 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/Encoders/LongFormulaEncoder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "PseudoBoolEncoder.h" 4 | 5 | namespace smtrat { 6 | class LongFormulaEncoder : public PseudoBoolEncoder { 7 | public: 8 | LongFormulaEncoder() : PseudoBoolEncoder () {} 9 | 10 | bool canEncode(const ConstraintT& constraint); 11 | Rational encodingSize(const ConstraintT& constraint); 12 | 13 | std::string name() { return "LongFormulaEncoder"; } 14 | 15 | protected: 16 | std::optional doEncode(const ConstraintT& constraint); 17 | 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/Encoders/ShortFormulaEncoder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "PseudoBoolEncoder.h" 4 | 5 | namespace smtrat { 6 | class ShortFormulaEncoder : public PseudoBoolEncoder { 7 | public: 8 | ShortFormulaEncoder() : PseudoBoolEncoder () {} 9 | 10 | bool canEncode(const ConstraintT& constraint); 11 | 12 | Rational encodingSize(const ConstraintT& constraint); 13 | 14 | std::string name() { return "ShortFormulaEncoder"; } 15 | 16 | protected: 17 | std::optional doEncode(const ConstraintT& constraint); 18 | 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file PBPPInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2016-11-23 6 | * Created on 2016-11-23. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/PBPPModule.md: -------------------------------------------------------------------------------- 1 | # PBPPModule {#PBPPModule} 2 | 3 | This module implements a variety of preprocessing techniques for pseudo-Boolean problems. Many of them are based on @cite Grobelna2017. -------------------------------------------------------------------------------- /src/smtrat-modules/PBPPModule/PBPPStatistics.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file PBPPStatistics.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2016-11-23 6 | * Created on 2016-11-23. 7 | */ 8 | 9 | #pragma once 10 | 11 | #include 12 | #ifdef SMTRAT_DEVOPTION_Statistics 13 | #include 14 | 15 | namespace smtrat 16 | { 17 | class PBPPStatistics : public Statistics 18 | { 19 | private: 20 | public: 21 | // Override Statistics::collect. 22 | void collect() 23 | { 24 | } 25 | PBPPStatistics( const std::string& _statisticName ): 26 | Statistics( ) 27 | { 28 | set_name(_statisticName); 29 | } 30 | ~PBPPStatistics() {} 31 | }; 32 | } 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/smtrat-modules/PFEModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(PFEModule/PFEModule.h) 3 | ModuleName(PFEModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/PFEModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/PFEModule/PFESettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file PFESettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-09-10 6 | * Created on 2015-09-10. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct PFESettings1 14 | { 15 | static constexpr auto moduleName = "PFEModule"; 16 | /** 17 | * Example for a setting. 18 | */ 19 | static const bool example_setting = true; 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-modules/PNFerModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(PNFerModule/PNFerModule.h) 3 | ModuleName(PNFerModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() -------------------------------------------------------------------------------- /src/smtrat-modules/PNFerModule/PNFerModule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat { 6 | class PNFerModule : public PModule { 7 | 8 | public: 9 | struct SettingsType { 10 | static constexpr auto moduleName = "PNFerModule"; 11 | }; 12 | 13 | PNFerModule(const ModuleInput*, Conditionals&, Manager* const = NULL); 14 | ~PNFerModule(); 15 | 16 | /** 17 | * Checks the received formula for consistency. 18 | * @return SAT, if the received formula is satisfiable; 19 | * UNSAT, if the received formula is not satisfiable; 20 | * Unknown, otherwise. 21 | */ 22 | Answer checkCore(); 23 | }; 24 | 25 | } // namespace smtrat 26 | -------------------------------------------------------------------------------- /src/smtrat-modules/PNFerModule/PNFerModule.md: -------------------------------------------------------------------------------- 1 | # PNFerModule {#PNFerModule} 2 | 3 | Transforms its received formula into PNF. -------------------------------------------------------------------------------- /src/smtrat-modules/SATModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(SATModule/SATModule.h) 3 | ModuleName(SATModule) 4 | ModuleVersion(1 0 0) 5 | EndDefineModule() 6 | 7 | set(DEPEND-shared smtrat-mcsat-shared PARENT_SCOPE) 8 | set(DEPEND-static smtrat-mcsat-static PARENT_SCOPE) 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/SATModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/STropModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(STropModule/STropModule.h) 4 | ModuleName(STropModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | 8 | set(DEPEND-shared smtrat-module-LRAModule-LRASettings1-shared smtrat-module-SATModule-SATSettings1-shared PARENT_SCOPE) 9 | set(DEPEND-static smtrat-module-LRAModule-LRASettings1-static smtrat-module-SATModule-SATSettings1-static PARENT_SCOPE) 10 | -------------------------------------------------------------------------------- /src/smtrat-modules/STropModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file STropInstantiation.cpp.in 3 | * @author Ömer Sali 4 | * 5 | * @version 2017-09-13 6 | * Created on 2017-09-13. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/STropModule/STropModule.md: -------------------------------------------------------------------------------- 1 | # STropModule {#STropModule} 2 | 3 | Implements the subtropical satisfiability method as described in @cite Sali2018 based on @cite Fontaine2017. -------------------------------------------------------------------------------- /src/smtrat-modules/SimplexModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(SimplexModule/SimplexModule.h) 4 | ModuleName(SimplexModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/SimplexModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file SimplexInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2023-04-28 6 | * Created on 2023-04-28. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/SimplexModule/SimplexModule.md: -------------------------------------------------------------------------------- 1 | # SimplexModule (#SimplexModule) 2 | 3 | Implements the general simplex method for solving conjunctions of linear real arithmetic constraints. 4 | This implementation is heavily inspired by the on in z3. -------------------------------------------------------------------------------- /src/smtrat-modules/SimplexModule/simplex/VariableInfo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace smtrat::simplex { 4 | 5 | using Variable = std::size_t; 6 | 7 | using ConflictActivity = double; 8 | 9 | struct VariableInfo { 10 | bool m_is_basic = false; 11 | bool m_is_integer; 12 | bool m_is_original; 13 | ConflictActivity m_conflict_activity = 0; // Can be used for pivoting strategies 14 | std::size_t m_tableau_index = 0; // Row or Column, if basic or non-basic REVIEW: model as union? 15 | VariableInfo(bool is_int, bool is_orig) : m_is_integer(is_int), m_is_original(is_orig) {} 16 | }; 17 | 18 | } -------------------------------------------------------------------------------- /src/smtrat-modules/SplitSOSModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(SplitSOSModule/SplitSOSModule.h) 3 | ModuleName(SplitSOSModule) 4 | ModuleVersion(0 0 1) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/SplitSOSModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-modules/SplitSOSModule/SplitSOSModule.md: -------------------------------------------------------------------------------- 1 | # SplitSOSModule {#SplitSOSModule} 2 | 3 | Splits the left hand side of constraints according to their sum-of-squares decomposition. -------------------------------------------------------------------------------- /src/smtrat-modules/SplitSOSModule/SplitSOSSettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file SplitSOSSettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2015-09-10 6 | * Created on 2015-09-10. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct SplitSOSSettings1 14 | { 15 | static constexpr auto moduleName = "SplitSOSModule"; 16 | /** 17 | * Example for a setting. 18 | */ 19 | static const bool example_setting = true; 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-modules/SymmetryModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | BeginDefineModule() 3 | ModuleMainHeader(SymmetryModule/SymmetryModule.h) 4 | ModuleName(SymmetryModule) 5 | ModuleVersion(0 0 1) 6 | EndDefineModule() 7 | -------------------------------------------------------------------------------- /src/smtrat-modules/SymmetryModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | /** 2 | * @file SymmetryInstantiation.cpp.in 3 | * @author YOUR NAME 4 | * 5 | * @version 2018-03-12 6 | * Created on 2018-03-12. 7 | */ 8 | 9 | #include "${Prefix}Module.tpp" 10 | 11 | namespace smtrat { 12 | ${INSTANTIATIONS} 13 | } 14 | -------------------------------------------------------------------------------- /src/smtrat-modules/SymmetryModule/SymmetryModule.md: -------------------------------------------------------------------------------- 1 | # SymmetryModule {#SymmetryModule} 2 | 3 | This module tries to recognize syntactic symmetries in the input formula and adds symmetry breaking constraints. 4 | The core functionality is provided by CArL through carl::formula::breakSymmetries() which internally encodes the formula as a graph and uses bliss to find automorphisms on this graph. 5 | 6 | ### Efficiency 7 | Finding automorphisms is as difficult as determining whether two graphs are isomorphic, and it is not known whether this problem can be solved in polynomial or exponential time. 8 | In practice, current solvers like bliss perform very good on large graphs and we therefore assume this module to be sufficiently fast. 9 | -------------------------------------------------------------------------------- /src/smtrat-modules/SymmetryModule/SymmetrySettings.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file SymmetrySettings.h 3 | * @author YOUR NAME 4 | * 5 | * @version 2018-03-12 6 | * Created on 2018-03-12. 7 | */ 8 | 9 | #pragma once 10 | 11 | namespace smtrat 12 | { 13 | struct SymmetrySettings1 14 | { 15 | /// Name of the Module 16 | static constexpr auto moduleName = "SymmetryModule"; 17 | /** 18 | * Example for a setting. 19 | */ 20 | static const bool example_setting = true; 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/smtrat-modules/VSModule/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | BeginDefineModule() 2 | ModuleMainHeader(VSModule/VSModule.h) 3 | ModuleName(VSModule) 4 | ModuleVersion(1 0 0) 5 | EndDefineModule() 6 | -------------------------------------------------------------------------------- /src/smtrat-modules/VSModule/Instantiation.cpp.in: -------------------------------------------------------------------------------- 1 | #include "${Prefix}Module.tpp" 2 | 3 | namespace smtrat { 4 | 5 | ${INSTANTIATIONS} 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/smtrat-optimization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-optimization_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-optimization ${PROJECT_VERSION_LIB} "${smtrat-optimization_sources}" "resources") 10 | target_include_dirs_from(smtrat-optimization-objects "" PUBLIC smtrat-common-shared carl-arith-shared) 11 | target_link_libraries(smtrat-optimization-shared smtrat-common-shared carl-arith-shared) 12 | target_link_libraries(smtrat-optimization-static smtrat-common-static carl-arith-static) 13 | 14 | install_libraries(smtrat smtrat-optimization-shared smtrat-optimization-static) 15 | 16 | -------------------------------------------------------------------------------- /src/smtrat-optimization/smtrat-optimization.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-optimization.h" -------------------------------------------------------------------------------- /src/smtrat-optimization/smtrat-optimization.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Optimization.h" -------------------------------------------------------------------------------- /src/smtrat-qe/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-qe_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-qe "${PROJECT_VERSION_LIB}" "${smtrat-qe_sources}" "resources") 10 | target_include_dirs_from(smtrat-qe-objects "" PUBLIC smtrat-common-shared carl-formula-shared) 11 | target_link_libraries(smtrat-qe-shared smtrat-common-shared carl-formula-shared smtrat-coveringng-shared) 12 | target_link_libraries(smtrat-qe-static smtrat-common-static carl-formula-static smtrat-coveringng-static) 13 | 14 | install_libraries(smtrat smtrat-qe-shared smtrat-qe-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-qe/cad/qe.cpp: -------------------------------------------------------------------------------- 1 | #include "qe.h" 2 | 3 | #include "CADElimination.h" 4 | 5 | namespace smtrat::qe::cad { 6 | 7 | FormulaT eliminateQuantifiers(const FormulaT& qfree, const QEQuery& quantifiers) { 8 | cad::CADElimination elim(qfree, quantifiers); 9 | return elim.eliminateQuantifiers(); 10 | } 11 | 12 | } -------------------------------------------------------------------------------- /src/smtrat-qe/cad/qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../QEQuery.h" 4 | 5 | #include 6 | 7 | namespace smtrat::qe::cad { 8 | 9 | FormulaT eliminateQuantifiers(const FormulaT& qfree, const QEQuery& quantifiers); 10 | 11 | } -------------------------------------------------------------------------------- /src/smtrat-qe/coverings/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace smtrat::qe::coverings { 4 | using Settings = @SMTRAT_Settings_QE_CAlC@; 5 | } -------------------------------------------------------------------------------- /src/smtrat-qe/coverings/qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include "Settings.h" 15 | #include "smtrat-cadcells/datastructures/roots.h" 16 | #include "smtrat-coveringng/VariableOrdering.h" 17 | 18 | #include "config.h" 19 | 20 | namespace smtrat::qe::coverings { 21 | 22 | // using Settings = DefaultSettings; 23 | 24 | std::optional qe(const FormulaT& formula); 25 | 26 | } // namespace smtrat::qe::coverings 27 | -------------------------------------------------------------------------------- /src/smtrat-qe/coverings/util/to_formula.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat::qe::coverings::util { 7 | 8 | FormulaT to_formula(const cadcells::datastructures::PolyPool& pool, carl::Variable variable, const cadcells::datastructures::SymbolicInterval& interval); 9 | 10 | FormulaT to_formula_true_only(const cadcells::datastructures::PolyPool& pool, const covering_ng::ParameterTree& tree); 11 | 12 | FormulaT to_formula_alternate(const cadcells::datastructures::PolyPool& pool, const covering_ng::ParameterTree& tree); 13 | 14 | } // namespace smtrat::qe::coverings -------------------------------------------------------------------------------- /src/smtrat-qe/fm/qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../QEQuery.h" 4 | 5 | #include 6 | 7 | namespace smtrat::qe::fm { 8 | 9 | std::optional qe(const FormulaT& f); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /src/smtrat-qe/fmplex/qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../QEQuery.h" 4 | #include 5 | 6 | namespace smtrat::qe::fmplex { 7 | 8 | std::optional qe(const FormulaT& f); 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/smtrat-qe/nucad/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace smtrat::qe::nucad { 4 | using Settings = @SMTRAT_Settings_QE_NuCAD@; 5 | } -------------------------------------------------------------------------------- /src/smtrat-qe/nucad/qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include "Settings.h" 15 | #include "smtrat-cadcells/datastructures/roots.h" 16 | #include "smtrat-coveringng/VariableOrdering.h" 17 | 18 | #include "config.h" 19 | 20 | namespace smtrat::qe::nucad { 21 | 22 | // using Settings = DefaultSettings; 23 | // using Settings = DefaultBCFilterSettings; 24 | // using Settings = DefaultBCFilterEWSettings; 25 | 26 | std::optional qe(const FormulaT& formula); 27 | 28 | } // namespace smtrat::qe::nucad 29 | -------------------------------------------------------------------------------- /src/smtrat-qe/nucad/util/to_formula.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat::qe::nucad::util { 7 | 8 | FormulaT to_formula_true_only_elim_redundant(const cadcells::datastructures::PolyPool& pool, const covering_ng::ParameterTree& tree); 9 | 10 | FormulaT to_formula_alternate_elim_redundant(const cadcells::datastructures::PolyPool& pool, const covering_ng::ParameterTree& tree); 11 | 12 | } // namespace smtrat::qe::nucad -------------------------------------------------------------------------------- /src/smtrat-qe/smtrat-qe.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-qe.h" 2 | 3 | //#include "cad/qe.h" 4 | #include "fm/qe.h" 5 | #include "fmplex/qe.h" 6 | #include "coverings/qe.h" 7 | #include "nucad/qe.h" 8 | 9 | namespace smtrat::qe { 10 | 11 | std::optional qe(const FormulaT& formula) { 12 | std::string qe_method = settings_module().get("qe-method", std::string("covering")); 13 | if (qe_method == "covering") return coverings::qe(formula); 14 | if (qe_method == "nucad") return nucad::qe(formula); 15 | if (qe_method == "fmplex") return fmplex::qe(formula); 16 | if (qe_method == "fm") return fm::qe(formula); 17 | 18 | SMTRAT_LOG_WARN("smtrat.qe", "Unknown qe-method " << qe_method << "."); 19 | SMTRAT_LOG_WARN("smtrat.qe", "Defaulting to covering."); 20 | return coverings::qe(formula); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /src/smtrat-qe/smtrat-qe.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace smtrat::qe { 6 | 7 | std::optional qe(const FormulaT& formula); 8 | 9 | } // namespace smtrat::qe -------------------------------------------------------------------------------- /src/smtrat-solver/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-solver_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-solver "${PROJECT_VERSION_LIB}" "${smtrat-solver_sources}" "resources") 10 | target_include_dirs_from(smtrat-solver-objects "" PUBLIC smtrat-common-shared carl-formula-shared) 11 | target_link_libraries(smtrat-solver-shared smtrat-common-shared carl-formula-shared) 12 | target_link_libraries(smtrat-solver-static smtrat-common-static carl-formula-static) 13 | 14 | install_libraries(smtrat smtrat-solver-shared smtrat-solver-static) 15 | -------------------------------------------------------------------------------- /src/smtrat-solver/smtrat-solver.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Manager.h" 4 | -------------------------------------------------------------------------------- /src/smtrat-strategies/config.h.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "strategies/@SMTRAT_Strategy@.h" 4 | #define CMakeStrategySolver smtrat::@strategy@ 5 | -------------------------------------------------------------------------------- /src/smtrat-strategies/smtrat-strategies.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-strategies.h" 2 | 3 | namespace smtrat { 4 | 5 | //void load_configured_strategy(Manager& m) { 6 | //} 7 | 8 | } -------------------------------------------------------------------------------- /src/smtrat-strategies/smtrat-strategies.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | // Use absolute include, otherwise cmake fails to add dependencies for config.h 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | //void load_configured_strategy(Manager& m); 11 | 12 | } -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/Approximation/common.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace apx = smtrat::cadcells::representation::approximation; 6 | 7 | namespace smtrat::strategies::approximation { 8 | 9 | struct OpSettings : cadcells::operators::MccallumFilteredSettings { 10 | static constexpr DelineationFunction delineation_function = COMPOUND_PWL; 11 | }; 12 | 13 | struct BaseOCSettings : smtrat::mcsat::onecell::BaseSettings { 14 | constexpr static bool exploit_strict_constraints = true; 15 | constexpr static bool use_approximation = true; 16 | 17 | using cell_heuristic = cadcells::representation::cell_heuristics::BiggestCellFilter; 18 | using covering_heuristic = cadcells::representation::covering_heuristics::BiggestCellCoveringFilter; 19 | using op = cadcells::operators::MccallumFiltered; 20 | }; 21 | 22 | } -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/Default.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | 8 | /** 9 | * The most efficient CoveringNG strategy with preprocessing. 10 | * 11 | */ 12 | class CoveringNG_Default: public Manager { 13 | public: 14 | CoveringNG_Default() : Manager() { 15 | setStrategy( 16 | addBackend>() 17 | ); 18 | } 19 | }; 20 | } // namespace smtrat 21 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/DefaultBC.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | namespace internal { 10 | 11 | struct CoveringNGSettings : CoveringNGSettingsDefault { 12 | using cell_heuristic = cadcells::representation::cell_heuristics::BiggestCell; 13 | using covering_heuristic = cadcells::representation::covering_heuristics::BiggestCellCovering; 14 | }; 15 | 16 | } 17 | 18 | class CoveringNG_DefaultBC: public Manager { 19 | public: 20 | CoveringNG_DefaultBC() : Manager() { 21 | setStrategy( 22 | addBackend>() 23 | ); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/DefaultCompound.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | namespace internal { 10 | 11 | struct CoveringNGSettings : CoveringNGSettingsDefault { 12 | using cell_heuristic = cadcells::representation::cell_heuristics::AllCompound; 13 | using covering_heuristic = cadcells::representation::covering_heuristics::AllCompoundCovering; 14 | }; 15 | 16 | } 17 | 18 | class CoveringNG_DefaultCompound: public Manager { 19 | public: 20 | CoveringNG_DefaultCompound() : Manager() { 21 | setStrategy( 22 | addBackend>() 23 | ); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/GBDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include 7 | 8 | namespace smtrat { 9 | class CoveringNG_GBDefault: public Manager { 10 | public: 11 | CoveringNG_GBDefault() : Manager() { 12 | setStrategy( 13 | addBackend>({ 14 | addBackend>() 15 | }) 16 | ); 17 | } 18 | }; 19 | } // namespace smtrat 20 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/PPDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | /** 10 | * The most efficient CoveringNG strategy with preprocessing. 11 | * 12 | */ 13 | class CoveringNG_PPDefault: public Manager { 14 | public: 15 | CoveringNG_PPDefault() : Manager() { 16 | setStrategy( 17 | addBackend>({ 18 | addBackend>() 19 | }) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/PPGBDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | namespace smtrat { 10 | class CoveringNG_PPGBDefault: public Manager { 11 | public: 12 | CoveringNG_PPGBDefault() : Manager() { 13 | setStrategy( 14 | addBackend>({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }) 19 | ); 20 | } 21 | }; 22 | } // namespace smtrat 23 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/PPSATDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | /** 11 | * The most efficient CoveringNG strategy with preprocessing. 12 | * 13 | */ 14 | class CoveringNG_PPSATDefault: public Manager { 15 | public: 16 | CoveringNG_PPSATDefault() : Manager() { 17 | setStrategy( 18 | addBackend>({ 19 | addBackend>({ 20 | addBackend>() 21 | }) 22 | }) 23 | ); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/CoveringNG/PPSTropDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | /** 11 | * The most efficient CoveringNG strategy with preprocessing and subtropical. Is slightly slower than PPDefault. 12 | * 13 | */ 14 | class CoveringNG_PPSTropDefault: public Manager { 15 | public: 16 | CoveringNG_PPSTropDefault() : Manager() { 17 | setStrategy( 18 | addBackend>({ 19 | addBackend>({ 20 | addBackend>() 21 | }) 22 | }) 23 | ); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MCSAT/NL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | namespace internal { 10 | 11 | struct SATSettings : smtrat::SATSettingsMCSAT { 12 | struct MCSATSettings : mcsat::Base { 13 | using ExplanationBackend = mcsat::SequentialExplanation; 14 | }; 15 | }; 16 | 17 | } 18 | 19 | class MCSAT_NL: public Manager { 20 | public: 21 | MCSAT_NL(): Manager() { 22 | setStrategy( 23 | addBackend>() 24 | ); 25 | } 26 | }; 27 | } // namespace smtrat 28 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MCSAT/OC.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | 8 | class MCSAT_OC: public Manager { 9 | public: 10 | MCSAT_OC(): Manager() { 11 | setStrategy( 12 | addBackend>() 13 | ); 14 | } 15 | }; 16 | 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MCSAT/PPDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | class MCSAT_PPDefault : public Manager { 10 | public: 11 | MCSAT_PPDefault() : Manager() { 12 | setStrategy( 13 | addBackend>({ 14 | addBackend>() 15 | }) 16 | ); 17 | } 18 | }; 19 | 20 | } // namespace smtrat 21 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MCSAT/PPOC.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | class MCSAT_PPOC: public Manager { 11 | public: 12 | MCSAT_PPOC(): Manager() { 13 | setStrategy( 14 | addBackend>( 15 | addBackend>() 16 | ) 17 | ); 18 | } 19 | }; 20 | 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/Exact.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_Exact: public Manager 11 | { 12 | public: 13 | MIS_Exact(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/Greedy.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_Greedy: public Manager 11 | { 12 | public: 13 | MIS_Greedy(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/GreedyExact.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_Trivial: public Manager 11 | { 12 | public: 13 | MIS_Trivial(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/GreedyPre.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_GreedyPre: public Manager 11 | { 12 | public: 13 | MIS_GreedyPre(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/GreedyWeighted.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_GreedyWeighted: public Manager 11 | { 12 | public: 13 | MIS_GreedyWeighted(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/Hybrid.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_Hybrid: public Manager 11 | { 12 | public: 13 | MIS_Hybrid(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/MIS/Trivial.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class MIS_Trivial: public Manager 11 | { 12 | public: 13 | MIS_Trivial(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/Brown.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_Brown: public Manager 11 | { 12 | public: 13 | NewCAD_Brown(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/Collins.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_Collins: public Manager 11 | { 12 | public: 13 | NewCAD_Collins(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FOS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCAD_FOS: public Manager 13 | { 14 | public: 15 | NewCAD_FOS(): Manager() { 16 | setStrategy( 17 | //addBackend( 18 | // addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | // ) 23 | //) 24 | ); 25 | } 26 | }; 27 | } // namespace smtrat 28 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU: public Manager 11 | { 12 | public: 13 | NewCAD_FU(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SC.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SC: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SC(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SI: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SI(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SInf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SInf: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SInf(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SL.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SL: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SL(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SR: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SR(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/FU_SZ.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_FU_SZ: public Manager 11 | { 12 | public: 13 | NewCAD_FU_SZ(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/Hong.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_Hong: public Manager 11 | { 12 | public: 13 | NewCAD_Hong(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOLS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOLS: public Manager 11 | { 12 | public: 13 | NewCAD_LOLS(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOLT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOLT: public Manager 11 | { 12 | public: 13 | NewCAD_LOLT(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOLTA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOLTA: public Manager 11 | { 12 | public: 13 | NewCAD_LOLTA(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOLTS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOLTS: public Manager 11 | { 12 | public: 13 | NewCAD_LOLTS(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOLTSA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOLTSA: public Manager 11 | { 12 | public: 13 | NewCAD_LOLTSA(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOS: public Manager 11 | { 12 | public: 13 | NewCAD_LOS(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOT: public Manager 11 | { 12 | public: 13 | NewCAD_LOT(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOTLSA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOTLSA: public Manager 11 | { 12 | public: 13 | NewCAD_LOTLSA(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOTS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOTS: public Manager 11 | { 12 | public: 13 | NewCAD_LOTS(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/LOTSA.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_LOTSA: public Manager 11 | { 12 | public: 13 | NewCAD_LOTSA(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/McCallum.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_McCallum: public Manager 11 | { 12 | public: 13 | NewCAD_McCallum(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/McCallumPartial.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_McCallumPartial: public Manager 11 | { 12 | public: 13 | NewCAD_McCallumPartial(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/NO.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_NO: public Manager 11 | { 12 | public: 13 | NewCAD_NO(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/NRA_CAD.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file NRASolver.h 3 | */ 4 | #pragma once 5 | 6 | #include 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | namespace smtrat 13 | { 14 | /** 15 | * Strategy description. 16 | * 17 | * @author 18 | * @since 19 | * @version 20 | * 21 | */ 22 | class NRA_CAD: public Manager { 23 | public: 24 | NRA_CAD(): Manager() { 25 | setStrategy({ 26 | addBackend>( 27 | addBackend>( 28 | addBackend>() 29 | ) 30 | ) 31 | }); 32 | } 33 | }; 34 | } // namespace smtrat 35 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/NU.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_NU: public Manager 11 | { 12 | public: 13 | NewCAD_NU(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/Naive.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_Naive: public Manager 11 | { 12 | public: 13 | NewCAD_Naive(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/POD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_POD: public Manager 11 | { 12 | public: 13 | NewCAD_POD(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/POLD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_POLD: public Manager 11 | { 12 | public: 13 | NewCAD_POLD(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/POPD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_POPD: public Manager 11 | { 12 | public: 13 | NewCAD_POPD(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/POSD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_POSD: public Manager 11 | { 12 | public: 13 | NewCAD_POSD(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/PP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_PP: public Manager 11 | { 12 | public: 13 | NewCAD_PP(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/PPRR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_PPRR: public Manager 11 | { 12 | public: 13 | NewCAD_PPRR(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/PPVE.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_PPVE: public Manager 11 | { 12 | public: 13 | NewCAD_PPVE(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/PPVERR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_PPVERR: public Manager 11 | { 12 | public: 13 | NewCAD_PPVERR(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/SAT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/SATModule/SATModule.h" 6 | 7 | namespace smtrat 8 | { 9 | class NewCAD_SAT: public Manager 10 | { 11 | public: 12 | NewCAD_SAT(): Manager() { 13 | setStrategy( 14 | addBackend>( 15 | ) 16 | ); 17 | } 18 | }; 19 | } // namespace smtrat 20 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/SO.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_SO: public Manager 11 | { 12 | public: 13 | NewCAD_SO(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCAD/SU.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/NewCADModule/NewCADModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class NewCAD_SU: public Manager 11 | { 12 | public: 13 | NewCAD_SU(): Manager() { 14 | setStrategy( 15 | addBackend>( 16 | addBackend>() 17 | ) 18 | ); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/B.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_B: public Manager 13 | { 14 | public: 15 | NewCADEQ_B(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BD: public Manager 13 | { 14 | public: 15 | NewCADEQ_BD(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BR.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BR: public Manager 13 | { 14 | public: 15 | NewCADEQ_BR(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BRD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BRD: public Manager 13 | { 14 | public: 15 | NewCADEQ_BRD(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BRI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BRI: public Manager 13 | { 14 | public: 15 | NewCADEQ_BRI(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BRID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BRID: public Manager 13 | { 14 | public: 15 | NewCADEQ_BRID(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BS: public Manager 13 | { 14 | public: 15 | NewCADEQ_BS(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BSD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BSD: public Manager 13 | { 14 | public: 15 | NewCADEQ_BSD(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BSI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BSI: public Manager 13 | { 14 | public: 15 | NewCADEQ_BSI(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/BSID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_BSID: public Manager 13 | { 14 | public: 15 | NewCADEQ_BSID(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/R.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_R: public Manager 13 | { 14 | public: 15 | NewCADEQ_R(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/RD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_RD: public Manager 13 | { 14 | public: 15 | NewCADEQ_RD(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/RI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_RI: public Manager 13 | { 14 | public: 15 | NewCADEQ_RI(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/RID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_RID: public Manager 13 | { 14 | public: 15 | NewCADEQ_RID(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/S.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_S: public Manager 13 | { 14 | public: 15 | NewCADEQ_S(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/SD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_SD: public Manager 13 | { 14 | public: 15 | NewCADEQ_SD(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/SI.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_SI: public Manager 13 | { 14 | public: 15 | NewCADEQ_SI(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCADEQ/SID.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/CNFerModule/CNFerModule.h" 6 | #include "../modules/FPPModule/FPPModule.h" 7 | #include "../modules/NewCADModule/NewCADModule.h" 8 | #include "../modules/SATModule/SATModule.h" 9 | 10 | namespace smtrat 11 | { 12 | class NewCADEQ_SID: public Manager 13 | { 14 | public: 15 | NewCADEQ_SID(): Manager() { 16 | setStrategy( 17 | addBackend>( 18 | addBackend>() 19 | ) 20 | ); 21 | } 22 | }; 23 | } // namespace smtrat 24 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/Backtracking.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | class NewCovering_Backtracking : public Manager { 9 | public: 10 | NewCovering_Backtracking() 11 | : Manager() { 12 | setStrategy( 13 | addBackend>( 14 | addBackend>())); 15 | } 16 | }; 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/Incomplete.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | namespace internal { 10 | struct NewCoveringSettings : NewCoveringSettings2 { 11 | using op = cadcells::operators::Mccallum; 12 | }; 13 | } // namespace internal 14 | 15 | class NewCovering_Incomplete : public Manager { 16 | public: 17 | NewCovering_Incomplete() 18 | : Manager() { 19 | setStrategy( 20 | addBackend>( 21 | addBackend>())); 22 | } 23 | }; 24 | } // namespace smtrat 25 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/Incremental.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | class NewCovering_Incremental : public Manager { 9 | public: 10 | NewCovering_Incremental() 11 | : Manager() { 12 | setStrategy( 13 | addBackend>( 14 | addBackend>())); 15 | } 16 | }; 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/IncrementalBacktracking.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | class NewCovering_IncrementalBacktracking : public Manager { 9 | public: 10 | NewCovering_IncrementalBacktracking() 11 | : Manager() { 12 | setStrategy( 13 | addBackend>( 14 | addBackend>())); 15 | } 16 | }; 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/PPComplete.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | namespace internal { 11 | struct NewCoveringSettings : NewCoveringSettings2 { 12 | using op = cadcells::operators::Mccallum; 13 | }; 14 | } // namespace internal 15 | 16 | class NewCovering_PPComplete : public Manager { 17 | public: 18 | NewCovering_PPComplete() 19 | : Manager() { 20 | setStrategy( 21 | addBackend>( 22 | addBackend>( 23 | addBackend>()))); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/PPIncomplete.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace smtrat { 9 | 10 | namespace internal { 11 | struct NewCoveringSettings : NewCoveringSettings2 { 12 | using op = cadcells::operators::Mccallum; 13 | }; 14 | } // namespace internal 15 | 16 | class NewCovering_PPIncomplete : public Manager { 17 | public: 18 | NewCovering_PPIncomplete() 19 | : Manager() { 20 | setStrategy( 21 | addBackend>( 22 | addBackend>( 23 | addBackend>()))); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NewCovering/Vanilla.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | class NewCovering_Vanilla : public Manager { 9 | public: 10 | NewCovering_Vanilla() 11 | : Manager() { 12 | setStrategy( 13 | addBackend>( 14 | addBackend>())); 15 | } 16 | }; 17 | } // namespace smtrat 18 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NuCAD/Default.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace smtrat { 7 | 8 | class NuCAD_Default: public Manager { 9 | public: 10 | NuCAD_Default() : Manager() { 11 | setStrategy( 12 | addBackend>() 13 | ); 14 | } 15 | }; 16 | } // namespace smtrat 17 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/NuCAD/PPDefault.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace smtrat { 8 | 9 | class NuCAD_PPDefault: public Manager { 10 | public: 11 | NuCAD_PPDefault() : Manager() { 12 | setStrategy( 13 | addBackend>({ 14 | addBackend>() 15 | }) 16 | ); 17 | } 18 | }; 19 | } // namespace smtrat 20 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/OnlyCAD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class OnlyCAD: public Manager 11 | { 12 | public: 13 | OnlyCAD(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/OnlyGB.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/GBModule/GBModule.h" 6 | #include "../modules/SATModule/SATModule.h" 7 | 8 | namespace smtrat 9 | { 10 | class OnlyGB: public Manager 11 | { 12 | public: 13 | OnlyGB(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/OnlySAT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace smtrat 8 | { 9 | /** 10 | * A pure SAT solver. 11 | */ 12 | class OnlySAT: 13 | public Manager 14 | { 15 | public: 16 | OnlySAT(): Manager() { 17 | setStrategy({ 18 | addBackend>() 19 | }); 20 | } 21 | 22 | }; 23 | 24 | } // namespace smtrat 25 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/OnlyVS.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file JustVS.h 3 | */ 4 | #pragma once 5 | 6 | #include "../solver/Manager.h" 7 | #include "../modules/VSModule/VSModule.h" 8 | 9 | namespace smtrat 10 | { 11 | /** 12 | * Strategy description. 13 | * 14 | * @author 15 | * @since 16 | * @version 17 | * 18 | */ 19 | class OnlyVS: 20 | public Manager 21 | { 22 | public: 23 | 24 | OnlyVS(): Manager() 25 | { 26 | setStrategy( 27 | { 28 | addBackend>() 29 | }); 30 | } 31 | }; 32 | } // namespace smtrat -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/Optimization/MAXSMTPBPPStrategy.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategy: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategy(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/Preprocessing/BVPreprocessing.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file BVPreprocessing.h 3 | */ 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | namespace smtrat 12 | { 13 | /** 14 | * Strategy description. 15 | * 16 | * @author 17 | * @since 18 | * @version 19 | * 20 | */ 21 | class BVPreprocessing: 22 | public Manager 23 | { 24 | public: 25 | BVPreprocessing(): Manager() { 26 | setStrategy({ 27 | //addBackend>( 28 | addBackend>() 29 | //) 30 | }); 31 | } 32 | 33 | }; 34 | 35 | } // namespace smtrat 36 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategy.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategy: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategy(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategy2.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/LRAModule/LRAModule.h" 6 | #include "../modules/PBPPModule/PBPPModule.h" 7 | #include "../modules/SATModule/SATModule.h" 8 | #include "../modules/ICPModule/ICPModule.h" 9 | 10 | 11 | namespace smtrat 12 | { 13 | class PBPPStrategy2: 14 | public Manager 15 | { 16 | public: 17 | PBPPStrategy2(): Manager() { 18 | setStrategy({ 19 | addBackend>( 20 | addBackend>( 21 | addBackend>( 22 | addBackend>() 23 | ) 24 | ) 25 | ), 26 | }); 27 | } 28 | }; 29 | } // namespace smtrat 30 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategyBasic.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/LRAModule/LRAModule.h" 6 | #include "../modules/PBPPModule/PBPPModule.h" 7 | #include "../modules/SATModule/SATModule.h" 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategyBasic: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategyBasic(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategyRNS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/LRAModule/LRAModule.h" 6 | #include "../modules/PBPPModule/PBPPModule.h" 7 | #include "../modules/SATModule/SATModule.h" 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategyRNS: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategyRNS(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategyWithCardConstr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/LRAModule/LRAModule.h" 6 | #include "../modules/PBPPModule/PBPPModule.h" 7 | #include "../modules/SATModule/SATModule.h" 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategyWithCardConstr: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategyWithCardConstr(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/PseudoBool/PBPPStrategyWithMixedConstr.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../solver/Manager.h" 4 | 5 | #include "../modules/LRAModule/LRAModule.h" 6 | #include "../modules/PBPPModule/PBPPModule.h" 7 | #include "../modules/SATModule/SATModule.h" 8 | 9 | 10 | namespace smtrat 11 | { 12 | class PBPPStrategyWithMixedConstr: 13 | public Manager 14 | { 15 | public: 16 | PBPPStrategyWithMixedConstr(): Manager() { 17 | setStrategy({ 18 | addBackend>( 19 | addBackend>( 20 | addBackend>() 21 | ) 22 | ), 23 | }); 24 | } 25 | }; 26 | } // namespace smtrat 27 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/Formula.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_Formula: public Manager 11 | { 12 | public: 13 | STrop_Formula(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/FormulaAlt.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_FormulaAlt: public Manager 11 | { 12 | public: 13 | STrop_FormulaAlt(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/FormulaAltOutputOnly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | // #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_FormulaAltOutputOnly: public Manager 11 | { 12 | public: 13 | STrop_FormulaAltOutputOnly(): Manager() { 14 | setStrategy({ 15 | // addBackend>({ 16 | addBackend>() 17 | // }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/FormulaOutputOnly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | // #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_FormulaOutputOnly: public Manager 11 | { 12 | public: 13 | STrop_FormulaOutputOnly(): Manager() { 14 | setStrategy({ 15 | // addBackend>({ 16 | addBackend>() 17 | // }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/FormulaWMCSAT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | namespace smtrat 10 | { 11 | class STrop_FormulaWMCSAT: public Manager 12 | { 13 | public: 14 | STrop_FormulaWMCSAT(): Manager() { 15 | setStrategy({ 16 | addBackend>({ 17 | addBackend>({ 18 | addBackend>() 19 | }) 20 | }) 21 | }); 22 | } 23 | }; 24 | } // namespace smtrat 25 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/Incremental.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | namespace smtrat 10 | { 11 | class STrop_Incremental: public Manager 12 | { 13 | public: 14 | STrop_Incremental(): Manager() { 15 | setStrategy({ 16 | addBackend>({ 17 | addBackend>({ 18 | addBackend>() 19 | }) 20 | }) 21 | }); 22 | } 23 | }; 24 | } // namespace smtrat 25 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/MCSATOnly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_MCSATOnly: public Manager 11 | { 12 | public: 13 | STrop_MCSATOnly(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/TransformationEQ.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_TransformationEQ: public Manager 11 | { 12 | public: 13 | STrop_TransformationEQ(): Manager() { 14 | setStrategy({ 15 | addBackend>({ 16 | addBackend>() 17 | }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-strategies/strategies/STrop/TransformationEQOutputOnly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | // #include 6 | #include 7 | 8 | namespace smtrat 9 | { 10 | class STrop_TransformationEQOutputOnly: public Manager 11 | { 12 | public: 13 | STrop_TransformationEQOutputOnly(): Manager() { 14 | setStrategy({ 15 | // addBackend>({ 16 | addBackend>() 17 | // }) 18 | }); 19 | } 20 | }; 21 | } // namespace smtrat 22 | -------------------------------------------------------------------------------- /src/smtrat-unsat-cores/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-unsat-cores_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-unsat-cores ${PROJECT_VERSION_LIB} "${smtrat-unsat-cores_sources}" "resources") 10 | target_include_dirs_from(smtrat-unsat-cores-objects "" PUBLIC smtrat-common-shared carl-arith-shared carl-covering-shared) 11 | target_link_libraries(smtrat-unsat-cores-shared smtrat-common-shared carl-arith-shared carl-covering-shared) 12 | target_link_libraries(smtrat-unsat-cores-static smtrat-common-static carl-arith-static carl-covering-static) 13 | 14 | install_libraries(smtrat smtrat-unsat-cores-shared smtrat-unsat-cores-static) 15 | 16 | -------------------------------------------------------------------------------- /src/smtrat-unsat-cores/smtrat-unsat-cores.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-unsat-cores.h" -------------------------------------------------------------------------------- /src/smtrat-unsat-cores/smtrat-unsat-cores.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "UnsatCore.h" 4 | #include "UnsatCore_ModelExclusion.h" -------------------------------------------------------------------------------- /src/smtrat-variablebounds/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(${carl_INCLUDE_DIR}/../cmake/carlmacros.cmake) 2 | 3 | add_definitions(-fPIC) 4 | 5 | configure_everything() 6 | 7 | file(GLOB_RECURSE smtrat-variablebounds_sources "*.cpp") 8 | 9 | add_new_libraries(smtrat-variablebounds ${PROJECT_VERSION_LIB} "${smtrat-variablebounds_sources}" "resources") 10 | target_include_dirs_from(smtrat-variablebounds-objects "" PUBLIC smtrat-common-shared carl-arith-shared carl-covering-shared) 11 | target_link_libraries(smtrat-variablebounds-shared smtrat-common-shared carl-arith-shared carl-covering-shared) 12 | target_link_libraries(smtrat-variablebounds-static smtrat-common-static carl-arith-static carl-covering-static) 13 | 14 | install_libraries(smtrat smtrat-variablebounds-shared smtrat-variablebounds-static) 15 | 16 | -------------------------------------------------------------------------------- /src/smtrat-variablebounds/smtrat-variablebounds.cpp: -------------------------------------------------------------------------------- 1 | #include "smtrat-variablebounds.h" -------------------------------------------------------------------------------- /src/smtrat-variablebounds/smtrat-variablebounds.h: -------------------------------------------------------------------------------- 1 | #pragma once -------------------------------------------------------------------------------- /src/tests/Common.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ths-rwth/smtrat/7293cb5544cc59027abaa4a548f1a295050bfa46/src/tests/Common.cpp -------------------------------------------------------------------------------- /src/tests/fourierMotzkinQE/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( runFourierMotzkinQETests 2 | Test_fmqe.cpp 3 | ) 4 | target_link_libraries(runFourierMotzkinQETests 5 | Boost_unit_test_framework_SHARED 6 | smtrat-qe-shared 7 | ) 8 | 9 | add_test( NAME FourierMotzkinQE COMMAND runFourierMotzkinQETests ) 10 | -------------------------------------------------------------------------------- /src/tests/mcsat/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | add_executable(runMCSATTests ${test_sources}) 3 | 4 | target_link_libraries(runMCSATTests 5 | Boost_unit_test_framework_SHARED 6 | smtrat-mcsat-shared 7 | ) 8 | add_test(NAME mcsat COMMAND runMCSATTests) 9 | -------------------------------------------------------------------------------- /src/tests/mcsat/Test_MCSAT.cpp: -------------------------------------------------------------------------------- 1 | #define BOOST_TEST_MODULE test_mcsat 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | struct MCSATFixture { 8 | MCSATFixture() { 9 | // std::cout << "Fixture" << std::endl; 10 | if (!carl::logging::logger().has("stdout")) { 11 | carl::logging::logger().configure("stdout", std::cout); 12 | } 13 | carl::logging::logger().formatter("stdout")->printInformation = true; 14 | carl::logging::logger().filter("stdout") 15 | ("smtrat.mcsat", carl::logging::LogLevel::LVL_DEBUG) 16 | ("smtrat.test.mcsat", carl::logging::LogLevel::LVL_DEBUG) 17 | ; 18 | } 19 | }; 20 | 21 | BOOST_GLOBAL_FIXTURE( MCSATFixture ); 22 | -------------------------------------------------------------------------------- /src/tests/mcsatvs/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | add_executable(runMcsatVSTests ${test_sources}) 3 | 4 | #set(UNITTEST_LIB "${carl_DIR}/resources/lib/libboost_unit_test_framework.a") 5 | #MESSAGE( STATUS "UNITTEST_LIB: " ${UNITTEST_LIB} ) 6 | #target_link_libraries(runMcsatVSTests ${UNITTEST_LIB} lib_${PROJECT_NAME} ${libraries}) 7 | 8 | target_link_libraries(runMcsatVSTests 9 | Boost_unit_test_framework_SHARED 10 | smtrat-mcsat-shared 11 | ) 12 | add_test(NAME mcsatvs COMMAND runMcsatVSTests) 13 | 14 | 15 | 16 | #add_executable(runMcsatVSBug 17 | # Test_McsatVSBug.cpp 18 | #) 19 | #target_link_libraries(runMcsatVSBug 20 | # Boost_unit_test_framework_SHARED 21 | # smtrat-mcsat-shared 22 | # ${libraries} 23 | #) 24 | #add_test(NAME mcsatvsbug COMMAND runMcsatVSBug) 25 | -------------------------------------------------------------------------------- /src/tests/mcsatvs/Test_MCSATVS.cpp: -------------------------------------------------------------------------------- 1 | #define BOOST_TEST_MODULE test_mcsatvs 2 | //#include 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | struct MCSATVSFixture { 9 | MCSATVSFixture() { 10 | // std::cout << "Fixture" << std::endl; 11 | if (!carl::logging::logger().has("stdout")) { 12 | carl::logging::logger().configure("stdout", std::cout); 13 | } 14 | carl::logging::logger().formatter("stdout")->printInformation = true; 15 | carl::logging::logger().filter("stdout") 16 | ("smtrat.mcsat.vs", carl::logging::LogLevel::LVL_DEBUG) 17 | ("smtrat.test.mcsatvs", carl::logging::LogLevel::LVL_DEBUG) 18 | ; 19 | } 20 | }; 21 | 22 | BOOST_GLOBAL_FIXTURE( MCSATVSFixture ); 23 | -------------------------------------------------------------------------------- /src/tests/nlsat/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | add_executable(runNLSATTests ${test_sources}) 3 | 4 | target_link_libraries(runNLSATTests 5 | Boost_unit_test_framework_SHARED 6 | smtrat-mcsat-shared 7 | ) 8 | add_test(NAME nlsat COMMAND runNLSATTests) 9 | -------------------------------------------------------------------------------- /src/tests/nlsat/Test_NLSAT.cpp: -------------------------------------------------------------------------------- 1 | #define BOOST_TEST_MODULE test_nlsat 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | struct NLSATFixture { 8 | NLSATFixture() { 9 | std::cout << "Fixture" << std::endl; 10 | if (!carl::logging::logger().has("stdout")) { 11 | carl::logging::logger().configure("stdout", std::cout); 12 | } 13 | carl::logging::logger().formatter("stdout")->printInformation = true; 14 | carl::logging::logger().filter("stdout") 15 | ("smtrat.mcsat", carl::logging::LogLevel::LVL_DEBUG) 16 | ("smtrat.test.nlsat", carl::logging::LogLevel::LVL_DEBUG) 17 | ; 18 | } 19 | }; 20 | 21 | BOOST_GLOBAL_FIXTURE( NLSATFixture ); 22 | -------------------------------------------------------------------------------- /src/tests/onecellcad/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # TODO test not compiling, enable when fixed 2 | add_executable(runOpenCellCadTests 3 | Test_OpenCad.cpp 4 | ) 5 | target_link_libraries(runOpenCellCadTests 6 | Boost_unit_test_framework_SHARED 7 | smtrat-mcsat-shared 8 | ) 9 | 10 | # TODO test not compiling, enable when fixed 11 | add_executable(runOneCellCadTests 12 | Test_OneCellCAD.cpp 13 | ) 14 | target_link_libraries(runOneCellCadTests 15 | Boost_unit_test_framework_SHARED 16 | smtrat-mcsat-shared 17 | ) 18 | 19 | 20 | add_executable(runOneCellCadBugTests 21 | Test_OneCellCADBug.cpp 22 | ) 23 | target_link_libraries(runOneCellCadBugTests 24 | Boost_unit_test_framework_SHARED 25 | smtrat-mcsat-shared 26 | ${libraries} 27 | ) 28 | add_test(NAME onecellcadbug COMMAND runOneCellCadBugTests) 29 | -------------------------------------------------------------------------------- /src/tests/pseudobool/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | 3 | add_executable(runPseudoBoolTests ${test_sources}) 4 | 5 | target_link_libraries(runPseudoBoolTests 6 | Boost_unit_test_framework_SHARED 7 | smtrat-module-PBPPModule-shared 8 | ) 9 | 10 | add_test(NAME pseudobool COMMAND runPseudoBoolTests) 11 | 12 | -------------------------------------------------------------------------------- /src/tests/pseudobool/Test_Encoder.cpp: -------------------------------------------------------------------------------- 1 | #define BOOST_TEST_DYN_LINK 2 | #define BOOST_TEST_MODULE test_PseudoBool 3 | #include 4 | 5 | #include 6 | #include 7 | 8 | struct PseudoBoolFixture { 9 | PseudoBoolFixture() { 10 | std::cout << "Fixture" << std::endl; 11 | if (!carl::logging::logger().has("stdout")) { 12 | carl::logging::logger().configure("stdout", std::cout); 13 | } 14 | carl::logging::logger().formatter("stdout")->printInformation = false; 15 | carl::logging::logger().filter("stdout") 16 | ("smtrat.pbc", carl::logging::LogLevel::LVL_DEBUG) 17 | ; 18 | } 19 | }; 20 | 21 | BOOST_GLOBAL_FIXTURE( PseudoBoolFixture ); 22 | -------------------------------------------------------------------------------- /src/tests/smtrat-cadcells/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | 3 | add_executable(runCadcellsTest ${test_sources}) 4 | 5 | target_link_libraries(runCadcellsTest smtrat-cadcells-shared ${GTEST_LIBRARIES}) 6 | 7 | add_test(NAME cadcells COMMAND runCadcellsTest) 8 | add_dependencies(all-tests runCadcellsTest) 9 | -------------------------------------------------------------------------------- /src/tests/smtrat-cadcells/datastructures_polynomials.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | TEST(smtrat_cadcells, datastructures_polynomials) 6 | { 7 | smtrat::cadcells::VariableOrdering vrs; 8 | smtrat::cadcells::Polynomial::ContextType ctx(vrs); 9 | smtrat::cadcells::Polynomial poly(ctx, 1); 10 | smtrat::cadcells::datastructures::PolyPool pool(ctx); 11 | ASSERT_EQ(pool(pool(poly)), poly); 12 | } 13 | -------------------------------------------------------------------------------- /src/tests/smtrat-mcsat/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB_RECURSE test_sources "*.cpp") 2 | 3 | add_executable(runMcsatTest ${test_sources}) 4 | 5 | target_link_libraries(runMcsatTest smtrat-mcsat-shared ${GTEST_LIBRARIES}) 6 | 7 | add_test(NAME mcsat COMMAND runMcsatTest) 8 | add_dependencies(all-tests runMcsatTest) 9 | --------------------------------------------------------------------------------