Original: Re-Evaluating Chemical Synthesis Planning Algorithms
Revised: Re-Evaluating Chemical Synthesis Planning Algorithms

Original: Abstract
Revised: Abstract

Original: Computer-Aided Chemical Synthesis Planning (CASP) algorithms have the potential to help chemists predict how to make molecules, and decide which moleculesto prioritize for synthesis and testing.
Revised: Computer-Aided Chemical Synthesis Planning (CASP) algorithms have the potential to help chemists predict how to make molecules, and decide which molecules to prioritize for synthesis and testing.

Original: Recently, several algorithms have beenproposed to tackle this problem, reporting large performance improvements.
Revised: Recently, several algorithms have been proposed to tackle this problem, reporting large performance improvements.

Original: Inthis work, we re-examine current and prior State-of-the-Art synthesis planningalgorithms under controlled and identical conditions, providing a holistic viewusing several previously un-reported evaluation metrics which cover the commonuse-cases of these algorithms.
Revised: In this work, we re-examine current and prior state-of-the-art synthesis planning algorithms under controlled and identical conditions, providing a holistic view using several previously un-reported evaluation metrics which cover the common use-cases of these algorithms.

Original: In contrast to prior studies, we find that under strictcontrol, differences between algorithms are smaller than previously assumed.
Revised: In contrast to prior studies, we find that under strict control, differences between algorithms are smaller than previously assumed.

Original: Ourfindings can guide users to choose the appropriate algorithms for specific tasks, aswell as stimulate new research in improved algorithms
Revised: Our findings can guide users to choose the appropriate algorithms for specific tasks, as well as stimulate new research in improved algorithms.

Original:  Introduction/Motivation
Revised:  Introduction/Motivation

Original: The synthesis of small organic molecules (SMOLs) is an essential part of drug and materials discovery.
Revised: The synthesis of small organic molecules (SMOLs) is an essential part of drug and materials discovery.

Original: To make a desired target molecule, one follows a synthesis route (also called plan), which consistsof usually multiple reactions one has to run starting from commercially available building blockmolecules to obtain the target.
Revised: To make a desired target molecule, one follows a synthesis route (also called plan), which consists of usually multiple reactions one has to run starting from commercially available building block molecules to obtain the target.

Original: Thus, a route resembles a cooking recipe, where the target moleculeis the desired final dish, and thethe building blocks are ingredients.
Revised: Thus, a route resembles a cooking recipe, where the target molecule is the desired final dish and the building blocks are ingredients.

Original: The most common approachto come up with a route is by decomposing the target molecule recursively using formally reversedchemical reactions, until one reaches the building blocks.
Revised: The most common approach to come up with a route is by decomposing the target molecule recursively using formally reversed chemical reactions, until one reaches the building blocks.

Original: In chemistry, this technique is calledretrosynthesis .
Revised: In chemistry, this technique is called retrosynthesis [Robinson, 1917, Vleduts, 1963, Corey and Cheng, 1989].

Original: In contrast to peptides, proteins, or DNA/RNA, which can be made by a small number of possiblechemical reaction types, the structural diversity of SMOLs requires thousands of different reactiontypes.
Revised: In contrast to peptides, proteins, or DNA/RNA, which can be made by a small number of possible chemical reaction types, the structural diversity of SMOLs requires thousands of different reaction types.

Original: This makes route planning challenging, as reaction types correspond to different options thatcan be taken at each step in the recursive decomposition, which makes retrosynthesis hard even forthe best human chemists.
Revised: This makes route planning challenging even for the best human chemists, as reaction types correspond to different options that can be taken at each step in the recursive decomposition.

Original: Computational approaches for synthesis planning have been studied for at least six decades [Todd,2005, Strieth-Kalthoff et al., 2020].
Revised: Computational approaches for synthesis planning have been studied for at least six decades [Todd, 2005, Strieth-Kalthoff et al., 2020, Vleduts, 1963].

Original: Recently, the use of machine learning for synthesis planning hasled to considerable progress in particular in the quality of the proposed solutions, and to renewedinterest in the field [Segler et al.,  2018, Coley et al., 2019, Kishimoto et al., 2019,Schwaller et al.
Revised: Recently, the use of machine learning for synthesis planning has led to considerable progress in particular in the quality of the proposed solutions, and to renewed interest in the field [Segler et al., 2017, 2018, Coley et al., 2019, Kishimoto et al., 2019,

Original: ,2020, Genheden et al., 2020, Chen et al., 2020, Kim et al., 2021, Xie et al., 2022].
Revised: Schwaller et al., 2020, Genheden et al., 2020, Chen et al., 2020, Kim et al., 2021, Xie et al., 2022].

