Back to [[Releases]].

= Fast Downward 23.06 =

Fast Downward 23.06 was released on July 31, 2023.

Highlights:

 * The option parser of the search component has been completely reimplemented. The new option parser has full error reporting where the old code crashed on errors or silently accepted them. This is also an important stepping stone towards a future use of Fast Downward as a library. With the change, the `--evaluator`, `--heuristic` and `--landmarks` options are now deprecated in favor of a new `let` syntax. For example,
 {{{
--evaluator h=EVALUATOR --search SEARCH_ALGORITHM}}}
 is deprecated in favor of the expression
 {{{
--search let(h, EVALUATOR, SEARCH_ALGORITHM)}}}

 * We now compile using the C++20 standard, so all modern C++ features can be used as long as they are supported by all main compilers Fast Downward supports (see `README.md`).

 * The linear programming and mixed integer programming features of Fast Downward now communicate directly with the LP/MIP solvers (!SoPlex or CPLEX) rather than using the open solver interface OSI as an intermediary. This has also allowed us to move to more modern versions of these solvers.

 * The `lmcount` heuristic has been split into two separate heuristics called `landmark_sum` and `landmark_cost_partitioning`. The former corresponds to the old `lmcount` with the option `admissible=false`, the latter to the old `lmcount` with the option `admissible=true`.

 * The two new landmark heuristics (`landmark_sum` and `landmark_cost_partitioning`) compute preferred operators more efficiently than before. On average, this improves performance of LAMA-style planner configurations.

 * The merge-and-shrink heuristic now stores labels and their transitions more efficiently, resulting in improved speed for merge-and-shrink heuristic construction.

 * The MIASM merge strategy for merge-and-shrink (more precisely, the `sf_miasm` merge scoring function) now has an option to cache scores. Caching is enabled by default and greatly speeds up construction of MIASM-based merge-and-shrink heuristics.

