We are working on a new version of AClib (2.0). Please visit our bitbucket repo for more information.
AClib: Algorithm Configuration Library
AClib is a benchmark library for instances of the algorithm configuration problem: given a parameterized algorithm A (the so-called target algorithm), a set of problem instances S (the so-called target instances), and a performance metric m, find a parameter setting of A that minimizes metric m across S. An example objective might be to minimize an algorithm's mean runtime.
The goal of AClib is to define a set of standard benchmarks for algorithm configuration in order to provide a solid foundation for empirical science in the field, much like SATlib, TSPlib, and MIPlib have done in their respective fields.
AClib is hosted by Freiburg University and the University of British Columbia.
License
The code base of AClib is distributed under the GNU Public License. See COPYING for details regarding the license. The licenses of the instance sets, target algorithms and configurators can be found in the corresponding READMEs
Requirements
- Python 2.7 (for the install and run script)
- Ruby 1.9 (for wrapper scripts of target algorithms)
- the configurators and target algorithms have further requirements, please have a look in their READMEs.
Releases
Base distribution package
aclib.tar.gzPackage contents
- COPYING - GNU Public License
- README.md - Explanatory information
- src/install_scenario.py - Script to download and install new scenarios
- src/run_scenario.py - Script to run a scenario
- src/create_website.py - Script to generate this site
- src/data/config.json - JSON file with information about downloadable scenarios
- scenarios/ - contains the configuration scenario files, which in turn reference target algorithms, instances, etc.
- target_algorithms/ - contains the target algorithm executables and parameter files
- instances/ - contains the actual target instances
- configurators/ - contains ParamILS, SMAC, and I/F-Race as example configurators
Usage
AClib provides an install and a run script to easily add and run new scenarios. (We only provide support for Linux based systems.)
Example
Here is a quick and easy example to test out the AClib system. From a clean directory, execute the following commands to download AClib and run the SMAC configurator on a scenario from the recent Configurable SAT Solver Competition (CSSC).
wget http://www.aclib.net/data/aclib.tar.gz
tar xzvf aclib.tar.gz
mkdir my_work_dir
cd my_work_dir
python ../aclib/src/install_scenario.py --scenario CSSC_regressiontests_riss3gExt
python ../aclib/src/run_scenario.py --scenario CSSC_regressiontests_riss3gExt --configurator SMAC
Install Script
The install script provides an easy way to download new scenarios from aclib.net. To list all available scenarios, use:
python <path to AClib root>/src/install_scenario.py --show_scenarios
To download and install a scenario, use:
python <path to AClib root>/src/install_scenario.py --scenario <SCENARIO KEY>
For further options, call:
python <path to AClib root>/src/install_scenario.py -h
Please read all messages of the install script carefully. In some cases we are not allowed to provide all files of a scenario because of license issues. In those cases the install script will attempt to point you to third party websites.
Since there are too many ways to install all kinds of target algorithms, please check whether the provided binaries are working on your machine. (In a future release, we will provide an automatic test).
Run Script
The run scripts provides an easy way to run a downloaded configuration scenario.
To run a scenario, use:
python <path to AClib root>/src/run_scenario.py --scenario <SCENARIO KEY> --configurator <configurator name>
By default, the working directory (including generation of output files) is your current directory. If you want to specify another directory, use:
python <path to AClib root>/src/run_scenario.py --scenario <SCENARIO KEY> --configurator <configurator name> --working_directory <dir>
For further options, call:
python <path to AClib root>/src/run_scenario.py -h
We do not recommend that you use the AClib root as your working directory. Please choose a directory external to AClib.
Scenarios
asp
- Target algorithm: clasp-2.1.4
- Instance set: ricochet
- Supported configurators: SMAC, ParamILS
- Target algorithm: clasp-2.1.4
- Instance set: riposte
- Supported configurators: SMAC, ParamILS
- Target algorithm: clasp-2.1.4
- Instance set: weighted-sequence
- Supported configurators: SMAC, ParamILS
btsp
- Target algorithm: moaco_btsp
- Instance set: btsp-rue-100-1000
- Supported configurators: irace
- Target algorithm: moaco_btsp
- Instance set: btsp-rue-100-1000
- Supported configurators: SMAC
mip
Reference for scenario: @InProceedings{HutHooLey10-mipconfig, author = {F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Automated Configuration of Mixed Integer Programming Solvers}, booktitle = {Proc.~of CPAIOR-10} year = 2010, pages = {186--202} }
Reference for scenario: @InProceedings{HutHooLey10-mipconfig, author = {F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Automated Configuration of Mixed Integer Programming Solvers}, booktitle = {Proc.~of CPAIOR-10} year = 2010, pages = {186--202} }
Reference for scenario: @InProceedings{HutHooLey10-mipconfig, author = {F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Automated Configuration of Mixed Integer Programming Solvers}, booktitle = {Proc.~of CPAIOR-10} year = 2010, pages = {186--202} }
- Target algorithm: cplex12.6
- Instance set: Regions200
- Supported configurators: SMAC, ParamILS
Reference for scenario: @InProceedings{HutHooLey10-mipconfig, author = {F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Automated Configuration of Mixed Integer Programming Solvers}, booktitle = {Proc.~of CPAIOR-10} year = 2010, pages = {186--202} }
ml
- Target algorithm: autoweka-0.5b3
- Instance set: abalone
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: amazon
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: car
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: cifar10
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: cifar10small
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: convex
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: dexter
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: dorothea
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: germancredit
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: gisette
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: kddcup09appetency
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: krvskp
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: madelon
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: mnist
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: mnistrotationbackimagenew
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: secom
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: semeion
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: shuttle
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: waveform
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: winequalitywhite
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
- Target algorithm: autoweka-0.5b3
- Instance set: yeast
- Supported configurators: SMAC
This scenario originates in the Auto-WEKA paper: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
planning
- Target algorithm: fast-downward
- Instance set: ipc2011-barman-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Barman domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-blocksworld-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Blocksworld domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-depots-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Depots domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-gripper-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Gripper domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-merged-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on a merged set of all 9 domains from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-parking-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Parking domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-rover-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Rover domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-satellite-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Satellite domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-spanner-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the Spanner domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: fast-downward
- Instance set: ipc2011-tpp-fd
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the Fast Downward planner to find an initial satisficing solution on the TPP domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-barman-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Barman domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-blocksworld-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Blocksworld domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-depots-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Depots domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-gripper-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Gripper domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-merged-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on a merged set of all 9 domains from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-parking-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Parking domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-rover-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Rover domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-satellite-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Satellite domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-spanner-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the Spanner domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
- Target algorithm: lpg
- Instance set: ipc2011-tpp-lpg
- Supported configurators: ParamILS, SMAC
Scenario optimizing the runtime for the LPG planner to find an initial satisficing solution on the TPP domain from IPC 2011.
Configurators are given a runtime cutoff of 5 CPU days, with a 900 CPU second runtime cutoff for each target algorithm run.
sat
- Target algorithm: gnovelty+GCa
- Instance set: 5sat500
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+GCwa
- Instance set: 5sat500
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+PCL
- Instance set: 5sat500
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: BMC08_without_intel
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: BMC08_without_intel
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: BMC08_without_intel
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3g
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3gExt
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: sat4j
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: simpsat
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: Solver43
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: BMC08_without_intel
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: BMC08_without_intel
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: circuit_fuzz
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: circuit_fuzz
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: circuit_fuzz
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3g
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3gExt
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: sat4j
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: simpsat
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: Solver43
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: circuit_fuzz
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: circuit_fuzz
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: GI-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: LABS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: QUEENS-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: BMC08-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: CIRCUITFUZZ-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: cryptominisat-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: lingeling-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: IBM-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 3CNF-V350-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: K3-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: DCCASat+march_rw-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: riss427-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: UNSAT-UNIF-K5-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 3SAT1K-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 5SAT500-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: CSCCSat2014-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: minisat_HACK_999ED_CSSC-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: probSAT-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: SparrowToRiss-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: yalsat-cssc14
- Instance set: 7SAT90-SAT-CSSC14
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2014: http://aclib.net/cssc2014/
- Target algorithm: clasp-cssc
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+GCa
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+GCwa
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+PCL
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3g
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3gExt
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: sat4j
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: simpsat
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: Solver43
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: CSSC_regressiontests
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: GI
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: GI
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: GI
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: K3
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: K3
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: K3
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: LABS
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: LABS
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: LABS
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: SWV-Calysto
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: SWV-Calysto
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: SWV-Calysto
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3g
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3gExt
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: sat4j
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: simpsat
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: Solver43
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: SWV-Calysto
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: SWV-Calysto
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: UF250
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: UF250
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: UF250
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+GCa
- Instance set: UF250
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+GCwa
- Instance set: UF250
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: gnovelty+PCL
- Instance set: UF250
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: unsat-unif-k5
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: clasp-cssc
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: forl-nodrup
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: unsat-unif-k5
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: lingeling
- Instance set: unsat-unif-k5
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3g
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: riss3gExt
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: sat4j
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: simpsat
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: Solver43
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: unsat-unif-k5
- Supported configurators: SMAC, ParamILS
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
- Target algorithm: spear
- Instance set: unsat-unif-k5
- Supported configurators: SMAC
This scenarios originates from the Configurable SAT Solver Competition (CSSC) 2013: http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/
timetabling
Trains the ctt timetabling solver on the instances of the ITC-2007 international timetabling competition, in which this solver placed third in the post-enrolment track.
We optimize for timetable quality, with 4 CPU days for configuration and a 300 second target algorithm runtime cutoff.
Trains the ctt timetabling solver on the instances of the ITC-2007 international timetabling competition, in which this solver placed third in the post-enrolment track.
We optimize for runtime to find a feasible solution (PAR-10), with 2 CPU days for configuration and a 300 second target algorithm runtime cutoff.
tsp
- Target algorithm: acotsp
- Instance set: tsp-rue-1000-3000
- Supported configurators: irace
- Target algorithm: acotsp
- Instance set: tsp-rue-1000-3000
- Supported configurators: SMAC
- Target algorithm: acotsp-var
- Instance set: tsp-rue-3000
- Supported configurators: irace
- Target algorithm: acotsp-var
- Instance set: tsp-rue-3000
- Supported configurators: SMAC
Target algorithms
btsp
----------------------------------------------------------------- Multi-Objective Ant Colony Optimization Framework Manuel López-Ibáñez and Thomas Stützle ----------------------------------------------------------------- This scenario requires the programs 'moaco_btsp' (from MOACO in directory moaco_btsp/), 'nondominated' (from mo-tools/, used for normalization), and hv (from hv/, for computing the hypervolume). All of them are implemented in C and need to be compiled. In GNU/Linux and other operating systems which support Makefiles, the required programs can be compiled by simply typing 'make' to produce the executables. Contents * Introduction * Usage * License * Download * Changelog ------------ Introduction ------------ Multi-objective optimization problems are problems with several, typically conflicting criteria for evaluating solutions. Without any a priori preference information, the Pareto optimality principle establishes a partial order among solutions, and the output of the algorithm becomes a set of nondominated solutions rather than a single one. Various ant colony optimization (ACO) algorithms have been proposed in recent years for solving such problems. These multi-objective ACO (MOACO) algorithms exhibit different design choices for dealing with the particularities of the multi-objective context. This program implements the multi-objective ant colony optimization (MOACO) framework. This framework is able to instantiate most MOACO algorithms from the literature, and also combine components that were never studied in the literature. Relevant literature: [1] Manuel López-Ibáñez and Thomas Stützle. The Automatic Design of Multi-Objective Ant Colony Optimization Algorithms. IEEE Transactions on Evolutionary Computation, 16(6):861–875, 2012. doi: 10.1109/TEVC.2011.2182651 [2] Manuel López-Ibáñez and T. Stützle. Automatic configuration of multi-objective ACO algorithms. In M. Dorigo et al., editors, Ant Colony Optimization and Swarm Intelligence, 7th International Conference, ANTS 2010, volume 6234 of Lecture Notes in Computer Science, pages 95–106. Springer, Heidelberg, Germany, 2010. [3] Manuel López-Ibáñez and T. Stützle. The impact of design choices of multi-objective ant colony optimization algorithms on performance: An experimental study on the biobjective TSP. In M. Pelikan and J. Branke, editors, Proceedings of the Genetic and Evolutionary Computation Conference, GECCO 2010, pages 71–78. ACM press, New York, NY, 2010. [4] Manuel López-Ibáñez and Thomas Stützle. An Analysis of Algorithmic Components for Multiobjective Ant Colony Optimization: A Case Study on the Biobjective TSP. In P. Collet et al., editors, Artificial Evolution, volume 5975 of Lecture Notes in Computer Science, pages 134-145. Springer, Heidelberg, Germany, 2010. ------------ Building ------------ The programming language is C, and the software has been tested on GNU/Linux using GCC >= 4.1. The unpacked sources contain the following directories: btsp, libmisc, libpareto, and moaco. Change the current directory to moaco/trunk and invoke make: $ tar xvf moaco-0.1.tar.gz $ cd moaco/trunk $ make For extending the code to a new problem, create a new directory beside btsp, e.g., myproblem, and then implement all functions called by the moaco and prefixed by Sol. The code can be compiled for the new problem as: $ cd moaco/trunk $ make clean $ make PROBLEM=myproblem ------------ Usage ------------ An example of invocation is: $ cd moaco/trunk $ ~/bin/moaco_btsp --input ../../btsp/kroAB100.tsp --time 100 --BicriterionAnt Other options available are given by the output of the parameter --help. The instance type handled by the btsp follows the format produced by the DIMACS benchmark generator [*]. Bi-objective TSP instances can be constructed by simply concatenating two single-objective instances such as: $ cat euclidA100.tsp euclidB100.tsp > euclidAB100.tsp [*] http://www2.research.att.com/~dsj/chtsp/download.html ------------ License ------------ This software is Copyright (C) 2010 - 2012 Manuel Lopez-Ibanez and Thomas Stuetzle. This program is free software (software libre); you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The file LICENSE contains a copy of the GNU General Public License; if not, you can obtain a copy of the GNU General Public License at http://www.gnu.org/copyleft/gpl.html This software includes code from various sources: * The GNU Scientific Library (GSL) is Copyright (C) The GSL Team, under the terms of the GPL. * moaco_spea2.c uses code from the PISA project Copyright (C) Swiss Federal Institute of Technology, Computer Engineering and Networks Laboratory, under the terms of the PISA license (PISA_LICENSE.txt). IMPORTANT NOTE: Please be aware that the fact that this program is released as Free Software does not excuse you from scientific propriety, which obligates you to give appropriate credit! If you write a scientific paper describing research that made substantive use of this program, it is your obligation as a scientist to (a) mention the fashion in which this software was used in the Methods section; (b) mention the algorithm in the References section. The appropriate citation is: Manuel López-Ibáñez and Thomas Stützle. The Automatic Design of Multi-Objective Ant Colony Optimization Algorithms. IEEE Transactions on Evolutionary Computation, 16(6):861–875, 2012. doi: 10.1109/TEVC.2011.2182651 Moreover, as a personal note, I would appreciate it if you would email manuel.lopez-ibanez@ulb.ac.be with citations of papers referencing this work so I can mention them to my funding agent and tenure committee. ------------ Download ------------ The latest version can be downloaded from: http://iridia.ulb.ac.be/~manuel/moaco ------------ Changelog ------------ Version 0.1 * This version corresponds to the framework described in: Manuel López-Ibáñez and Thomas Stützle. The Automatic Design of Multi-Objective Ant Colony Optimization Algorithms. IEEE Transactions on Evolutionary Computation, 16(6):861–875, 2012. doi: 10.1109/TEVC.2011.2182651 * moaco: Multi-objective ant colony optimization framework, implementing: + MOAQ + Pareto ACO (PACO) + BicriterionAnt + Multi-Objective Network ACO (MONACO) + m-ACO variant 1 (mACO1) + m-ACO variant 2 (mACO2) + m-ACO variant 3 (mACO3) + m-ACO variant 4 (mACO4) + MACS + COMPETants * btsp: Bi-objective travelling salesman problem. * libpareto: A small library to handle Pareto (nondominated) sets. * libmisc: A library with miscellaneous utilities.
mip
ml
Reference: @InProceedings{ThoHutHooLey13-AutoWEKA, author = {C. Thornton and F. Hutter and H.~H. Hoos and K. Leyton-Brown}, title = {Auto-{WEKA}: Combined Selection and Hyperparameter Optimization of Classification Algorithms}, booktitle = {Proc.~of KDD-2013}, year = 2013, pages = {847-855} }
multi_problem
clasp-2.x
A conflict-driven nogood learning answer set solver
http://www.cs.uni-potsdam.de/clasp/
http://potassco.sourceforge.net/
OVERVIEW clasp is an answer set solver for (extended) normal logic programs. It combines the high-level modeling capacities of answer set programming with state-of-the-art techniques from the area of Boolean constraint solving. The primary clasp algorithm relies on conflict-driven nogood learning, a technique that proved very successful for satisfiability checking (SAT). Starting with version 2.0, clasp supports parallel (multithreaded) solving.
clasp is written in (mostly) Standard-C++. It was successfully built and run under Linux (x86-32, x86-64) using gcc and Windows (x86-32, x86-64) using either Microsoft Visual Studio or MinGW.
Detailed information (including a User's manual), source code, and pre-compiled binaries are available at: http://potassco.sourceforge.net/
LICENSE clasp is part of the Potassco project hosted at SourceForge. It is distributed under the GNU Public Licens. See COPYING for details regarding the license.
PACKAGE CONTENTS COPYING - GNU Public License CHANGES - Major changes between versions README - This file configure.{sh,bat} - Simple script that creates Makefiles for building clasp (library and application) app/ - Source code directory of the command-line interface libclasp/ - Directory of the clasp (static) library (sources, documentation, unit tests) libprogram_opts/ - Library for parsing command-line options (needed by app) build_vc/ - Directory containing Visual Studio project files for building clasp tools/ - Some additional files
BUILDING & INSTALLING The preferred way to build clasp is to use make and the provided configure script. You'll need to have the GNU Compiler Collection (GCC) version 3 or better installed in order to build clasp. You'll also need GNU make 3.80 or better. On Microsoft Windows, we recommend using MinGW available from http://www.mingw.org/ You may want to visit http://www.mingw.org/wiki/Getting_Started for detailed instructions on installing MinGW. Make sure to also install MinGW-make.
In the following it is assumed that 'make' is an alias for the installed GNU make. If this is not the case on your system, replace 'make' with the name of the GNU make executable (e.g. gmake). Furthermore, on Microsoft Windows use ./configure.bat instead of ./configure.sh.
clasp's multithread support requires the Intel Threading Building Blocks library (version >= 3.x) which is freely available at: http://threadingbuildingblocks.org/ After downloading and installing you may want to set and export the TBB30_INSTALL_DIR environment variable.
Type ./configure.sh --help to get an overview of all supported build configurations/options.
To build clasp: ./configure.sh cd build/release make
To build clasp with multithread support using TBB30_INSTALL_DIR: ./configure.sh --with-mt cd build/release_mt make
To build clasp with multithread support using custom directory structure:
./configure.sh --with-mt TBB_INCLUDE=
To install clasp: make install
By default, 'make install' will install clasp in '/usr/local/bin' You can specify an installation prefix other than '/usr/local' by running the configure-script with the option '--prefix=PATH'. Alternatively, use option '--bindir=PATH' to directly specify the installation path.
Finally, you can always skip installation and simply copy the clasp executable to a directory of your choice.
BUILDING WITH Microsoft Visual Studio In the directory build_vc/ we provide Microsoft Visual Studio project files for building clasp. You can download the freely available express edition of Visual C++ from here: http://www.microsoft.com/express/Downloads/ Once installed: - open build_vc\vc9\clasp\clasp.sln - select the desired solution configuration (typically release_static) - build the "app" project
USAGE clasp reads problem instances either from stdin, e.g cat problem | clasp or from a given file, e.g clasp problem
Beside logic programs in SMODELS-format, clasp also supports SAT-problems in DIMACS-, Max-SAT in (extended) DIMACS-, and PB-problems in OPB and WBO-format.
Type clasp --help to get an overview of the various options supported by clasp.
In addition to printing status information, clasp also provides information about the computation via its exit status. The exit status is: 10: if the problem was found to be satisfiable 20: if the problem was proved to be unsatisfiable 0 : if the satisfiability of problem is not known, because search was either interrupted or not started 127: if clasp ran out of memory Furthermore, the exit status of 1 indicates an error.
planning
A static version of the Fast Downward planning system, as used in the IPC 2011 planning competition and subsequent work in automated configuration for planning.
Provided with permission of the authors, please do not redistribute.
Contact the Fast Downward authors at http://www.fast-downward.org for license details and to see newer versions of the software.
A static version of the LPG-td planning system, as used in the IPC 2011 planning competition and subsequent work in automated configuration for planning.
Provided with permission of the authors, please do not redistribute.
Contact the authors of LPG at http://zeus.ing.unibs.it/lpg/ for license details.
sat
[This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Please contact the authors for an appropriate reference and licensing information. Please see below for the original README.]
Authors: Benjamin Kaufmann, Torsten Schaub, Marius Schneider
University of Potsdam
Contact: manju@cs.uni-potsdam.de
Content: . |-- callstring_generator.rb : original file from the minisat example |-- clasp : static linked binary of clasp 2.1.3 |-- clasp-2.1.3-src/ : sources of clasp 2.1.3 (see http://sourceforge.net/projects/potassco/files/clasp/2.1.3/) |-- clasp-2.1-sat-t1-discrete.txt : discrete configuration space of clasp 2.1 |-- clasp-2.1-sat-t1.txt : continuous configuration space of clasp 2.1 |-- clasp_parser.py : python script for reading the configuration from the file generated by callstring_generator.rb and printing the call string of clasp |-- parameter_parser.py : converts smac like paramters in clasp like parameters |-- README : this file
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Mate Soos, soos.mate@gmail.com Please contact the author for an appropriate reference and licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Thach-Thao Duong, thachthaoduong@gmail.com Please contact the author for an appropriate reference and licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Thach-Thao Duong, thachthaoduong@gmail.com Please contact the author for an appropriate reference and licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Authors: Thach-Thao Duong and Duc Nghia Pham. Contact: thachthaoduong@gmail.com Please contact the authors for an appropriate reference and licensing information.
[This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Armin Biere, biere@jku.at Please contact the author for an appropriate reference. Please see below for the original README; the compilation README file also covers licensing questions.]
see lingeling-ars-df4d2c8-130529/README for compilation
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Norbert Manthey, norbert.manthey@tu-dresden.de Please contact the author for an appropriate reference. Please see license.txt for licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Author: Norbert Manthey, norbert.manthey@tu-dresden.de Please contact the author for an appropriate reference. Please see license.txt for licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Authors: Daniel Le Berre and Stefanie Roussel. Contact: leberre@cril.fr Please contact the authors for an appropriate reference and licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Authors: Cheng-Shen Han and Jie-Hong Roland Jiang. Contact: jhjiang@cc.ee.ntu.edu.tw Please contact the authors for an appropriate reference and licensing information.
This version is taken from the Configurable SAT Solver Competition (CSSC) 2013 (http://www.cs.ubc.ca/labs/beta/Projects/CSSC2013/). Authors: Valeriy Balabanov. Contact: balabasik@gmail.com Please contact the authors for an appropriate reference and licensing information.
Author: Domagoj Babic, babic.domagoj@gmail.com Please contact the author concerning licensing information.
Reference: @misc{BabHut07, author = {Domagoj Babi\'c and Frank Hutter}, title = {SPEAR Theorem Prover}, note = {Solver description, {SAT} competition}, year={2007} }
timetabling
ctt timetabling solver for post-enrolment exam timetabling problems.
This code is the version used for the post-enrolment track of the ITC 2007 international timetabling competition, in which it placed third.
Code is made available with permission from the authors and should not be further distributed.
To compile: make all
To compile the checker: make checksln
To change command line parameters edit the file opag-input.cpp. Then run: make config this will create a new file called ComParser.cpp. Do not modify this file.
tsp
AAAA CCCC OOOO TTTTTT SSSSS PPPPP AA AA CC OO OO TT SS PP PP AAAAAA CC OO OO TT SSSS PPPPP AA AA CC OO OO TT SS PP AA AA CCCC OOOO TT SSSSS PP ###################################################### ########## ACO algorithms for the TSP ########## ###################################################### Version: 1.03 + tuning.patch (see below) Author: Thomas Stuetzle Copyright (c) Thomas Stuetzle, 2002 This is the README file to the software package ACOTSP. This software package was developed by Thomas Stuetzle in connection with the Book [DorStu04] Marco Dorigo and Thomas Stuetzle, "Ant Colony Optimization", MIT Press, Cambridge, MA, USA, 2004. The software package is freely available subject to the GNU General Public Licence, which is included in file gpl.txt. If you use ACOTSP in your research, I would appreciate a citation in your publication(s). Please cite it as Thomas Stuetzle. ACOTSP, Version 1.0. Available from http://www.aco-metaheuristic.org/aco-code, 2004. This software package provides an implementation of various Ant Colony Optimization (ACO) algorithms for the symmetric Traveling Salesman Problem (TSP). The ACO algorithms implemented are Ant System, Elitist Ant System, MAX-MIN Ant System, Rank-based version of Ant System, Best-Worst Ant System, and Ant Colony System. This is Version 1.0 of ACOTSP; it is in large part identical to the software used to produce the results in [DorStu04], but it has been slightly adapted to make the code more readable, more comments were added, and a new command line parser was generated with opag. AIMS OF THE SOFTWARE: This software was developed to have one common code for the various known ACO algorithms that were at some point applied to the TSP in the literature. The software tries to provide a reasonably efficient implementation of these ACO algorithms while at the same time aiming for readability and understandability of the code. UPDATES for version 1.03: (Manuel Lopez-Ibanez, Thomas Stuetzle) - parse.c, InOut.h: Increase filename length limit to 255. Add error if limit is passed. - TSP.c: correction to the computation of the ceiling distances (thanks to Ashley Wang for reporting the error). UPDATES for version 1.02: (Manuel Lopez-Ibanez) - Avoid rounding issues that may rarely result in broken tours. (ants.c: neighbour_choose_and_move_to_next) - The termination condition is now checked after every local search call. (acotsp.c: local_search) - Avoid division by zero. (ants.c: bwas_pheromone_mutation) - Defaults for all algorithms follow those given in the ACO book. - The type of timer can be selected when building. Either 'make TIMER=dos' or 'make TIMER=unix'. - New command-line flags: --quiet and --seed - Information about command-line options is printed to stdout. Only errors are printed in stderr. - Fix various compiler warnings. UPDATES for version 1.01: - corrected a memory leak on 64 bit architectures (file ls.c, line 83, changed int to long int) - corrected a problem in MMAS pheromone update (file acotsp.c, line 406, condition corrected to if ( u_gb == 1 && (iteration - restart_found_best > 50)) ) - corrected a problem in BWAS update (file acotsp.c, line 406, procedure call should read bwas_worst_ant_update( &ant[iteration_worst_ant], best_so_far_ant ); ) - corrected a problem in option parsing (file parse.c, line 1032 should read check_out_of_range( nn_ants, 1, 100, "nn_ants"); ) Thanks to the various users who have reported these problems! tuning.patch ============= There are some changes in the ants.c and acotsp.c files. These changes save the initial tour found: ants.c: In function nn_tour adding of the line: copy_from_to( &ant[0], best_so_far_ant); acotsp.c: In main after the call init_try(n_try); adding of write_report(); These changes were made due to a bug (http://sourceware.org/bugzilla/show_bug.cgi?id=13932) in the libc library, specifically in the pow function only for 64 bits processors. This was making the execution of acotsp much slower and not producing any solution before the termination criterion. ./acotsp --time 20 --tries 1 -i 1500-6.tsp --seed 545301 --acs --localsearch 3 --alpha 2.81 --beta 7.68 --rho 0.17 --ants 37 --nnls 9 --q0 0.59 --dlb 1 ========= CONTENTS ========= The GNU General Public Licence: gpl.txt The main control routines, main: acotsp.c Procedures to implement the ants behaviour: ants.c ants.h Input / output / statistics routines: InOut.c InOut.h Procedures specific to the TSP: TSP.c TSP.h Local search procedures: ls.c ls.h Additional useful / helping procedure: utilities.c utilities.h Command line parser: parse.c parse.h Time measurement: timer.h dos_timer.c : default timer implementation based on clock() unix_timer.c : in case you want to use rusage() instead, edit the Makefile to use this one or compile with 'make TIMER=unix' Makefile Instances: Some problem instances from TSPLIB: eil51.tsp kroA100.tsp d198.tsp lin318.tsp pcb442.tsp att532.tsp rat783.tsp pcb1173.tsp d1291.tsp pr2392.tsp. Other TSP instances are available from TSPLIB, the webpage for the 8th DIMACS Implementation Challenge on the TSP (http://www.research.att.com/~dsj/chtsp/) or the webpage on "Solving TSP" ===== Code ===== The software was developed in ANSI C under Linux, using the GNU 2.95.3 gcc compiler and extensively tested in this environment. The software is distributed as a gzipped tar file. To install the code, first obtain the file ACOTSP.V1.0.tar.gz. Unzip the file by typing gunzip ACOTSP.V1.0.tar.gz and then unpack it by typing tar -xvf ACOTSP.V1.0.tar The software will unpack in a new folder ACOTSP.V1.0 To compile it under Linux just type 'make' and the executable 'acotsp' is produced. Note: The code is written in ANSI C. Hence, the code should be reasonable portable to other Operating Systems than Linux or Unix. ====== USAGE ====== Given the large number of ACO algorithms, also the number of command line options is relatively large. The default parameter settings are such, that MAX-MIN Ant System will be run using a 3-opt local search, using alpha = 1, beta = 2, rho = 0.5 for a maximum of 10 seconds per each trial for 10 independent trials. (guess who developed MAX-MIN Ant System ;-) The executable 'acotsp' provides the following command line options (given are the short and the long options): -r, --tries # number of independent trials -s, --tours # number of steps in each trial -t, --time # maximum time for each trial --seed # seed for the random number generator -i, --tsplibfile f inputfile (TSPLIB format necessary) -o, --optimum # stop if tour better or equal optimum is found -m, --ants # number of ants -g, --nnants # nearest neighbours in tour construction -a, --alpha # alpha (influence of pheromone trails) -b, --beta # beta (influence of heuristic information) -e, --rho # rho: pheromone trail evaporation -q, --q0 # q_0: prob. of best choice in tour construction -c, --elitistants # number of elitist ants -f, --rasranks # number of ranks in rank-based Ant System -k, --nnls # No. of nearest neighbors for local search -l, --localsearch 0: no local search 1: 2-opt 2: 2.5-opt 3: 3-opt -d, --dlb 1 use don't look bits in local search -u, --as apply basic Ant System -v, --eas apply elitist Ant System -w, --ras apply rank-based version of Ant System -x, --mmas apply MAX-MIN ant system -y, --bwas apply best-worst ant system -z, --acs apply ant colony system -h, --help display the help text and exit Options -u --as, -v --eas, -w --ras, -x --mmas, -y --bwas, -z --acs, -h, --help don't need arguments, while all the others do. A Mandatory option is only the option "-i, --tsplibfile". Here, mandatory means that without specifying this option, the program won't work, since there is no input file. All the other options take some default values. The default values for these are: -r, --tries : 10 -s, --tours : 100 -t, --time : 10 /* seconds */ -o, --optimum : 1 -m, --ants : 25 -g, --nnants : 20 -a, --alpha : 1 -b, --beta : 2 -e, --rho : 0.5 -q, --q0 : 0.0 -c, --elitistants : 100 -f, --rasranks : 6 -k, --nnls : 20 -l, --localsearch : 3 /* use 3-opt */ -d, --dlb : 1 -u, --as : 0 -v, --eas : 0 -w, --ras : 0 -x, --mmas : 1 /* apply MAX-MIN Ant System */ -y, --bwas : 0 -z, --acs : 0 The default settings imply that as default MAX-MIN Ant System is run using a 3-opt local search procedure. Please note that these default values do not really make sense for some of the algorithms (e.g., typically an evaporation of 0.2 is recommended vor MAX-MIN Ant System); that is, for some of the algorithms the default parameter settings lead to poor performance (an example is ACS). Hence, when you use any of the ACO algorithms, make sure you set the appropriate parameter values. Typically, one may want to adjust the parameters -t, --time -o, --optimum -m, --ants -b, --beta -e, --rho -q, --q0 -l, --localsearch Note that only one option among -u --as, -v --eas, -w --ras, -x --mmas, -y --bwas, -z --acs, is to be specified. Examples for running an experiments are: ./acotsp -i lin318.tsp -v -t 60. -o 42029 -m 50 -b 5 or ./acotsp --tsplibfile lin318.tsp --acs --rho 0.1 --q0 0.95 --time 60. --optimum 42029 --ants 10 ======= OUTPUT ======= Every experiment produces three files. These files are best.tsplibfilename cmp.tsplibfilename stat.tsplibfilename where tsplibfilename is the instance identifier of the instance under solution. The most important of these is the file "cmp.tsplibfilename". This file starts with a specification of the parameter settings used to run the experiment. The section with the comprehensive experimental data starts with begin problem tsplibfilename Next the random number seed for the next trial is given Then, for each trial statistical information on the development of the best-so-far solution is given. Each section for a trial starts with begin tryThen, each time the algorithm finds a new best solution a line best iteration tours time is added, where "best" is the tour length of the best-so-far solution; iteration is the iteration number in which this solution is found; tours is the number of solutions constructed so far (typically this is simple iteration X n_ants); and time is the time at which a new best-so-far solution is found Each trial is ended by end try Once all trials are run the line end problem tsplibfilename is added to end the file. The file best.tsplibfilename collects the information about parameter settings, the best solution found in each trial, and some additional statistical information. The file stat.tsplibfilename may be used for the output of statistical information on a trial as generated by the procedure population_statistics(); in InOut.c; however, it is not heavily used in ACOTSP V1.0. Have fun, and if you have any comments please write to stuetzle no@spam ulb.ac.be
This scenario requires the programs 'acotsp' (from ACOTSP-VAR in directory src/), 'nondominated' (from mo-tools/, used for normalization), and hv (from hv/, for computing the hypervolume). All of them are implemented in C and need to be compiled. In GNU/Linux and other operating systems which support Makefiles, the required programs can be compiled by simply typing 'make' to produce the executables. ACOTSP-VAR is a modified version of the ACOTSP software with additional parameters controlling parameter variation. Further information about this variant can be found in the paper: M. López-Ibáñez and T. Stützle. Automatically improving the anytime behaviour of optimisation algorithms. European Journal of Operational Research, 2013. doi:10.1016/j.ejor.2013.10.043. This modified version is Copyright (c) 2013 Manuel Lopez-IbanezThis program is free software (software libre); you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. IMPORTANT NOTE: Please be aware that the fact that this program is released as Free Software does not excuse you from scientific propriety, which obligates you to give appropriate credit! If you write a scientific paper describing research that made substantive use of this program, it is your obligation as a scientist to (a) mention the fashion in which this software was used in the Methods section; (b) mention the algorithm in the References section. The appropriate citation is given above. The original ACOTSP is Copyright (c) Thomas Stuetzle, 2002. The README and license information of the original ACOTSP can be found in src/README
Instance sets
asp
The instances ricochet are Copyright (C) 2013 Potassco torsten@cs.uni-potsdam.de. The instances are lincensed under GPLv2.
Distributed by AClib with prior consent from the Author.
Literature (not exactly the same instances as used below; but generated with the advanced encoding on the same board)
@InProceedings{gejokaobsascsc13a, author = "M. Gebser and H. Jost and R. Kaminski and P. Obermeier and O. Sabuncu and T. Schaub and M. Schneider", title = "Ricochet Robots: A transverse {ASP} benchmark", crossref = "lpnmr13", pages = "348-360" } @Proceedings{lpnmr13, title = "Proceedings of the Twelfth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR'13)", booktitle = "Proceedings of the Twelfth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR'13)", year = 2013, editor = "P. Cabalar and T. Son", volume = 8148, series = "Lecture Notes in Artificial Intelligence", publisher = "Springer-Verlag" }
@InProceedings{schanda_et_al:LIPIcs:2012:3611, author = {Florian Schanda and Martin Brain}, title = {{Using Answer Set Programming in the Development of Verified Software}}, booktitle = {Technical Communications of the 28th International Conference on Logic Programming (ICLP'12)}, pages = {72--85}, series = {Leibniz International Proceedings in Informatics (LIPIcs)}, ISBN = {978-3-939897-43-9}, ISSN = {1868-8969}, year = {2012}, volume = {17}, editor = {Agostino Dovier and V{\'i}tor Santos Costa}, publisher = {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik}, address = {Dagstuhl, Germany}, URL = {http://drops.dagstuhl.de/opus/volltexte/2012/3611}, URN = {urn:nbn:de:0030-drops-36114}, doi = {http://dx.doi.org/10.4230/LIPIcs.ICLP.2012.72}, annote = {Keywords: Answer Set Programming, verification, SPARK, Ada, contract based verification, safety critical} }
@inproceedings{DBLP:conf/padl/LierlerSTW12, author = {Yuliya Lierler and Shaden Smith and Miroslaw Truszczynski and Alex Westlund}, title = {Weighted-Sequence Problem: ASP vs CASP and Declarative vs Problem-Oriented Solving}, booktitle = {PADL}, year = {2012}, pages = {63-77}, ee = {http://dx.doi.org/10.1007/978-3-642-27694-1_6}, crossref = {DBLP:conf/padl/2012}, bibsource = {DBLP, http://dblp.uni-trier.de} } @proceedings{DBLP:conf/padl/2012, editor = {Claudio V. Russo and Neng-Fa Zhou}, title = {Practical Aspects of Declarative Languages - 14th International Symposium, PADL 2012, Philadelphia, PA, USA, January 23-24, 2012. Proceedings}, booktitle = {PADL}, publisher = {Springer}, series = {Lecture Notes in Computer Science}, volume = {7149}, year = {2012}, isbn = {978-3-642-27693-4}, ee = {http://dx.doi.org/10.1007/978-3-642-27694-1}, bibsource = {DBLP, http://dblp.uni-trier.de} }
btsp
Bi-objective travelling salesman problem (BTSP) instances. There are Random Uniform Euclidean with sizes between 100 and 1000 cities. These instances are for all purposes in the public domain.
mip
These instances are provided by the Berkeley Computational Optimization Lab (under http://ieor.berkeley.edu/~atamturk/data/capacitated.lotsizing/cls.data.tar.gz). Please cite them as follows:
@ARTICLE{AM:ls-poly, AUTHOR = {A. Atamt{\"u}rk and J. C. Mu{\~n}oz}, TITLE = {A Study of the Lot-Sizing Polytope}, JOURNAL = {Mathematical Programming}, VOLUME = {99}, PAGES = {443-465}, YEAR = {2004}}
These instances were generated and provided by Bistra Dilkina, using the generator from:
@inproceedings{ghs08:connection, author={Gomes, Carla P. and {van Hoeve}, Willem-Jan and Sabharwal, Ashish}, title={Connections in networks: a hybrid approach}, booktitle=cpaior08, month=may, year=2008, address={Paris, France}, series=lncs, volume=5015, pages={303-307}, publisher = springer-lncs, editor = {L. Perron and M.~A. Trick} }
These instances were generated and provided by Lin Xu, using the generator from:
@INPROCEEDINGS{rcw, author = {Ahmadizadeh, K. and Dilkina, B. and Gomes, C.P. and Sabharwal, A.}, title = {An empirical study of optimization for maximizing diffusion in networks}, booktitle = cp10, pages = {514--521}, year = 2010, series = {LNCS}, volume = {6308}, publisher = {Springer-Verlag} }
These instances were generated by Lin Xu, using the generator from:
@InProceedings{LeyPeaSho00, author = "K. Leyton-Brown and M. Pearson and Y. Shoham", title = "Towards a Universal Test Suite for Combinatorial Auction Algorithms", booktitle = {EC '00: Proceedings of the 2nd ACM conference on Electronic commerce}, pages = "66--76", year={2000}, publisher = {ACM}, address = {New York, NY, USA}, }
ml
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset has been proposed by: @article{krizhevsky2009learning, title={Learning multiple layers of features from tiny images}, author={Krizhevsky, Alex and Hinton, Geoffrey}, journal={Master's thesis, Department of Computer Science, University of Toronto}, year={2009} }
This dataset has been proposed by: @article{krizhevsky2009learning, title={Learning multiple layers of features from tiny images}, author={Krizhevsky, Alex and Hinton, Geoffrey}, journal={Master's thesis, Department of Computer Science, University of Toronto}, year={2009} }
This dataset is taken from: @article{bergstra2012random, title={Random search for hyper-parameter optimization}, author={Bergstra, J. and Bengio, Y.}, journal=jmlr, volume={13}, pages={281--305}, year={2012} }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset originates from the KDD cup 2009.
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is taken from: @incollection{LeCunEtAl12, author = {Yann LeCun and L{\'e}on Bottou and Genevieve B. Orr and Klaus-Robert M{\"u}ller}, title = {Efficient BackProp}, booktitle = {Neural Networks: Tricks of the Trade (2nd ed.)}, year = {2012}, pages = {9-48} }
This dataset is taken from: @incollection{LeCunEtAl12, author = {Yann LeCun and L{\'e}on Bottou and Genevieve B. Orr and Klaus-Robert M{\"u}ller}, title = {Efficient BackProp}, booktitle = {Neural Networks: Tricks of the Trade (2nd ed.)}, year = {2012}, pages = {9-48} }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
This dataset is part of the UCI machine learning repository: @misc{Asuncion+Newman:2007 , author = "A. Asuncion, D.J. Newman", year = "2007", title = "{UCI} Machine Learning Repository", url = "http://www.ics.uci.edu/$\sim$mlearn/{MLR}epository.html", institution = "University of California, Irvine, School of Information and Computer Sciences" }
planning
This is a set of instances from the Barman planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Barman planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Blocksworld planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Blocksworld planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Depots planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Depots planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Gripper planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Gripper planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from all domains of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from all domains of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Parking planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Parking planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Rover planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Rover planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Satellite planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Satellite planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the Spanner planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the Spanner planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
This is a set of instances from the TPP planning domain of the IPC-2011 learning track.
The training set was generated specifically for the FD-autotune submission, while the test set is that used in the competition.
This is a set of instances from the TPP planning domain of the IPC-2011 learning track.
The training set was generated specifically for the ParLPG submission, while the test set is that used in the competition.
sat
This instance set was introduced in the following paper:
@inproceedings{CaptainJack, lauthor = {Tompkins, Dave A. D. and Balint, Adrian and Hoos, Holger H.}, author = {Tompkins, D. A. D. and Balint, A. and Hoos, H. H.}, title = {Captain {Jack}: new variable selection heuristics in local search for {SAT}}, booktitle = {Proc.~of SAT-11}, lseries = {SAT'11}, year = {2011}, lisbn = {978-3-642-21580-3}, llocation = {Ann Arbor, MI}, pages = {302--316}, lnumpages = {15}, lurl = {http://dl.acm.org/citation.cfm?id=2023474.2023506}, lacmid = {2023506}, lpublisher = {Springer-Verlag}, laddress = {Berlin, Heidelberg}, }
This benchmark set consists of CNFs that Sam Bayless derived by unrolling the Hardware Model Checking Competition 2008 (HWMCC 2008) circuits into CNF, using the tool 'aigunroll'.
HWMCC 2008 can be cited as follows: A. Biere. Hardware Model Checking Competition 2008. http://fmv.jku.at/hwmcc/
This benchmark set is a subset of the BMC08 instances used in the Configurable SAT Solver Challenge 2013 (CSSC 2013); instances generated from 60 Intel instances with unclear licensing restrictrions are omitted. If you have access to the full instance set, the original BMC08 training/test split is given in data/BMC08.
These were created using Armin Biere's cnf fuzzer fuzzsat, which generated circuits and translates them into CNFs. We generated many circuits (using the options -i 100 -I 100) and then filtered out all that could be solved by lingeling in < 1 second (on one particular desktop computer).
These are easy regression test instances provided by Sam Bayless for the Configurable SAT Solver Competition (CSSC 2013). They are useful for testing wrappers etc. Note that, since these are not instances for a real configuration scenario, the test set is superfluous. To be syntactically correct, it is chosen as identical to the training set.
These instances are described on page 117 of Balint, A, Belov, A, Heule, M J H & Jaervisalo, M (eds), 2013, Proceedings of SAT Competition 2013: Solver and Benchmark Descriptions. Department of Computer Science Series of Publications B, vol. B-2013-1, vol. B-2013-1, University of Helsinki, Helsinki.
This is a set of uniform random 3-SAT instances of various sizes that was used for the Configurable SAT Solver Competition (CSSC 2013).
These instances are described on page 115 of Balint, A, Belov, A, Heule, M J H & Jaervisalo, M (eds), 2013, Proceedings of SAT Competition 2013: Solver and Benchmark Descriptions. Department of Computer Science Series of Publications B, vol. B-2013-1, vol. B-2013-1, University of Helsinki, Helsinki.
This benchmark set consists of 604 SAT-encoded software verification instances generated with the Calysto tool from Domagoj Babic, split into 302 training and 302 test instances. It can be cited as:
@inproceedings{babic07structural-abs, author = {Domagoj Babi\'c and Alan J. Hu}, title = {{Structural Abstraction of Software Verification Conditions}}, booktitle = {Computer Aided Verification: 19th International Conference, CAV 2007}, publisher = {Springer}, series = {LNCS}, volume = {4590}, year = {2007}, pages={366--378}, location = {Berlin, Germany} }
The set was first used for algorithm configuration in: @inproceedings{HutBabHooHu07, author = {F. Hutter and D. Babi\'c and H.~H.~Hoos and A.~J.~Hu}, title = {{Boosting verification by automatic tuning of decision procedures}}, year = {2007}, booktitle = fmcad07, publisher = {IEEE Computer Society}, address = {Washington, DC, USA}, editor = {J. Baumgartner and M. Sheeran}, pages = {27--34} }
This is a set of satisfiable uniform random 3-SAT instances at the phase transition with 250 variables that was included in the CSSC distribution as a simple benchmark set to enable a quick configuration run for testing purposes.
These instance were generated with the generator at: http://sourceforge.net/projects/ksatgenerator/, described on page 72 of: Balint, A, Belov, A, Heule, M J H & Jaervisalo, M (eds), 2012, Proceedings of SAT Competition 2012: Solver and Benchmark Descriptions. Department of Computer Science Series of Publications B, vol. B-2012-2, vol. B-2012-2, University of Helsinki, Helsinki.
timetabling
tsp
Travelling salesman problem (TSP) instances. There are Random Uniform Euclidean with sizes between 1000 and 3000 cities. These instances are for all purposes in the public domain.
Travelling salesman problem (TSP) instances. There are Random Uniform Euclidean with size 3000. These instances are for all purposes in the public domain.
People
-
Manuel López-Ibáñez (webpage | email ), IRIDIA, Université Libre de Bruxelles
-
Chris Fawcett (webpage | email), University of British Columbia
-
Holger H. Hoos (webpage | email), University of British Columbia
-
Kevin Leyton-Brown (webpage | email), University of British Columbia
-
Thomas Stützle (webpage | email), IRIDIA, Université Libre de Bruxelles
References
- [Babic and Hu, 2007]. D. Babic and A. Hu. Structural abstraction of software verification conditions. In Proc. of CAV-07, pages 366-378, 2007.
- [Babic and Hutter, 2007] D. Babic and F. Hutter. SPEAR Theorem Prover, solver description SAT '07.
- [Soos, 2010] M. Soos. CryptoMiniSat 2.5.0. Solver description, SAT Race 2010, 2010.
- [Balint et al, 2011] A. Balint, A. Frohlich, D.A.D. Tompkins, and H.H. Hoos. Sparrow2011. Solver description, SAT competition 2011, 2011.
- [Tompkins et al, 2011] D.A.D. Tompkins, A. Balint, and H.H. Hoos. Captain Jack: new variable selection heuristics in local search for SAT. In Proc. of SAT-11, pages 302-316, 2011.
- [KhudaBukhsh et al, 2009] A. KhudaBukhsh, L. Xu, H. H. Hoos, and K. Leyton-Brown. SATenstein: Automatically building local search SAT solvers from components. In Proc. of IJCAI-09, pages 517-524, 2009.
- [Gebser et al, 2007] M. Gebser, B. Kaufmann, A. Neumann, and T. Schaub. Conflict-driven answer set solving. In Proc. of IJCAI-07, pages 386-392, 2007.
- [Helsgaun, 2000] Helsgaun, K. (2000). An effective implementation of the Lin-Kernighan traveling salesman heuristic. European Journal of Operational Research, 126(1), pages 106-130.
- [Zarpas, 2005] E. Zarpas. Benchmarking SAT solvers for bounded model checking. In Proc. of SAT-05, pages 340-354. Springer Verlag, 2005
- [Ahmadizadeh, 2008] K. Ahmadizadeh, B. Dilkina, C.P. Gomes, and A. Sabharwal. An empirical study of optimization for maximizing diffusion in networks. In Proc. of CP-10, pages 514-521, 2010
- [Gomes et al, 2008] C.P. Gomes, W. van Hoeve, and A. Sabharwal. Connections in networks: a hybrid approach. In Proc. of CPAIOR-08, pages 303-307, 2008.
- [Leyton-Brown et al, 2000] K. Leyton-Brown, M. Pearson, and Y. Shoham. Towards a universal test suite for combinatorial auction algorithms. In Proc. of EC-00, pages 66-76, 2000.
- [Atamturk and Munoz, 2004] A.Atamturk and J. C. Munoz. A study of the lot-sizing polytope. Mathematical Programming, 99:443-465, 2004.
- [Silverthorn et al, 2012] B. Silverthorn, Y. Lierler, and M. Schneider. Surviving solver sensitivity: An ASP practitioner's guide. In Proc. of ICLP-LIPICS-12, pages 164-175, 2012.
- [Johnson, 2011] D.S. Johnson (2011). Random TSP generators for the DIMACS TSP challenge. http://www2.research.att.com/~dsj/chtsp/codes.tar. Last accessed on May 16, 2011.
- [Stützle, 2002] T. Stützle (2002). ACOTSP: A Software Package of Various Ant Colony Optimization Algorithms Applied to the Symmetric Traveling Salesman Problem. http://www.aco-metaheuristic.org/aco-code/.
-
[López-Ibáñez and Stützle, 2012] Manuel López-Ibáñez and Thomas Stützle. The Automatic Design of Multi-Objective Ant Colony Optimization Algorithms. IEEE Transactions on Evolutionary Computation, 16(6):861–875, 2012.
-
[López-Ibáñez and Stützle, 2013] Manuel López-Ibáñez and Thomas Stützle. Automatically Improving the Anytime Behaviour of Optimisation Algorithms. European Journal of Operational Research, 2013.