Original: Conceptually, synthesis planning algorithms have four components: 1) A reaction prediction module,to propose single-step retrosynthetic disconnections that correspond to feasible reactions in the forward direction, 2) a search or planning algorithm that can handle large branching factors, 3) abuilding block library, 4) ranking criteria for the returned routes, for example by cost.
Revised: Conceptually, synthesis planning programs have four components: 1) A reaction prediction module, to propose single-step retrosynthetic disconnections that correspond to feasible reactions in the forward direction, 2) a search or planning algorithm that can handle large branching factors, 3) a building block library, 4) ranking criteria for the returned routes, for example by cost.

Original: In this work, we re-evaluate component 2), the search algorithms.
Revised: In this work, we re-evaluate component 2), the search algorithms.

Original: We report preliminary findingswhich suggest that the performance of different search algorithms may be much more similar thanpreviously reported.
Revised: We report preliminary findings which suggest that the performance of different search algorithms may be much more similar than previously reported.

Original: Specifically, after re-benchmarking two MCTS variants against the Retro*algorithm [Chen et al., 2020] on four distinct sets of test molecules, we find that both the time atwhich a solution is found and the diversity of solutions found is essentially indistinguishable for allalgorithms.
Revised: Specifically, after re-benchmarking two Monte Carlo Tree Search (MCTS) variants against the Retro* algorithm [Chen et al., 2020] on four distinct sets of test molecules, we find that both the time at which a solution is found and the diversity of solutions found is essentially indistinguishable for all algorithms.

Original: We believe these results raise some important questions for the community, and help toset best practice for future researchers in this area.
Revised: We believe these results raise some important questions for the community, and help to set best practice for future researchers in this area.

Original:  Experimental Procedure
Revised:  Experimental Procedure

Original: Algorithm classes considered.
Revised: Algorithm classes considered.

Original: We focus our experiments on two algorithm classes: MCTS[Browne et al., 2012] and Retro* [Chen et al., 2020], which is inspired by A*.
Revised: We focus our experiments on two algorithm classes: MCTS [Browne et al., 2012] and Retro* [Chen et al., 2020], which is inspired by A*.

Original: MCTS is chosenbecause of its initial successful results for synthesis planning [Segler et al., 2017], and the subsequentattention and adoption that it received from the chemistry community (e.g. [Segler et al., 2018, Coleyet al., 2019, Genheden et al., 2020]).
Revised: MCTS is chosen because of its initial successful results for synthesis planning [Segler et al., 2017], and the subsequent attention and adoption that it received from the chemistry community (e.g. [Segler et al., 2018, Coley et al., 2019, Genheden et al., 2020]).

Original: Retro* [Chen et al., 2020] is selected as it reported a significantimprovement over MCTS , and because the algorithm operates on an AND/OR tree instead of an
Revised: Retro* [Chen et al., 2020] is selected as it reported a significant improvement over MCTS , and because the algorithm operates on an AND/OR tree instead of an

Original: OR tree from Segler et al.
Revised: OR tree from Segler et al.

Original: [2018], Coley et al.
Revised: [2018], Coley et al.

Original: [2019], Genheden et al.
Revised: [2019], Genheden et al.

Original: [2020], which is a morenatural data structure for synthesis trees.
Revised: [2020], which is a more natural data structure for synthesis trees.

Original: We did not run initial experiments using proof numbersearch [Kishimoto et al., 2019] at this time due to the lower performance of this method reported in
Revised: We did not run initial experiments using proof number search [Kishimoto et al., 2019] at this time due to the lower performance of this method reported in

Original: Genheden and Bjerrum [2022], although we intend to run these experiments at a later date.
Revised: Genheden and Bjerrum [2022], although we intend to run these experiments at a later date.

Original: Algorithms used.
Revised: Algorithms used.

Original: From these algorithm classes, we chose three specific algorithms: Retro* on
Revised: From these algorithm classes, we chose three specific algorithms: Retro* on

Original: AND/OR trees, MCTS as implemented by Segler et al.
Revised: AND/OR trees, MCTS as implemented by Segler et al.

Original: [2018], Coley et al.
Revised: [2018], Coley et al.

Original: [2019], Genheden et al.[2020] on OR trees, and a novel modified version of MCTS which uses an AND/OR tree (AO-MCTS).
Revised: [2019], Genheden et al. [2020] on OR trees, and a novel modified version of MCTS which uses an AND/OR tree (AO-MCTS).