The Apptainer and Docker distributions of the planner include LP support using the [[https://soplex.zib.de/|SoPlex]] solver.

== Downloads ==

 * source tarball: [[attachment:fast-downward-23.06.tar.gz||&do=get]]
 * Apptainer image: downloaded automatically by Apptainer (see QuickStart)
 * Docker container: [[https://hub.docker.com/r/aibasel/downward|aibasel/downward:23.06 on Docker Hub]]
 * Vagrantfile: [[attachment:Vagrantfile||&do=get]] for Fast Downward 23.06

For Apptainer, Docker and Vagrant, see QuickStart for instructions on how to run the planner. That page explains how to run the latest release of Fast Downward, so you have to amend the instructions if you want to run an older release.

For the tarball, if you have satisfied all dependencies, the following should build and run the planner with configuration alias `lama-first` on PDDL files `/path/to/domain.pddl` and `/path/to/problem.pddl` on a Linux or macOS system:
{{{#!bash
tar -xvzf fast-downward-23.06.tar.gz
cd fast-downward-23.06
./build.py
./fast-downward.py --alias lama-first /path/to/domain.pddl /path/to/problem.pddl
}}}

For dependencies and more advanced information (including Windows builds), see [[https://github.com/aibasel/downward/blob/main/BUILD.md|the build instructions]].

== Limitations ==

For licensing reasons, the binary distributions of Fast Downward have limited support for commercial LP solvers (like CPLEX). The Docker and Apptainer distributions only support !SoPlex. The Vagrant version supports !SoPlex and/or CPLEX if they are available at provisioning time. See QuickStart for more information.

== Referencing Fast Downward 23.06 ==

If you use this version of Fast Downward in a scientific publication, we encourage you to mention the version number, as in
"We ran experiments with Fast Downward 23.06." The canonical reference for citing Fast Downward is the following journal paper:

{{{
@Article{helmert-jair2006,
  author =  "Malte Helmert",
  title =   "The {Fast} {Downward} Planning System",
  journal = "Journal of Artificial Intelligence Research",
  year =    "2006",
  volume =  "26",
  pages =   "191--246"
}
}}}

== Changes in Fast Downward 23.06 ==

Details:

 * option parser: We implemented a new way of defining features and parsing them from the command line. The new parser now supports defining variables for features (heuristics and landmark graphs so far) as an expression within the option string. For example,
   {{{
let(h, lmcut(), astar(h))}}}
 instantiates the `lmcut` heuristic, binds it to the variable `h` and uses it within the `astar` search algorithm.
 This change to the parser is an important stepping stone towards solving a more general problem about how components interact. Details of the new parser are described in a blog article. We also improved the documentation of enum values. <<BR>>
 https://www.fast-downward.org/ForDevelopers/Blog/TheNewOptionParser <<BR>>
 https://issues.fast-downward.org/issue1073 <<BR>>
 https://issues.fast-downward.org/issue1040

 * translator, for developers: Unreachable atoms are now filtered from mutex groups in an earlier processing step than before. In a few domains this leads to a different finite-domain representation. We could remove an old hack related to static literals in goals, which is no longer necessary. We also added some type annotations, in particular to the core data structures. <<BR>>
 https://issues.fast-downward.org/issue1079

 * translator, for users: The change described in the previous entry can lead to Fast Downward producing a slightly different finite-domain representation in some cases.

 * search algorithms, for developers: Instead of "search engine" we now say "search algorithm" everywhere. Among other things, this affects source file and directory names, namespaces, class names. The change is also reflected in the documentation. <<BR>>
 https://issues.fast-downward.org/issue1099

 * Cartesian abstractions, for developers: The `cegar` directory and namespace have been renamed to `cartesian_abstractions` to avoid confusion with CEGAR-based code in the `pdbs` directory. <<BR>>
 https://issues.fast-downward.org/issue1098

 * landmarks: We replaced the `lmcount` heuristic with two new heuristics called `landmark_sum` and `landmark_cost_partitioning`. No functionality is added or removed: `landmark_sum` replaces `lmcount` with the option `admissible=false` and `landmark_cost_partitioning` replaces `lmcount` with the option `admissible=true`. <<BR>>
 https://issues.fast-downward.org/issue1071

 * landmarks: Refactor the computation of preferred operators in the landmark heuristics (`landmark_sum` and `landmark_cost_partitioning`). The change affects configurations based on LAMA that use preferred operators. While the semantics of the code did not change, the new version is slightly faster and can solve more tasks and/or improves plan quality in an anytime configuration within the same time limit. <<BR>>
 https://issues.fast-downward.org/issue1070

 * merge-and-shrink: Improve the way that labels and their transitions are stored. We removed the class `LabelEquivalenceRelation`. Instead `TransitionSystem` now handles locally equivalent labels itself using a new `LocalLabelInfo` class and stores a mapping from global to local labels. Labels are now removed from label groups in batches during label reduction. With this change, we can now construct the atomic factored transition system (and the overall heuristic) in significantly more cases, reducing both memory usage and construction time. <<BR>>
 https://issues.fast-downward.org/issue927

 * merge-and-shrink: The MIASM scoring function (feature `sf_miasm`) now has an option to cache scores for merge candidates, enabled by default. This greatly decreases computation time of M&S abstractions with this scoring function. <<BR>>
 https://issues.fast-downward.org/issue1092

 * pattern databases: The pattern generators `cegar_pattern` and `random_pattern` now correctly support fractional values for the `max_time` parameter. Previously the fractional part was silently ignored. For example a timeout of 7.5 seconds was treated as 7 seconds.

 * pattern databases, for developers: We split off the computation of pattern databases from the `PatternDatabase` class. `PatternDatabase` now stores pattern, `hash_multipliers` and `num_states` in a new class `Projection`, used for ranking and unranking. PDBs can be computed via a function which uses an internal class `PatternDatabaseFactory`. Abstract operators live in their own files now, similar to `MatchTree`. Performance does not change due to this issue. <<BR>>
 https://issues.fast-downward.org/issue1019

 * LP/MIP solvers: So far, we used the open solver interface OSI to communicate with MIP and LP solvers. We now replaced this with our own interface to have more direct control and fewer external dependencies. We now support CPLEX 22.1.1 and !SoPlex from their current main branch (released versions <= 6.0.3 are incompatible with C++20). We removed the solver options for CLP and Gurobi in the process: CLP has much worse performance than !SoPlex, which is also open source, while Gurobi was never practically possible to compile with, as we did not have a CMake find script for it. Performance with CPLEX increases in MIP configurations and stays roughly the same in LP configurations. Performance with !SoPlex increases for potential heuristics and decreased slightly in other configurations. Our Windows builds forced static linking because of OSI. With OSI removed, they no longer do. <<BR>>
 https://issues.fast-downward.org/issue1076 <<BR>>
 https://issues.fast-downward.org/issue1093 <<BR>>
 https://issues.fast-downward.org/issue1095

 * LP/MIP solvers, for developers: Previously, LP solvers could crash if a constraint included multiple terms for the same variable. We now protect against this with an assertion in debug mode. The change has no effect on release builds. <<BR>>
 https://issues.fast-downward.org/issue1088

 * build: The build script now performs the requested builds in the given order. For example,
 {{{
  ./build.py debug release}}}
 will perform a debug build and then a release build. Previously, the order was arbitrary, depending on Python dictionary order. <<BR>>
 https://issues.fast-downward.org/issue1086

 * C++ standard: We now compile the planner using the C++20 standard. We added tests for GCC 12 and clang 14 but dropped tests for GCC 9, clang 10, and clang 11.

 The minimal supported compilers are now:
  * g++-10
  * clang-12
  * MSVC 19.34
  * !AppleClang 13.0

 Language features supported by all of these compilers may now be used in the planner. For a list of such features and more details, see the issue tracker. The list includes `std::optional`, so we removed the implementation of `optional` in `src/search/ext`. <<BR>>
 https://issues.fast-downward.org/issue1028 <<BR>>
 https://issues.fast-downward.org/issue1094

 * Windows build: We now enable more compiler warnings on Windows builds. In detail, we no longer ignore warnings C4800, C4512, C4706, C4100, C4127, C4309, C4702, C4239, C4996, and C4505 on Windows builds as they no longer occur in our code. Warnings in !GitHub actions are now also treated as errors in Windows builds. <<BR>>
 https://issues.fast-downward.org/issue565

 * infrastructure: We fixed a problem with using CPLEX in the !GitHub action builds on Ubuntu. <<BR>>
 https://issues.fast-downward.org/issue1093

 * infrastructure: We update the version of uncrustify used to fix code formatting. Instructions on how to install the new version can be found on the wiki: <<BR>>
 https://www.fast-downward.org/ForDevelopers/Uncrustify. <<BR>>
 https://issues.fast-downward.org/issue1090