{'fraction_non_alphanumeric': 0.03499065604406413, 'fraction_numerical': 0.007253860529162978, 'mean_word_length': 4.201969813251471, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Abstract Geometrical Computation 11: Slanted Firing Squad Synchronisation on Signal Machines

Firing Squad Synchronisation on Cellular Automata is the dynamical synchronisation of finitely many cells without any prior knowledge of their range. This can be conceived as a signal with an infinite speed. Most of the proposed constructions naturally translate to the continuous setting of signal machines and generate fractal figures with an accumulation on a horizontal line, i.e. synchronously, in the space-time diagram. Signal machines are studied in a series of articles named Abstract Geometrical Computation. In the present article, we design a signal machine that is able to synchronise/accumulate on any non-infinite slope. The slope is encoded in the initial configuration. This is done by constructing an infinite tree such that each node computes the way the tree expands. The interest of Abstract Geometrical computation is to do away with the constraint of discrete space, while tackling new difficulties from continuous space. The interest of this paper in particular is to provide basic tools for further study of computable accumulation lines in the signal machine model.


Introduction
The Firing Squad Synchronisation Problem (FSSP) is as follows: a general wants a whole line of riflemen to fire synchronously. However, communication is only between very close individuals and the number of riflemen is unknown. There is no global time, but everyone receives ticks simultaneously and repeatedly. Moreover, it is supposed that the number of states of each rifleman is finite. Finite state, discrete space and time, synchrony and uniformity correspond to the Cellular Automata (CA) model. In this context, the goal is, starting from a single activated cell, to reach a configuration in which all cells of a given region are in a special firing state simultaneously and for the first time.
This problem have been studied from the 1960's [9,17,20], with a wide range of construction [3,15,16] and is still active nowadays [10,11,12,13,19,21]. In [15], a six-state minimal time solution is given. Solutions to this problem also often serve as a tool to solve other problems. In [3] a variation with two generals is used to solve a related complexity problem. In [18], the election leader problem, which can be seen as a reversed FSSP is solved efficiently for any finite dimension. In [14], FSSP is used on demand to synchronise computation steps.
The most common solutions involve signals sent at different speeds bouncing onto the edges of the line and sprouting new signals whenever crossing each other in such a way that signals eventually and simultaneously evenly fill the line which triggers the firing. A tree structure often appears in the construction. These trees are rooted in the general and the leaves reach the firing riflemen. Very commonly, the solutions are presented in a continuous setting, then adapted to the discrete space and time of CA; reaching the granularity of space (i.e. cells) indicates when to fire.
It appears natural to consider this problem in the continuous setting of Abstract geometrical computation: the study of computing in an euclidean space with geometrical tools. It is done using signal machines, which compute by drawing coloured lines which interact in specific ways upon collision. It lead to a series of articles, for example, isolated accumulations on single point are characterised in [7].
Signal machines are an abstraction of 1D CA: signals carrying a given label travel at a given speed through a continuous space; any collision between two or more signals results in the vanishing of incoming signals, and the emergence of new ones, according to their labels and to some predefined rules. Figure 1a provides some space-time diagram of an example signal machine (time elapses upward). Signal machines are defined by meta-signals that define signals, and collision rules, that define their interactions; for example, the space-time diagram in Fig. 1b was obtained with a machine with meta-signals zig , zag, le and ri, as well as the collision rules {zig ,ri} → { zag,ri} and { zag,le} → {zig ,le}.
Compared to CA, there is no underlying grid and only signal dynamics is addressed. The continuous time and space allow phenomena alien to CA: accumulation as illustrated in Fig. 1b: there are infinitely many collisions leading to the top of the triangle. It is already known that forecasting of any accumulation on rational signal machines is highly unpredictable [5] and the possible localisation of isolated accumulation of such machines have been characterised [8].  Most of the schemes used for FSSP in CA can be defined directly as signals machines (but going from there to a CA is no triviality [1]). In CA, the construction stops when the granularity of space is reached. In the continuous setting of signal machines, there is no such a thing so that the divide and conquer process never stops and generates a fractal. The result, a horizontal firing line in a space-time diagram, consists of an accumulation line as in Fig. 1c (each colour corresponds to one meta-signal, speed magnitudes are 0, 1 or 3, such that red and blue signals form an infinite binary tree). That is a line of points nearby which an infinity of signal collisions happen (the continuous equivalent of filling a discrete line with signals). Such a construction with a finite yet unbounded binary tree has been used in [4] to provide unbounded branching to solve PSPACE-complete problems with polynomial depth.
The accumulation line in the space-time diagram needs not be horizontal although there are not much research on the matter since, in the more usual discrete settings, synchronisation is the goal and slope is less meaningful. Achieving a given slope would correspond to riflemen firing in succession at a predefined rate. Much like the regular FSS problem is about synchrony, our Slanted FSS problem is about coordination. Its solution could be used to as a tool for problems requiring tasks to be done in a quick succession-too quick for the end of a task to trigger the beginning of the next one; for example sending self driving cars through an intersection with shorter security distances than possible using uncoordinated human drivers.
In the present paper, we prove that not only it is possible to generate any segment of any non-infinite slope as an accumulation set but moreover that they can all be generated by the same signal machine. Without loss of generality, we aim at segment with extremities at abscissa −1 and +1. The target segment is encoded in the initial configuration: the ordinates (the times) of the extremities are encoded as distance between signals.
The idea is to draw an infinite unary-binary tree in a finite amount of space, halving the size of edges after each node with two children. The structure of the tree dictates the shape of the accumulation set. As in [4], the tree structure conveys some information used to extend the tree: with sign test, addition and subtraction (on real numbers) primitives, each node computes whether to delay or split and updates and broadcasts the information. These primitives are also part of the linear version of the Blum, Shub and Smale model of computation [2] witch is related to Signal Machines [6].
Unary-binary tree is one of the many possible constructions that can fulfil our goal, we chose it for its simplicity, with complete disregard for time minimality or optimisation of the number of meta-signals or collision rules -corresponding notions to states and rule of a cellular automaton.
The algorithm is first implemented on an augmented signal machine to allow the signals in the tree to carry an unlimited quantity of information. This allows to concentrate on the algorithm without dealing with technical details. Then these augmented signals are encoded as a ray of signals on an ordinary signal machine and needed arithmetic operations are implanted. This is much more involving because it has to deal with updating the information now encoded with only finitely many possible signals.
The paper is organised as follows. The relevant definitions are provided in Sect. 2. The algorithm is explained in Sect. 3 and implemented on augmented signal machines in Sect. 4. This is then implemented on ordinary signal machine in Sect. 5. Section 6 concludes the paper.

Signal machines
A signal machine regroups the definitions of its meta-signals and their dynamics: constant speed outside of collisions and rewriting rules at collisions.
A signal machine is a triplet (M, S, R) such that: -M is a finite set, whose elements are called meta-signals; -S : M → R is the speed function (each meta-signal has a constant speed); -R is a finite set of collision rules; a collision rule ρ can be written ρ − → ρ + , and consists in an input set ρ − and an output set ρ + of meta-signals of distinct speeds, with ρ − containing at least two meta-signals. R is deterministic: ρ = ρ implies that ρ − = ρ − . In the example in Fig. 1b, there are four meta-signals: zag, ri, le, and zig of speeds −1, −1/2, 1/2, and 1 respectively. The collision rules are {zig ,ri} → { zag,ri} and {le, zag} → {le,zig }.
A configuration, c, is a mapping from the points of the real line to either a meta-signal, a rule or the value (indicating that there is nothing there). There are finitely many non-locations in any initial configuration. There are 3 signals in the initial configuration in Fig. 1b, from left to right: le, zig , and ri.
A space-time diagram is the collection of configurations as time elapses. It forms a two dimensional picture (time is elapsing upwards in the figures). It is a function from A signal of a space-time diagram is a maximal segment or half-line mapped by the space-time diagram to a meta-signal µ and of inverse slope S(µ) (signals cannot be horizontal). Meta-signals can be thought of as type, and signals as instances of them. The meta-signal of a signal is also called its type for the sake of concision.
A space-time diagram follows the rules: -any point of the space-time diagram that maps to a meta-signal µ belongs to a signal which verifies: -its starting location is either a rule ρ with µ ∈ ρ + or a point of the initial configuration mapping to µ and -its end, if any, is a rule ρ with µ ∈ ρ − ; -any point of the space-time diagram with a collision of rule ρ is at: -the starting end of one signal of type µ for every µ in ρ + and -the ending end of one signal of type µ for every µ in ρ − (if not in the starting configuration); -there is no infinite time-backward continuous path/sequence of signals each of whose start is the end of the next. This ensures that signals propagate with uniform speed, collision rules are properly applied and no signal nor collision appears out of the blue. In particular we do not want anything appearing from accumulation points as defined below.

Accumulation points
In the example in Fig. 1b, there is a special point on top such that there are infinitely many signals and collisions leading to it. The signal machine does not provide any definition for what happens there so that the space-time diagram cannot be defined for all times and locations. We extend the definition as follows: a space-time diagram is a partial function from R × R + to M ∪ R ∪ { , 5} where 5 is a new symbol introduced to designate accumulation points (and only such points). Outside of accumulation points, the constrains are as before but signals may also end in accumulations. Any accumulation point must be the forward limit of an infinite sequence of collision points.
The example in Fig. 1b is the simplest example of accumulation. There is only one point valued 5; the rest of the space-time diagram is . In the example of Fig. 1c, a connected accumulation set (a line segment) is generated.

Augmented signal machines
Augmented Signal Machines (ASM) are natural extensions of signal machine where signals are allowed to carry analog information.
An augmented signal machine is a triplet (M, S, R) such that: -M is a finite set of meta-signals; -S : M → R is the speed function; -each µ in M has an associated set, called domain and noted D µ : signals may carry information depending on their type; -the set of augmented meta-signals is M = {(µ, x)|µ ∈ M, x ∈ D µ }. The speed of an augmented meta-signal is simply the speed of its corresponding meta-signal; -R is a set of collision rules; a collision rule ρ can be written ρ − → ρ + , and consists in an input set ρ − and an output set ρ + of augmented meta-signals of distinct speeds, with ρ − containing at least two augmented meta-signals. R is deterministic. Configurations, diagrams, augmented signals and accumulation points are defined the same way as for regular signal machines, replacing meta-signals by augmented meta-signals.
A signal machine is a special case of augmented signal machine where every D µ is a singleton (or a finite set). In this paper, domains are either singletons or subsets of R 2 . We thus note augmented meta-signals µ when D µ is a singleton, and otherwise we note µ r l instead of (µ, (l, r)). Since there are potentially infinitely many rules for an augmented signal machines, we define several of them at a time through parameterized patterns: X C − → Y where X is a left member of a rule containing free variables, C is a condition on them and Y is a right member which might also depend on them. Concrete examples of rule pattern are given in Sect. 4.

Slanted Firing Squad Synchronization Problem
The goal of the Firing Squad Synchronization Problem (FSSP) on signal machines is to design a machine and an initial configuration which create an horizontal line as the set of accumulation points of the corresponding space-time diagram.
Formally, a solution of the FSSP is a signal machine together with an initial configuration composed of two border signals, a sequence of signals -called the general-along with the prescribed distance between them near the left border. If the width of the general is small enough relative to distance between border signals, there exists a time t l such that, in the resulting space-time diagram, the set of accumulation point is the horizontal segment of equation t = t l -within the boundaries.
The goal of the Slanted Firing Squad Synchronization Problem (SFSSP) for signal machines is to design a machine and an initial configuration which creates a slanted line as the set of accumulation points of the corresponding space-time diagram. In other words, looking at the firing line over time, we want the firing to happen in succession, as an apparent dot moving at a constant, specified speed. Since space-time diagram is a central piece of signal machines, we prefer the image of and the vocabulary related to a slanted line in a space-time diagram over those of a virtual moving dot.
Formally, a solution of the Slanted FSSP of slope α is again a signal machine and an initial configuration, such that -the initial configuration is composed of 2 static bounding signals (to delimit the firing line), one on the left border of the general, one far beyond the right border; -for all big enough ratio of width between the line and the general, there exists a time t l such that, in the resulting space-time diagram, the set of accumulation points is the slanted line segment of equation Conversely, instead of aiming at a big enough line, we can shrink the general. This is our approach in the rest of the paper and we fix the boundaries at −1 and 1.
Additionally and informally, a universal solution to the SFSSP is a single signal machine and a way to encode any given slope α into a general so as to solve the corresponding SFSSP.
In this paper, instead of aiming at a slope α, we aim at a segment [(−1, l), (1, r)] with l, r ≥ 1. This allows to solve for any slope, and gives perspective about drawing arbitrary segment or curve in the space-time diagram, while foregoing time-optimality.

General scheme and algorithm
The target segment and the parameters are depicted in Fig. 2a : parameters l and r are the ordinates of the extremities of the target segment. To be valid, the parameters have to be both at least 1.
The algorithm relies on a very simple divide and conquer strategy: to draw -accumulate on-the segment  Figure 2b illustrates this infinite recursion, with vertical segments drawn as dotted and black, and diagonal segments of slope + − 1 being drawn as red or blue, depending whether they go to the left or right (ascending) respectively. This colour code applies to section 4 as well. In the one entwined in Fig. 1c (looking only at red and blue signals), each node always have two descendants. The unary steps are used to provide delays and thus slope. Each (sub-)tree is bounded by two motionless signals as in figures 2c and 2d. When an update is carried out, the collision happens exactly at the middle of the bounds which are considered 2 units of space apart.  The following primitives are used to direct the dynamics in the algorithm: delay (l, r) : the current node is of degree 1. Its single child is 1 unit up and the algorithm is prompted with parameters (l, r). In Fig. 2b a delay corresponds to a dotted connections and split ((l, r),(l , r )) : the current node is of degree 2. The left child is at (−1/2, 1/2) relatively to the current node, the right child at (1/2, 1/2). In Fig. 2b, the links between the node and its children are red and blue. At each child, the algorithm is prompted with the scale reduce by a factor 2 and with the parameters (l, r) for the left one, and (l , r ) for the right one. Figure 2c outlines how a delay can be implemented by an augmented signal machine, with two auxiliary signals bouncing off the boundary at the correct speeds (3/2 for green and −3 for purple) to wait the correct amount of time. Figure 2d outlines how a split can be implemented, with auxiliary green signals of speed 3, and purple −3. Altogether, it yields the algorithm 1 where the tree is initialised with the "top level" l and r for the targeted final accumulation segment. The strategy is to delay whenever possible, i.e. when both extremities are at least 2 units above.
t a r g e t Nodes are called split or delay depending on the used primitive. There is no end to the recursion: the constructed unary-binary tree is infinite to produce the whole accumulations segment.

Correctness
The split nodes play a key role in the demonstration of the correctness of the algorithm. The depth of a collision is the number of its ancestors of degree 2 (i.e. split nodes). From now on, let d denotes the depth of a given collision and α denotes the slope of the targeted segment, that is (r 0 − l 0 )/2 where (r 0 , l 0 ) denotes the parameter at the root of the tree.
Lemma 1 (Invariants). Algorithm 1 satisfies the following invariants: 1. 1 ≤ l and 1 ≤ r (the parameters remain valid); 2. (r − l)/2 = α (slope is preserved); 3. the boundary points of the current targeted segment are on the initially targeted segment: assume the initial parameters are l 0 and r 0 , and consider a collision happening at (x, t), with parameters l, r. The points (x, t) + 2 −d (−1, l) and (x, t) + 2 −d (+1, r) are on the initial targeted segment. That is the segment with extremities (−1, l 0 ) and (1, r 0 ) Proof. The first two invariants are straightforward to prove from Algo. 1. Let us consider a node at (x, t) with parameters l, r (both at least 1). Let us prove the last invariant by induction. It is true for the root node. After a delay node: and similarly for r: the targeted segment extremities are unchanged.
After a split node: : the left extremity of the left new branch matches the left extremity of the formerly targeted segment. Since , the right extremity of the left new branch matches the middle of the formerly targeted segment. Proof is the same for the right branch.

Lemma 2.
A split collision at (x, t) happens before the point on the targeted segment at the same spatial location, but not sooner than 2 −d (2 + |α|) before. In other words: Proof. The second inequality is obvious. For the first one, we can observe that: (l + r)/2 = min{l, r} + |α|. Indeed, we have: 2 min{l, r} + |r − l| = 2 min{l, r} + max{l, r} − min{l, r} = min{l, r} + max{l, r} = l + r . We can then write: . Finally, since it is a split node, min{l, r} ≤ 2, yielding the desired inequality.
Let us note that any infinite branch of the tree contains infinitely many split . There are always infinitely many branching on both sides.
We remark that the set of abscissae of split nodes is exactly the set of dyadic rationals comprised strictly between −1 and 1, which is dense in [−1, 1]. Indeed, these are the number written Σ d Thus, there is a sequence of nodes (x d , t d ) d∈N such that: We can even take |x d − x| < 2 −d , and we do, for convenience.
Points above the targeted segment are not accumulation points as no node is above it, as shows Lem. 2 (delay nodes have to have a split heir above them, eventually). For a point below the accumulated segment, say by a amount ∆t, then, according to Lem. 2, there's a depth d big enough beyond which nodes are no lower than ∆t/2 below the accumulation segment.
All in all, the accumulation set is exactly the targeted segment.

ASM implementation
Each augmented meta-signal that will translate into a ray of regular signals has its name written slanted, whereas 'regular' ones that translate directly into the SM version in next section, like border, are upright.
The initial configuration starts with borders at −1 and +1 as shown in Fig. 2a. As mentioned, each sub-tree is bounded by a pair of border signals. Each time, we have to consider three cases depending on how the node was generated (unary, left or right binary). Figure 4 shows how a delay is implemented. It is initiated by a collision between a main (red, dotted black, or blue) which carries the values of l and r and an auxiliary signal (green or purple). At this collision, when both l and r are greater than 2, one augmented signal goes forth (green bounce sl , sl stands for slow) and back (purple bounce) to the border on the right. The amount of time waited is directly proportional to the width of the bounds, and with proper speeds the delay can be made half the width as desired. These speeds are given in the list of meta-signals in Fig. 6.  Auxiliary signals (bounce and the likes) bouncing off the borders is described by the collision rules in Fig. 7a. The last two rules deal with the case where two such signals bounce at the same point of the border from both sides.
The three rule patterns of Fig. 7b correspond to central collision in the three cases in Fig. 4. The left part of the rules corresponds to collisions happening at nodes (with respect to the simulated algorithm) prompted by a previous node accordingly -whether prompted by a delay , or either side of a split . The right parts of these rule patterns are the same: it is the signals necessary to perform a delay, i.e. to wait a unit of time. Figure 5 shows how a split is carried out: once again with green and purple signals bouncing off the walls, this time intercepting split signals half a unit of time later and in the middle of the new boundaries. The border created by a split ensures both sides of the computation start in the middle of their own borders and are kept separated. It also effectively scales these subsequent computations down by a factor of two. The three rule patterns of Fig. 7c correspond to central collision in the three cases in Fig. 5.

SM implementation
It is first presented how bouncing signals are handled and how augmented signals are encoded as macrosignals: coherent packs of parallel signals (also seen as rays) that can store the analogue information. The update and routing is then presented in three stages. The first stage tests whether the (next) step is delay   or split . The second stage is the routing in a macro-collision (coherent pack of collisions issued from a collision with one or more macro-signals, implement an augmented collision). The third stage is the updating of the parameters. Please note that the updating of parameters is started at the end of the routing macro-collision and that the test for next step is done right after. This ensures that the values are updated and the routing scheme is known before the next step starts.
For the sake of readability, signals that are redundant or irrelevant to the construction are often removed from schematic pictures. Figures without annotation (signal names) are generated through a Java SM simulator and are complete and thorough.
The colour scheme of these pictures is as follows: -border signals are black; -tree signals are blue -tree signals are those at the exact same position as the augmented signal in the augmented signal machine solution of Sect. 4; -tree macro-signals are filled with yellow; -bouncing signals are green, slow bouncing signals are green (and appear almost black in the generated pictures); -signals helping with the geometry of macro-collisions are orange; -purple, green and light green are used for computation within a macro-signal (in preparation for collision), with purple more often associated to testing and green to changing value; -other colours are used for more particular signals and explained in due time; -signals foreshadowing or helping to build a split are dashed; and -signals foreshadowing or helping to build a delay are dotted.
Although special care has been taken so that pictures remain readable in black and white.

ASM simulation structure
As in Sect. 4, the tree structure is built with the help of fast signals bouncing on borders. The initial configuration thus has two border signals, defining the unit of space.
The way the ASM is simulated by a SM is depicted in Fig. 8. The filled area corresponds to macro-signals and macro-collisions of the tree. This area is also used to carry out updating. The rest are regular signals used for constructing the delay and split steps as previously, but some are doubled to take the width of the macro-signals into account. As can be seen in Fig. 8, some meta-signals of the augmented signal machine implementation have to be doubled in order to deal with the width of the macro-signals. This is the case for bounce sl , bounce and bounce. For example, bounce is replaced by a pair (bounce top ,bounce bot ) where bounce top should be "above" bounce bot .
These fast signals as well as borders as well as relevant collision rules are defined in Fig. 9. These definitions are quite straightforward from the ASM definition and are not exemplified. Their actions can be seen in figures 8 and 28.  The height of the bouncing part, h b , and the width of the tree macro-signals, w t , verify: h b = w t on both output of split and h b = 4/3w t after delay . To keep coherence, the following updates are made through steps:

Meta-signal Speed
-through a split from a split , h b = 1/2h b and w t = 1/2w t , -through a split from a delay , h b = 1/2h b and w t = 3/8w t , -through a delay from a split , h b = 4/3w t , and -through a delay from a delay , unchanged. These remain coherent as long as the initial values are. Although the computations are not detailed here, these relations are satisfied by all the following constructions and can be checked from the speeds of the signals involved.

Encoding of macro-signals
The augmented signals percolating through the tree, delay r l , split r l and split r l , carry analogue information. Thus they have to be encoded as by macro-signals with multiple (regular) signals. The way they are encoded after an updating is depicted in Fig. 10. The sequence of parallel signals is to be understood as follows.
The tree (and variants) signals are at the exact locations of the augmented signals in the infinite tree. Then come signal one (brown) and signal two (orange) which provide the local scale. Values are encoded by the distance of the signal to tree (so 0 is at tree). Signal bound marks the other end of the macro-signal. These four signals are structural and not affected by the updating of the parameters.   The parameters l and r are encoded by l and r blue signals between one (included) and bound (excluded). Thanks to Lem. 2, all the values of the parameters are bounded by 2 + α from the start so that the scale can be set to ensure that l and r always remain between one and bound. If the value l (or r or both) is equal to 1 or 2, then a special signal is used that amount for the superposition. These special cases are straightforward and are not addressed anymore.
An extra signal with a different speed, test, initiates the test for the next step inside the macro-signal as presented later on. Other signals might be present inside the macro-signals to carry out the parameter updating. The scale is small enough to ensure that all involved signals remain between tree and bound during parameter updates and that any computation finishes before the next macro-collision starts. Throughout the updating, signals and positions changed, but the encoding remains similar.
Each macro-signal has the same speed as the augmented signal it encodes: 0 for delay r l as in Fig. 10a, 1 for split r l as in Fig. 10c and -1 for split r l as in Fig. 10b. The sequence of signals is displayed left to right except for split r l as in Fig. 10b. In the rest of this paper, meta-signals exclusively used to form macro-signal delay r l , split r l and split r l respectively carry no arrow, a right dotted arrow and a left dotted arrow, irrespective of their speeds and directions. For example one, one and one each encodes the position of scale 1, but in different macro-signals. Involved meta-signals (except test signals listed in the next section) are listed in Figure 11.

Test
The first stage is to test whether the next step is delay or split , i.e. whether l and r are both greater than or equal to 2. In order to do so with the encoding, starting from tree, the test is true if two is met before any l or r. So, as shown in Fig. 12, a purple test signal starts from tree and turns to some signal recording whether the next node ought to be delay (test dl , dotted) or split (test sp , dashed). The information is then stored on the last signal bound, which becomes bound dl (dotted) or bound sp (dashed) accordingly. All signals in the macro-signals are then parallel and nothing happens until the next macro-collision. Figures 12a and 12b provide an example where the test lead to delay while Fig. 12c provides one leading to split .
The meta-signals and collision rules at play are listed in Figure 13.

Rerouting
The second stage is the macro-collision started by either bounce bot or bounce bot colliding with the macrosignal. It amounts for the next tick of the clock: the time to start generating the next node of the tree.  Figure 12: Testing for the next step.
Collision rules with arrows are the same as without arrows. Duration of steps are handled by bouncing signals so that only the macro-collision is addressed. The cases of delay and split are considered one after the other. In each case, the previous node has to be considered.
Rerouting is done using common signal machine tools. In particular, a reflection is when each signal of a macro-signal bounce off a common signal at a common speed. A refraction is when each signal of a macro-signal takes a new common speed upon crossing a common signal. In both cases, parallelism ensures that the proportion between distances between signals remains unchanged.
Since signals one, two, l and r are only rerouted and each in the same fashion, in the schematic pictures, for the sake of clarity, only signal one is shown.

delay rerouting
At a delay step, the macro-signal is only straightened if it is not already vertical, and bouncing signals are sent.
delay rerouting from a delay . Since the macro-signal is already vertical, bouncing signals have to be sent back and the updating initiated. This is done as in Fig. 14: upon crossing bound dl , the bottom bouncing signal bounce bot takes note that the next intersection is a delay , becoming bounce dl . It then simply bounces off tree, becoming the slower bounce bot sl . While bouncing, it also turns tree into tree dl , indicating the top bouncing signal to just bounce back. When leaving, the signal bounce top sprouts a signal updt * dl which will start the updating (parameter update then test) within the macro-signals on meeting tree.
Signals like one are unaffected and just pass through the macro-collision.
delay rerouting from a right branch of a split . If the macro-signal comes from the left, it goes first through a refraction on wall dl and then a refraction on bounce dl , as in Fig. 15 to ensure the correct scaling of the macro-signal (the two refraction are more visible on Fig. 24b). The intermediate speed is such that the width of the macro-signal is halved. Again, information about the next step is carried on the bound side of the macro-signal, by bound dl . The output of the starting collision (between bounce bot and tree) contains three signals: A vertical signal tree dl that refracts signal in the band once. A signal bound sdl that is the diffraction of the bound signal, and still carries the delay information; that way, bounce top can become bounce dl and handles the second refraction . A signal bounce s that, upon intersecting with bounce top , can start bounce bot sl at the correct place. delay rerouting from a left branch of a split . The macro-signal comes from the right, it first undergoes a reflection on wall dl , then a refraction on bounce dl , as shown in Fig. 16 (it is more visible on Fig. 24c). Once again, the intermediate speed is such that the width of the macro-signal is halved. So after the first reflection everything behaves the same way than after the first refraction when coming from the left. The reason for using a reflection is the following: information on the next step is carried on the bound side of the macro-signal (bound dl ) and has to be below (before) tree; this is why a leftward macro-signal is a mirror image of a rightward macro-signal, rather than a mere slanting of a vertical macro-signal -in other words the bound is on the left.
Without a bounce top to handle the refraction , we need another signal, dsep 2 (orange) coming from somewhere else. A dsep 1 (orange as well) signal is thus launched at the bottom intersection with a default fast speed of −3. It intersects the bounce top signal and sprout dsep 2 . The dsep 2 signal in turn has a finely tuned speed so as to intersect with bounce s at the right time and place. There, a bounce top is sprouted as if it came from the right and handles the refraction .
The new meta-signals and collision rules involved are listed in Figure 17.

Split Rerouting
At a split step we need to fork the macro-signal, and go half a unit of space both ways during half a unit of time (again using bouncing signals). Forking is done by sending a copy of each side (with corresponding orders of signals inside the new macro-signals) and adding a motionless border signal, so as to set border and scale for the new branches.
split rerouting from a split . Routing from each branch is done symmetrically (as can be seen in Figs. 27b and 27c) so only one case is presented. Forking the macro-signal from the right branch of a split is done by raising a vertical signal wall sp on which the macro-signal gets duplicated as can be seen in Fig. 18. The duplication can be viewed as a simultaneously operating a reflection and a refraction on the macro-signal. Both branches are then routed and their widths are halved in the process. The meta-signals and collision rules at play are listed in Fig. 19.  split rerouting from a delay . If the previous step is a delay , the construction, shown in Fig. 20, is more involving. Again this is due to the difference of orientation between the signals in a leftward band and a straight one. The right part of the collision output is obtained by a simple refraction on signal bounce 1 sp . The left part is obtained through a refraction by sep 1 , a reflection on bound 1 and a refraction on The new meta-signals and collision rules at play are listed in Fig. 21.  Figure 21: Definitions for split routing after a delay .

Updating the parameters
The updating of parameters is done according to Algo. 1. It occurs right after a macro-collision and depends on its nature.

delay parameter update
The updating is done by removing 1 from both l and r as depicted in Fig. 22. This corresponds to a shift of l and r by the distance from tree to one. For l, this is done by constructing a parallelogram with one side going from one to tree and the opposite side from l to its updated position. Parallel lines simply correspond to signals with the same speed (one back and r back , and updt 2 dl and minus 2 ). Signal r is shifted similarly. After that, the signal test start is generated and sent to collide tree to generate test to start the test sequence as seen previously.
The new meta-signals and collision rules used in 22 are listed in Fig. 23. The signals updt 2 dl and updt 1 dl (as well as minus 2 and minus 1 ) are used to count down before disappearing after meeting both l and r (in whatever order). A full delay step, that is rerouting and parameter update, is performed as shown in Fig. 24.  Collision rules with arrows are the same as without arrows.

split parameter update
The updating on the right (resp. left) branch of a split is illustrated by Fig. 25 and done as follows: r (resp. l) is added to both l and r; then 1 is removed from both l and r. What happens on the right and on the left branch is symmetrical with the roles of l and r swapped; so that only what happens on a right branch is presented.
Adding r to both l and r is done by moving l and r by the distance from tree to r (again using a parallelogram). The computing signals bounce back to tree after measuring that distance and before adding it so that the construction does not depend on the order of l and r. The new meta-signals and collision rules at play are listed in Fig. 26.
The computation is finished by removing 1 and starting the test stage. This is done exactly as in the parameter update occurring after a delay step. The (dotted arrow) meta-signals and collision rules are already defined in Fig. 23.

Conclusion
We provide a recursive geometrical algorithm to draw an infinite tree accumulating on a parameterised slope together with its proof and its implementation as a signal machine. An extended run on a signal machine can be seen in Fig. 28, with l = 150/113 and r = 200/101.
By comparison with cellular automata, the active signals (the general) start on an arbitrarily small area. It corresponds to the single active cell at the start in cellular automata.
It takes several signals to code any slope with finitely many meta-signals. It is possible to shrink the general to a single point and do similar construction to ours (for example by building bands of signals such as our). There would, however, be only one attainable slope per general (assuming its position is fixed), and finitely many per signal machine (since point generals are one of finitely many meta-signals).
An important model that appears in the current construction is the augmented signal machine. It allows to construct and prove at some level, leaving only "technicalities" to simulate with a usual signal machine (using macro-signals and macro-collisions). These technicalities can be involving by themselves.
Our construction exhibits rational robustness: if the signal speed and initial positions are rational, so will be the targeted slope. Further more the tree drawn is fractal (can be recursively defined) if and only if l and r are rational numbers. Indeed, if say, l is irrational, then the path from the general to (−1, l) is made of a non-periodic sequence of delay and split . If l and r are rational, then one can show the set of reachable parameters is finite by observing the invariant: there is some positive integer m (the least common multiple of the denominators of initial l and r) such that both m.l and m.r always belongs to N, as well as the fact that l and r are bounded.
This construction is a first step toward a study of possible accumulation sets of signal machines. The next step is to look for curves, i.e. non piece-wise rectilinear. We can already adapt the initial configuration (without modifying the machine!) to accumulate on a continuous piece-wise linear function, as shown in Fig. 29.