Original: All algorithms are implemented in a similar way as part of a larger python package for retrosynthesis,ensuring that performance differences due to implementation style are minimal.
Revised: All algorithms are implemented in a similar way as part of a larger python package for retrosynthesis, ensuring that performance differences due to implementation style are minimal.

Original: All algorithms usethe same reaction model and policy, and we run each algorithm with two different value functions: aconstant value function, and a pre-trained neural network value function from Chen et al.
Revised: All algorithms use the same reaction model and policy, and we run each algorithm with two different value functions: a constant value function, and a pre-trained neural network value function from Chen et al.

Original: Thisis an important departure from previous papers, which used different value functions for differentalgorithms (often rollouts for MCTS), making it unclear how much of performance differences aredue to the algorithm and how much are due to the value function.
Revised: This is an important departure from previous papers, which used different value functions for different algorithms (often rollouts for MCTS), making it unclear how much of performance differences are due to the algorithm and how much are due to the value function.

Original: Further details can be found in
Revised: Further details can be found in

Original: Appendix A.
Revised: Appendix A.

Original: Evaluation metrics.
Revised: Evaluation metrics.

Original: We chose to evaluate performance with two metrics: the time at which asolution is found, and the number of distinct solutions found over time.
Revised: We chose to evaluate performance with two metrics: the time at which a solution is found, and the number of distinct solutions found over time.

Original: The first metric was chosenas an improvement over previous papers, which simply report the fraction of molecules which haveat least one solution by a given time, which does not yield any insight about when within that timewindow solutions were found.
Revised: The first metric was chosen as an improvement over previous papers, which simply report the fraction of molecules which have at least one solution by a given time, which does not yield any insight about when within that time window solutions were found.

Original: The second metric was chosen to represent route diversity.
Revised: The second metric was chosen to represent route diversity.

Original: Althoughchemists generally want CASP algorithms to propose multiple diverse synthesis routes, most previousworks have not evaluated diversity.
Revised: Although chemists generally want CASP algorithms to propose multiple diverse synthesis routes, most previous works have not evaluated diversity.

Original: Our metric, which specifically reports the number of synthesisroutes found at time t such that no molecules in any two synthesis routes overlap, was chosen basedon the diversity-metric guidance from Xie et al.
Revised: Our metric, which specifically reports the number of synthesis routes found at time t such that no molecules in any two synthesis routes overlap, was chosen based on the diversity-metric guidance from Xie et al.

Original: Among other things, this measure of diversityguarantees that adding an additional solution to an existing set of solutions will never result inthe diversity decreasing: a property which does not hold for other proposed measures of diversity 
Revised: Among other things, this measure of diversity guarantees that adding an additional solution to an existing set of solutions will never result in the diversity decreasing: a property which does not hold for other proposed measures of diversity [Genheden and Bjerrum, 2022].

Original: Use of caching.
Revised: Use of caching.

Original: When calculating the metrics above, we have followed previous works in usingthe number of calls to the reaction model as a measure of time, since this tends to be the mostcomputationally-intensive part of the search.
Revised: When calculating the metrics above, we have followed previous works in using the number of calls to the reaction model as a measure of time, since this tends to be the most computationally-intensive part of the search.

Original: However, unlike previous works, we use a cache forthe reaction model, meaning that after the reactions for a molecule M are predicted once, if M isencountered again its reactions are retrieved from the cache instead of calling the model.
Revised: However, unlike previous works, we use a cache for the reaction model, meaning that after the reactions for a molecule M are predicted once, if M is encountered again its reactions are retrieved from the cache instead of calling the model.

Original: This may sound like a minor implementation detail, but it actually has a significant impact on the evaluation.
Revised: This may sound like a minor implementation detail, but it actually has a significant impact on the evaluation.

Original: Often very large sub-trees can occur in multiple places during search: 1 without a cache, expandingeach occurrence of these subtrees will count against an algorithm’s time budget, whereas with a cachethese expansions are effectively free.
Revised: Often very large sub-trees can occur in multiple places during search: 2 without a cache, expanding each occurrence of these subtrees will count against an algorithm’s time budget, whereas with a cache these expansions are effectively free.

Original: Given that any realistic implementation of these algorithmswould use caching to minimize computational cost, we think that it is important to use caching whenmaking any sort of real-world comparison between algorithms.
Revised: Given that any realistic implementation of these algorithms would use caching to minimize computational cost, we think that it is important to use caching when making any sort of real-world comparison between algorithms.

