Change forwards -> forward

Author: hyanwong

completing_forward_sims.md

@@ -9,20 +9,20 @@ kernelspec:
   name: python3
 ---
 
-(sec_completing_forwards_simulations)=
+(sec_completing_forward_simulations)=
 
-# Completing forwards simulations
+# Recapitation: completing a forward simulation
 
-The ``msprime`` simulator generates tree sequences using the backwards in
-time coalescent model. But it is also possible to output tree sequences
-from [forwards-time](https://doi.org/10.1371/journal.pcbi.1006581)
+The ``msprime`` simulator generates tree sequences using the
+backward-in-time coalescent model. But it is also possible to output tree sequences
+from [forward-time](https://doi.org/10.1371/journal.pcbi.1006581)
 simulators such as [SLiM](https://messerlab.org/slim)
 and [fwdpy11](https://fwdpy11.readthedocs.io/) (see the
 {ref}`sec_tskit_forward_simulations` tutorial).
 There are many advantages to using forward-time simulators, but they
 are usually quite slow compared to similar coalescent simulations. In this
 section we show how to combine the best of both approaches by simulating
-the recent past using a forwards-time simulator and then complete the
+the recent past using a forward-time simulator and then complete the
 simulation of the ancient past using ``msprime``. (We sometimes refer to this
 "recapitation", as we can think of it as adding a "head" onto a tree sequence.)
 
@@ -133,9 +133,10 @@ coalesced_ts = msprime.sim_ancestry(
 coalesced_ts.draw_svg()
 ```
 
-The trees have fully coalesced and we've successfully combined a forwards-time
+The trees have fully coalesced and we've successfully combined a forward-time
 Wright-Fisher simulation with a coalescent simulation: hooray!
 
+(sec_completing_forward_simulations_input_roots)=
 
 ## Why keep input roots (i.e., the initial generation)?
 
@@ -164,7 +165,7 @@ the method presented here.
 
 ## Topology gotchas
 
-The trees that we output from this combined forwards and backwards simulation
+The trees that we output from this combined forward and backward simulation
 process have some slightly odd properties that are important to be aware of.
 In the example above, we can see that the old roots are still present in both trees,
 even through they have only one child and are clearly redundant.
@@ -179,7 +180,7 @@ they may cause problems:
 2. If you are computing the overall tree "height" by taking the time of the
    root node, you may overestimate the height because there is a unary edge
    above the "real" root (this would happen if one of the trees had already
-   coalesced in the forwards-time simulation).
+   coalesced in the forward-time simulation).
 
 For these reasons it may be better to remove this redundancy from your
 computed tree sequence which is easily done using the

forward_sims.md

@@ -25,7 +25,7 @@ along with their genomes, storing inherited genomic regions as well as the full
 The code in this tutorial is broken into separate functions for clarity and
 to make it easier to modify for your own purposes; a simpler and substantially
 condensed forward-simulator is coded as a single function at the top of the
-{ref}`sec_completing_forwards_simulations` tutorial.
+{ref}`sec_completing_forward_simulations` tutorial.
 
 :::{note}
 If you are simply trying to obtain a tree sequence which is
@@ -210,7 +210,7 @@ that the child inherits a mosaic of the two genomes present in each parent.
 
 The exact details of the mosaic will depend on the model of recombination you
 wish to implement. For instance, a simple model such as that in the
-{ref}`sec_completing_forwards_simulations` tutorial might assume exactly one
+{ref}`sec_completing_forward_simulations` tutorial might assume exactly one
 crossover per chromosome. A complex model might allow not just multiple
 crossovers with e.g. recombination "hotspots", but also non-crossover events
 such as {ref}`msprime:sec_ancestry_gene_conversion`.
@@ -475,7 +475,7 @@ in which an alternative technique, such as backward-in-time coalescent simulatio
 is used to to fill in the "head" of the tree sequence. In other words,
 we can use a fast backward-time simulator such as `msprime` to simulate the
 prior genealogy of the oldest nodes in the simplified tree sequence.
-Details are described in the {ref}`sec_completing_forwards_simulations`
+Details are described in the {ref}`sec_completing_forward_simulations`
 tutorial.
 
 ## More complex forward-simulations

more_forward_sims.md

@@ -254,5 +254,5 @@ This will primarily deal with sites and mutations (and mutational metadata).
 We could also include details on selection, if that seems sensible.
 
 The section in that workbook on "Starting with a prior history" should be put in
-the {ref}`sec_completing_forwards_simulations` tutorial.
+the {ref}`sec_completing_forward_simulations` tutorial.
 :::

simulation_overview.md

@@ -44,29 +44,29 @@ Compare to expectations
 (e.g. for use as a null model). For instance,  comparison to *neutral* simulations
 can be used to identify regions subject to selection.
 
-There are two major forms of population genetic simulation: **forwards-time**
-and **backwards-time**. In general, forwards-time simulation is detailed and more
-realistic, while backwards-time simulation is fast and efficient.
+There are two major forms of population genetic simulation: **forward-time**
+and **backward-time**. In general, forward-time simulation is detailed and more
+realistic, while backward-time simulation is fast and efficient.
 
 More specifically, apart from a
 {ref}`few exceptions <msprime:sec_ancestry_models_selective_sweeps>`,
-backwards-time simulations are primarily focused on neutral simulations, while
+backward-time simulations are primarily focused on neutral simulations, while
 forward simulation is better suited to complex simulations, including those involving
 selection and continuous space.
 
 ## Advantages of tree sequences
 
-Some forwards-time ([SLiM](http://messerlab.org/slim/),
-[fwdpy](http://molpopgen.github.io/fwdpy/)) and backwards-time
+Some forward-time ([SLiM](http://messerlab.org/slim/),
+[fwdpy](http://molpopgen.github.io/fwdpy/)) and backward-time
 ([msprime](https://tskit.dev/msprime)) simulators have a built-in capacity to output
 tree sequences. This can have several benefits:
 
 1. Neutral mutations, which often account for the majority of genetic variation, do not
     need to be tracked during the simulation, but can be added afterwards. See
     "{ref}`sec_tskit_no_mutations`".
-2. Tree sequences can be used as an interchange format to combine backwards and
-    forwards simulations, allowing you to take advantage of the advantages of both
-    approaches. This is detailed in {ref}`sec_completing_forwards_simulations`.
+2. Tree sequences can be used as an interchange format to combine backward and
+    forward simulations, allowing you to take advantage of the advantages of both
+    approaches. This is detailed in {ref}`sec_completing_forward_simulations`.
 
 ## Some tips on simulation
 

terminology_and_concepts.md

@@ -145,7 +145,7 @@ objects. In tree sequences, however, all nodes, both internal and terminal,
 are represented by an **integer ID**, unique over the entire tree sequence, and which exists
 at a specific point in time. A branch point in any of the trees is associated with
 an *internal node*, representing an ancestor in which a single DNA
-sequence was duplicated (in forwards-time terminology) or in which multiple sequences
+sequence was duplicated (in forward-time terminology) or in which multiple sequences
 coalesced (in backwards-time terminology).