Original: Experiments run.
Revised: Experiments run.

Original: For all experiments, each algorithm is allowed to run for a maximum of 300 son each molecule tested.
Revised: For all experiments, each algorithm is allowed to run for a maximum of 300 s on each molecule tested.

Original: While previous papers tend to focus on a single testing setup (i.e. using asingle reaction model, set of purchasable molecules, and set of test molecules), we think that testingon multiple setups is helpful to obtain a comprehensive picture of the performance differences ofeach algorithm.
Revised: While previous papers tend to focus on a single testing setup (i.e. using a single reaction model, set of purchasable molecules, and set of test molecules), we think that testing on multiple setups is helpful to obtain a comprehensive picture of the performance differences of each algorithm.

Original: Therefore we use the following setups.
Revised: Therefore we use the following setups.

Original: Retro* Hard: 190 hard molecules used in Chen et al.
Revised: Retro* Hard: 190 hard molecules used in Chen et al.

Original: [2020], using the reaction model andset of purchasable molecules from Chen et al.
Revised: [2020], using the reaction model and set of purchasable molecules from Chen et al.

Original: PaRoutes: 200 randomly chosen molecules from the n = 5 setting of PaRoutes [Genhedenand Bjerrum, 2022], using their pre-trained reaction model as the policy for each algorithm.3.
Revised: PaRoutes: 200 randomly chosen molecules from the n = 5 setting of PaRoutes [Genheden and Bjerrum, 2022], using the associated pre-trained reaction model as the policy for each algorithm and the associated set of purchasable molecules.

Original: ChemBL Hard: 200randomly chosen “hard” molecules chosen  from  the ChemBL dataset,with the reaction model and purchasable molecules from Chen et al.To create a set
Revised: ChemBL Hard: 200 “hard” molecules chosen randomly from a subset of the ChemBL dataset, with the reaction model and purchasable molecules from Chen et al.

Original:  of molecules equally or more challenging than the Retro* set,  molecules were chosen byapplying the pre-processing script from [Brown et al., 2019], keeping only molecules whosemolecular weight, Bertz coefficient, logP and TPSA were larger  the mean of the respectivevalues in the Retro* hard set, and removing all purchasable molecules.
Revised: To create a set of molecules equally or more challenging than the Retro* set, the subset of molecules was chosen by applying the pre-processing script from [Brown et al., 2019], keeping only molecules whose molecular weight, Bertz coefficient, logP and TPSA were larger than the mean of the respective values in the Retro* hard set, and removing all purchasable molecules.

Original: GDB17: 200 randomly chosen molecules from gdb17 [Ruddigkeit et al., 2012], using thereaction model and set of purchasable molecules from Chen et al.
Revised: GDB17: 200 randomly chosen molecules from gdb17 [Ruddigkeit et al., 2012], using the reaction model and set of purchasable molecules from Chen et al.

Original: Summary.
Revised: Summary.

Original: Overall, the most important parts of our experimental procedure are:
Revised: Overall, the most important parts of our experimental procedure are:

Original: [Figure] • Algorithm Implementation: [Figure] – All algorithms implemented by us in a similar way as part of a common code base.
Revised: • Algorithm implementation – All algorithms implemented by us in a similar way as part of a common code base.

Original: [Figure]

Original: – Use the same policies and value functions for all algorithms.
Revised: – Use the same policies and value functions for all algorithms.

Original: [Figure] • Analysis of performance[Figure] – Show when each algorithm finds a solution, not just whether a solution is found at anarbitrary end time.
Revised: • Analysis of performance – Show when each algorithm finds a solution, not just whether a solution is found at an arbitrary end time.

Original: [Figure]

Original: – Measure and evaluate diversity of routes found in a principled way– Use caching of the reaction model and account for this when measuring algorithmruntime.
Revised: – Measure and evaluate diversity of routes found in a principled way. – Use caching of the reaction model and account for this when measuring algorithm runtime.

Original: – Test in 4 different scenarios
Revised: – Test in 4 different scenarios.

Original:  Results and Discussion
Revised:  Results and Discussion

Original: The results from our experiments are summarized in Figure 1.
Revised: The results from our experiments are summarized in Figure 1.

Original: The most important observation inthis figure is the high amount of overlap between the evaluation metrics for all different algorithms.
Revised: The most important observation in this figure is the high amount of overlap between the evaluation metrics for all different algorithms.

Original: Looking at the left column, for all four test sets, the box plots for time of first solution for all differentalgorithms almost entirely overlap.
Revised: Looking at the left column, for all four test sets, the box plots for time of first solution for all different algorithms almost entirely overlap.

Original: Looking at the right column, for all test sets the algorithms allfind approximately the same number of non-overlapping routes, although they seem to find additionalroutes at slightly different rates (with no clear pattern across the different test sets).
Revised: Looking at the right column, for all test sets the algorithms all find approximately the same number of non-overlapping routes, although they seem to find additional routes at slightly different rates (with no clear pattern across the different test sets).

Original: This result mayseem surprising, because it directly contradicts the findings of Chen et al.
Revised: This result may seem surprising, because it directly contradicts the findings of Chen et al.

Original: [2020], who report that
Revised: [2020], who report that

Original: MCTS performs far worse than Retro*.
Revised: MCTS performs far worse than Retro*.

Original: However, our findings are very similar to those of Genhedenand Bjerrum [2022], who also report very little difference between MCTS and Retro*.
Revised: However, our findings are very similar to those of Genheden and Bjerrum [2022], who also report very little difference between MCTS and Retro*.

Original: [Figure]
Revised: [Figure]

Original: Further examining Figure 1 yields several additional insights:
Revised: Further examining Figure 1 yields several additional insights:

Original: • Difficulty of different test sets: The easiest set seems to be that of PaRoutes [Genheden and Bjerrum, 2022], where all algorithms find a solution for 75% of the test molecules withinjust 10 calls to the reaction model.
Revised: • Difficulty of different test sets : The easiest set seems to be that of PaRoutes [Genheden and Bjerrum, 2022], where all algorithms find a solution for 75% of the test molecules within just 10 calls to the reaction model.

Original: The hardest set seems to be GDB17, where over 75%of the molecules are not solved at all.
Revised: The hardest set seems to be GDB17, where over 75% of the molecules are not solved at all.

Original: The Retro* Hard and ChemBL Hard test sets are somewhere in between.
Revised: The Retro* Hard and ChemBL Hard test sets are somewhere in between.

Original: • Effect of the value function:
Revised: • Effect of the value function:

Original: Comparing each algorithm run with a constant value function (C) to that same algorithm run with a neural network value function (V) reveals that thevalue function seems to help, but only slightly.
Revised: Comparing each algorithm run with a constant value function (C) to that same algorithm run with a neural network value function (V) reveals that the value function seems to help, but only slightly.

Original: This is most visible on the Retro* Hard test set.
Revised: This is most visible on the Retro* Hard test set.

Original: It is consistent with the results reported by Chen et al.
Revised: It is consistent with the results reported by Chen et al.

Original: [2020] that setting the value function to 0 for all molecules resulted in only a mild decrease in performance.
Revised: [2020] that setting the value function to 0 for all molecules resulted in only a mild decrease in performance.

Original: We also analyzed the results measuring time instead by wall-clock time (Figure 2) and by number ofcalls to the value function (Figure 3).
Revised: We also analyzed the results measuring time instead by wall-clock time (Figure 2) and by number of calls to the value function (Figure 3).

Original: In general, the conclusions measuring time with wall-clock arevery similar to those measuring time with number of calls to the reaction model: perhaps unsurprisingsince calling the reaction model is the most time-consuming part of search.
Revised: In general, the conclusions measuring time with wall-clock are very similar to those measuring time with number of calls to the reaction model: perhaps unsurprising since calling the reaction model is the most time-consuming part of search.

Original: However, when time ismeasured by number of calls to the value function, Retro* is decisively worse than MCTS: solutionsare found later, and fewer solutions are generally found by any given time.
Revised: However, when time is measured by number of calls to the value function, Retro* is decisively worse than MCTS: solutions are found later, and fewer solutions are generally found by any given time.

Original: We believe this isbecause for MCTS, only a handful of molecules are evaluated after the reaction model is run (since asingle random action is taken), however for Retro* all molecules produced by the value function areevaluated with the reaction model (because the minimum cost path must be computed).
Revised: We believe this is because for MCTS, only a handful of molecules are evaluated after the reaction model is run (since a single random action is taken), however for Retro* all molecules produced by the value function are evaluated with the reaction model (because the minimum cost path must be computed).

Original: This suggeststhat Retro* would not perform well if an expensive value function were used (e.g. rollouts).
Revised: This suggests that Retro* would not perform well if an expensive value function were used (e.g. rollouts).

Original:  Conclusions and Future Work
Revised:  Conclusions and Future Work

Original: After a careful re-implementation of existing methods, our main finding in Section 3 is that theperformance of different CASP algorithms is much more similar than previously reported.
Revised: After a careful re-implementation of existing methods, our main finding in Section 3 is that the performance of different CASP algorithms is much more similar than previously reported.

Original: Thisseems to suggest either that newer algorithms are needed to improve upon the deficiencies of existingalgorithms, or that the choice of search algorithm is less important than previously thought – perhapsthe most important choice is a good policy and value function.
Revised: This suggests either that new algorithms are needed to improve upon the deficiencies of existing algorithms, or that the choice of search algorithm is less important than previously thought – perhaps the most important choice is a good policy and value function.

Original: Future work will include addingadditional algorithms such as proof number search [Kishimoto et al., 2019] to the benchmark, andexpanding our evaluation metrics to also include route quality
Revised: Future work will include adding additional algorithms such as proof number search [Kishimoto et al., 2019] to the benchmark, and expanding our evaluation metrics to also include route quality.

Revised: Acknowledgments and Disclosure of Funding

Revised: We want to thank Jose Jimenez-Luna for help with the computing cluster and Tao Qin for helpful discussions.

Revised: Austin Tripp acknowledges funding via a C T Taylor Cambridge International

Revised: Scholarship.

Original: A Details on Algorithm Implementations
Revised: A Details on Algorithm Implementations

Original: All code was written in python.
Revised: All code was written in python.

Original: For retro*, the cost of all reactions was the negative log probabilityfrom the template classifier, as in [Chen et al., 2020].
Revised: For Retro*, the cost of all reactions was the negative log probability from the template classifier, as in [Chen et al., 2020].

Original: The constant value function was given avalue of 0, and the outputs of the neural network value function was used without adjustment.
Revised: The constant value function was given a value of 0, and the outputs of the neural network value function was used without adjustment.

Original: Forboth AND/OR and OR MCTS, the P-UCT bound function from Segler et al.
Revised: For both AND/OR and OR MCTS, the P-UCT bound function from Segler et al.

Original: [2018] was used with
Revised: [2018] was used with

Original: C = 10 , and P values obtained by applying softmax normalization to the log probabilities from thetemplate classifier with a softmax temperature T = 3 .
Revised: C = 10 , and P values obtained by applying softmax normalization to the log probabilities from the template classifier with a softmax temperature T = 3 .

Original: The values of T and C were chosen from ahyperparameter sweep on a small set of sample molecules.
Revised: The values of T and C were chosen from a hyperparameter sweep on a small set of sample molecules.

Original: The constant value function had a valueof 0 . 5 , and the values from the neural network value function were adjusted by f ( x ) =
Revised: The constant value function had a value of 0 . 5 , and the values from the neural network value function were adjusted by f ( x ) =

Original: exp ( − x )(because this neural network predicts a cost , it needed to be adjusted so that higher cost implied lowervalue).
Revised: exp ( − x ) (because this neural network predicts a cost , it needed to be adjusted so that higher cost implied lower value).

Original: To prevent infinite expansion, the search trees for all algorithms were limited to a maximumdepth of 20 for all tree types.
Revised: To prevent infinite expansion, the search trees for all algorithms were limited to a maximum depth of 20 for all tree types.

Original: AND/OR MCTS is a simple variant of MCTS on AND/OR tree.
Revised: AND/OR MCTS is a simple variant of MCTS on AND/OR tree.

Original: Like OR MCTS, it is an iterativealgorithm where one starts at the root node, descends the tree to a leaf node, either expands orevaluates this node, then propagates a series of values upwards.
Revised: Like OR MCTS, it is an iterative algorithm where one starts at the root node, descends the tree to a leaf node, either expands or evaluates this node, then propagates a series of values upwards.

Original: At an OR node, an AND node isselected using the same P-UCT method as in OR MCTS (whichever node has the highest value +exploration bound).
Revised: At an OR node, an AND node is selected using the same P-UCT method as in OR MCTS (whichever node has the highest value + exploration bound).

Original: At an AND node, all of its children are visited, and the value propagated upwardsis the minimum value of the children.
Revised: At an AND node, all of its children are visited, and the value propagated upwards is the minimum value of the children.

Original: This is the key difference to normal MCTS, where only a singlechild of one node is visited.
Revised: This is the key difference to normal MCTS, where only a single child of one node is visited.

Original: B Additional Results
Revised: B Additional Results

Original: [Figure] [Figure]
Revised: [Figure] [Figure]